LeetCode 62. Unique Paths

问题描述

• 地址

问题分析

• 求从一个棋盘的左上角到右下角共有多少种路径，只能向下或者向右走。该题类似于 LeetCode 64. Minimum Path Sum , 只不过 64是求最短路径和，是最优子结构问题。该题是统计数目。
• 该题动态规划有两种思路: 把[i,j] 看成是起点还是终点
  
  • dp[i][j] 表示从[i,j] 出发到 [m,n] 共有多少条路径, dp[i][j] = dp[i][j + 1] + dp[i + 1][j], 初始条件为 dp[m][n] = 1该题实现用的这种看做起点的思路。
  • dp[i][j] 表示从左上角出发到 [i,j] 共有多少条路径，dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，初始条件为 dp[1][1] = 1,跳台阶问题便是用的这种看做终点的思路。
• 同样，根据依赖关系可知，该题也可以实现动态规划的空间优化。
• 此外，该题除了动态规划，还有数学解法。因为是从左上角和右下角，向下走m-1步，向右走n-1步，一共可以走m - 1 + n - 1步，每一次要么向下，要么向右，所以一共的路径数其实是一个组合问题，可能性个数为 C(m - 1 + n - 1， m-1),所以可以不用额外空间便能求到。
• 如何只用一个循环求组合数 C(N, k)
  
  • Combination(N, k) = P(N, k)/ k! = n! / (k!(n - k)!) = ( (n - k + 1) * (n - k + 2) * ... * n ) / k!

         long res = 1;
        // here we calculate the total possible path number 
        // Combination(N, k) = P(N, k)/ 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;
        }

经验教训

• 该类型动态规划题目的两种思路： 把[i,j] 看成是起点还是终点
• 求解组合问题

代码实现

• 递归（TLE）

    public int uniquePaths(int m, int n) {
        return findPaths(1, 1, m, n);
    }

    //从[i,j]出发，到[m,n]的共有多少条路径
    public int findPaths(int i, int j, int m, int n) {
        if (i == m && j == n) {
            return 1;
        }
        if (i > m || j > n) {
            return 0;
        }
        //从下方出发与从右方出发的路径和
        return findPaths(i + 1, j, m, n) + findPaths(i, j + 1, m, n);
    }

• 动态规划

    public int uniquePaths(int m, int n) {
        if (m < 0 || n < 0) {
            return 0;
        }
        //dp[i][j]：从[i,j]出发，到[m,n]的路径数
        int[][] dp = new int[m + 1][n + 1];
        for (int j = 1; j <= n; ++j) {
            dp[m][j] = 1;
        }
        for (int i = m - 1; i >= 1; --i) {
            dp[i][n] = 1;
            for (int j = n - 1; j >= 1; --j) {
                dp[i][j] = dp[i + 1][j] + dp[i][j + 1];
            }
        }
        return dp[1][1];
    }

• 动态规划空间优化

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

• 数学（组合问题）求解

    public int uniquePaths(int m, int n) {
        int N = m + n - 2;// how much steps we need to do
        int k = Math.min(m - 1, n - 1);// number of steps that need to go down or go right
        long 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;
        }
        //其实当m = 100, n=100时，早就超了，不是很懂这题的测试用例
        return (int)res;
    }