62. Unique Paths

题目：

A robot is located at the top-left corner of a m x ngrid (marked 'Start' in the diagram below).

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?

Above is a 3 x 7 grid. How many possible unique paths are there?

Note: m and n will be at most 100.

链接： http://leetcode.com/problems/unique-paths/

4/16/2017

1ms，8%

一开始几乎忘记怎么做了，决定好好研究DP

注意：

第7行初始值设为1

public class Solution {
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i == 0 && j == 0) dp[i][j] = 1;
                else if (i == 0) dp[i][j] = dp[i][j - 1];
                else if (j == 0) dp[i][j] = dp[i - 1][j];
                else dp[i][j] = dp[i][j - 1] + dp[i - 1][j];
            }
        }
        return dp[m - 1][n - 1];
    }
}

还可以用一维数组rolling array来计算，参考别人答案。多一个元素是为了免掉第一次的全部赋值。

为什么用了一维数组还是可以的呢？虽然是一维，但是每次i有变化时,res又被重复使用，之前dp[i-1][j]这一部分是在之前算过了。（感觉还是没有解释好）

public class Solution {
    public int uniquePaths(int m, int n) {
        if (m < 0 || n < 0) return 0;
        int[] dp = new int[n + 1];
        dp[0] = 1;
        
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                dp[j] += dp[j - 1];
            }
        }
        return dp[n - 1];
    }
}

关于rolling array很详细的解释

https://discuss.leetcode.com/topic/15265/0ms-5-lines-dp-solution-in-c-with-explanations

如何实现combination的实现

https://discuss.leetcode.com/topic/2734/my-ac-solution-using-formula

class Solution {
    public:
        int uniquePaths(int m, int n) {
            int N = n + m - 2;// how much steps we need to do
            int k = m - 1; // number of steps that need to go down
            double res = 1;
            // here we calculate the total possible path number 
            // Combination(N, k) = n! / (k!(n - k)!)
            // reduce the numerator and denominator and get
            // C = ( (n - k + 1) * (n - k + 2) * ... * n ) / k!
            for (int i = 1; i <= k; i++)
                res = res * (N - k + i) / i;
            return (int)res;
        }
    };

通过permutation来实现combination

https://discuss.leetcode.com/topic/19613/math-solution-o-1-space

public class Solution {
    public int uniquePaths(int m, int n) {
        if(m == 1 || n == 1)
            return 1;
        m--;
        n--;
        if(m < n) {              // Swap, so that m is the bigger number
            m = m + n;
            n = m - n;
            m = m - n;
        }
        long res = 1;
        int j = 1;
        for(int i = m+1; i <= m+n; i++, j++){       // Instead of taking factorial, keep on multiply & divide
            res *= i;
            res /= j;
        }
            
        return (int)res;
    }
}

更多讨论：

https://discuss.leetcode.com/category/70/unique-paths