Giant Chess board

Author: gkcs

src/main/java/main/java/videos/GiantChessBoard.java

@@ -0,0 +1,86 @@
+package main.java.videos;
+
+import main.java.InputReader;
+
+import java.math.BigInteger;
+import java.util.Arrays;
+
+public class GiantChessBoard {
+    private static long mod = (long) (1e9 + 7);
+    private static long[] fact = generateFactorials(1000000);
+    private static long[] invFact = generateReverseFactorials(1000000);
+
+    public static void main(final String[] args) {
+        final InputReader in = new InputReader(System.in);
+        final int n = in.readInt();
+        final int m = in.readInt();
+        final int k = in.readInt();
+        final Point point[] = new Point[k];
+        for (int i = 0; i < k; i++) {
+            point[i] = new Point(in.readInt(), in.readInt());
+        }
+        Arrays.sort(point);
+        final int[] x = new int[k + 1];
+        final int[] y = new int[k + 1];
+        for (int i = 0; i < k; i++) {
+            x[i] = point[i].x;
+            y[i] = point[i].y;
+        }
+        x[k] = n;
+        y[k] = m;
+        final long[] dp = new long[k + 1];
+        for (int i = 0; i <= k; i++) {
+            dp[i] = comb(x[i] - 1, x[i] - 1 + y[i] - 1);
+            for (int j = 0; j < i; j++) {
+                if (y[j] <= y[i]) {
+                    dp[i] -= dp[j] * comb(x[i] - x[j], x[i] - x[j] + y[i] - y[j]) % mod;
+                }
+            }
+            dp[i] = ((dp[i] % mod) + mod) % mod;
+        }
+        long result = dp[k];
+        System.out.println(result);
+    }
+
+    private static long comb(final int m, final int n) {
+        return (((fact[n] * invFact[m]) % mod) * invFact[n - m]) % mod;
+    }
+
+    public static long[] generateFactorials(int count) {
+        long[] result = new long[count];
+        result[0] = 1;
+        for (int i = 1; i < count; i++) {
+            result[i] = (result[i - 1] * i) % mod;
+        }
+        return result;
+    }
+
+    public static long[] generateReverseFactorials(int upTo) {
+        final long[] reverseFactorials = new long[upTo];
+        reverseFactorials[0] = reverseFactorials[1] = 1;
+        final BigInteger BIG_MOD = BigInteger.valueOf(mod);
+        for (int i = 1; i < upTo; i++) {
+            reverseFactorials[i] = (BigInteger.valueOf(i).modInverse(BIG_MOD).longValue() * reverseFactorials[i - 1]) % mod;
+        }
+        return reverseFactorials;
+    }
+}
+
+class Point implements Comparable<Point> {
+    final int x, y;
+
+    Point(final int x, final int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    @Override
+    public int compareTo(final Point other) {
+        if (x < other.x) {
+            return -1;
+        } else if (x > other.x) {
+            return 1;
+        }
+        return this.y - other.y;
+    }
+}