Solve 'Unique Paths' problems

Author: rayworks

src/main/java/org/sean/recursive/UniquePaths.java

@@ -0,0 +1,41 @@
+package org.sean.recursive;
+
+import java.util.Arrays;
+
+/***
+ * 62. Unique Paths
+ */
+public class UniquePaths {
+    private int[][] cache;
+    public int uniquePaths(int m, int n) {
+
+        if(cache == null) {
+            cache = new int[m][n];
+            for(int i = 0; i < m; i++) {
+                Arrays.fill(cache[i], -1);
+            }
+        }
+
+        if(m >= 1 && n >= 1 && cache[m -1][n - 1] >= 0) {
+            return cache[m -1][n - 1];
+        }
+
+        if(m <= 0 || n <= 0)
+            return 0;
+
+        if(m == 1 && n == 1)
+            return 1;
+
+        int up = uniquePaths(m -1, n);
+        int left = uniquePaths(m, n - 1);
+
+        if(m - 1 > 0 && n > 0) {
+            cache[m - 2][n - 1] = up;
+        }
+
+        if(m > 0 && n - 1 > 0) {
+            cache[m - 1][n - 2] = left;
+        }
+        return  up + left;
+    }
+}

src/main/java/org/sean/recursive/UniquePaths2.java

@@ -0,0 +1,58 @@
+package org.sean.recursive;
+
+import java.util.Arrays;
+
+/** * 63. Unique Paths II */
+public class UniquePaths2 {
+    private int[][] cache;
+
+    /**
+     * * Counts the unique path for an obstacle Grid
+     *
+     * @param m width of grid
+     * @param n height of grid
+     * @param obstacleGrid two-dimensional array
+     * @return number of unique path from [0, 0] -> [m-1, n-1]
+     */
+    private int uniquePaths(int m, int n, int[][] obstacleGrid) {
+
+        if (cache == null) {
+            cache = new int[m][n];
+            for (int i = 0; i < m; i++) {
+                Arrays.fill(cache[i], -1);
+            }
+        }
+
+        if (m >= 1 && n >= 1 && cache[m - 1][n - 1] >= 0) {
+            return cache[m - 1][n - 1];
+        }
+
+        if (m <= 0 || n <= 0) return 0;
+
+        // check the start point
+        if (m == 1 && n == 1) return obstacleGrid[m - 1][n - 1] == 1 ? 0 : 1;
+
+        if (obstacleGrid[m - 1][n - 1] == 1) {
+            // blocked node
+            return 0;
+        }
+
+        int up = uniquePaths(m - 1, n, obstacleGrid);
+        int left = uniquePaths(m, n - 1, obstacleGrid);
+
+        if (m - 1 > 0 && n > 0) {
+            cache[m - 2][n - 1] = up;
+        }
+
+        if (m > 0 && n - 1 > 0) {
+            cache[m - 1][n - 2] = left;
+        }
+        return up + left;
+    }
+
+    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
+        if (obstacleGrid == null || obstacleGrid.length == 0) return 0;
+
+        return uniquePaths(obstacleGrid.length, obstacleGrid[0].length, obstacleGrid);
+    }
+}

src/test/java/org/sean/recursive/UniquePaths2Test.java

@@ -0,0 +1,35 @@
+package org.sean.recursive;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class UniquePaths2Test {
+
+    private UniquePaths2 uniquePaths2;
+
+    @Before
+    public void setUp() {
+        uniquePaths2 = new UniquePaths2();
+    }
+
+    @Test
+    public void uniquePathsWithObstacles() {
+        int count =
+                uniquePaths2.uniquePathsWithObstacles(
+                        new int[][] {
+                            new int[] {0, 0, 0},
+                            new int[] {0, 1, 0},
+                            new int[] {0, 0, 0}
+                        });
+
+        Assert.assertEquals(2, count);
+    }
+
+    @Test
+    public void testEmptyPath() {
+        int count = uniquePaths2.uniquePathsWithObstacles(new int[][] {new int[] {1}});
+
+        Assert.assertEquals(0, count);
+    }
+}

src/test/java/org/sean/recursive/UniquePathsTest.java

@@ -0,0 +1,22 @@
+package org.sean.recursive;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class UniquePathsTest {
+
+    private UniquePaths paths;
+
+    @Before
+    public void setUp() throws Exception {
+        paths = new UniquePaths();
+    }
+
+    @Test
+    public void uniquePaths() {
+        Assert.assertEquals(3, paths.uniquePaths(3,2));
+    }
+}