Unique Paths I && II

Change-Id: Ibab38e244528511dc534f98c90100e88425307c5

Author: applewjg

UniquePaths.java

@@ -0,0 +1,49 @@
+/*
+ Author:     King, [email protected]
+ Date:       Oct 9, 2014
+ Problem:    Unique Paths
+ Difficulty: Easy
+ Source:     https://oj.leetcode.com/problems/unique-paths/
+ Notes:
+ A robot is located at the top-left corner of a m x n grid.
+ The robot can only move either down or right at any point in time. The robot is trying to reach 
+ the bottom-right corner of the grid (marked 'Finish' in the diagram below).
+ How many possible unique paths are there?
+
+ Solution: 
+ 1. Use formula C(x,t) = t!/(x!*(t-x)!) (x should be large for calculation).
+ 2. Dynamic programming. UP(i,j) = UP(i-1,j) + UP(i,j-1).
+ */
+public class Solution {
+    public int uniquePaths_1(int m, int n) {
+        if (m == 1  || n == 1) return 1;
+        int t = (m-1)+(n-1);
+        int x = (m > n) ? (m-1) : (n-1);
+        long res = 1;
+        for (int i = t; i > x; i--) res *= i;
+        for (int i = t-x; i > 1; i--) res /= i;
+        return (int)res;
+    }
+    public int uniquePaths_2(int m, int n) {
+        if (m == 1  || n == 1) return 1;
+        int[][] dp = new int[m][n];
+        for (int i = 0; i < m; i++)
+            dp[i][0] = 1;
+        for (int j = 0; j < n; j++)
+            dp[0][j] = 1;
+        for (int i = 1; i < m; i++)
+            for (int j = 1; j < n; j++)
+                dp[i][j] = dp[i-1][j] + dp[i][j-1];
+        return dp[m-1][n-1];
+    }
+    public int uniquePaths(int m, int n) {
+        if (m == 1  || n == 1) return 1;
+        int[] dp = new int[n];
+        for (int j = 0; j < n; j++)
+            dp[j] = 1;
+        for (int i = 1; i < m; i++)
+            for (int j = 1; j < n; j++)
+                dp[j] = dp[j] + dp[j-1];
+        return dp[n-1];
+    }
+}

UniquePathsII.java

@@ -0,0 +1,57 @@
+/*
+ Author:     King, [email protected]
+ Date:       Dec 25, 2014
+ Problem:    Unique Paths II
+ Difficulty: Easy
+ Source:     https://oj.leetcode.com/problems/unique-paths-ii/
+ Notes:
+ Follow up for "Unique Paths":
+ Now consider if some obstacles are added to the grids. How many unique paths would there be?
+ An obstacle and empty space is marked as 1 and 0 respectively in the grid.
+ For example,
+ There is one obstacle in the middle of a 3x3 grid as illustrated below.
+ [
+  [0,0,0],
+  [0,1,0],
+  [0,0,0]
+ ]
+ The total number of unique paths is 2.
+ Note: m and n will be at most 100.
+
+ Solution: Dynamic programming.
+ */
+
+public class Solution {
+    public int uniquePathsWithObstacles_1(int[][] obstacleGrid) {
+        int m = obstacleGrid.length;
+        int n = obstacleGrid[0].length;
+        int[][] dp = new int[m][n];
+        if (obstacleGrid[0][0] == 1) return 0;
+        dp[0][0] = 1;
+        for (int i = 1; i < m; i++)
+            dp[i][0] = obstacleGrid[i][0] == 1 ? 0 : dp[i-1][0];
+        for (int j = 1; j < n; j++)
+            dp[0][j] = obstacleGrid[0][j] == 1 ? 0 : dp[0][j-1];
+        
+        for (int i = 1; i < m; i++)
+            for (int j = 1; j < n; j++)
+                dp[i][j] = obstacleGrid[i][j] == 1 ? 0: dp[i-1][j] + dp[i][j-1];
+        
+        return dp[m-1][n-1];  
+    }
+    public int uniquePathsWithObstacles_2(int[][] obstacleGrid) {
+        int m = obstacleGrid.length;
+        if (m == 0) return 0;
+        int n = obstacleGrid[0].length;
+        int[] dp = new int[n];
+        if(obstacleGrid[0][0] == 1 || obstacleGrid[m-1][n-1] == 1) return 0;
+        dp[0] = 1;
+        for (int i = 0; i < m; ++i) {
+            dp[0] = obstacleGrid[i][0] == 1 ? 0 : dp[0];
+            for(int j = 1; j < n; ++j) {
+                 dp[j] = obstacleGrid[i][j] == 1 ? 0: dp[j] + dp[j-1];
+            }
+        }
+        return dp[n-1];
+    }
+}