LeetCode——62题：不同路径

问题

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

问总共有多少条不同的路径？

例如，上图是一个7 x 3 的网格。有多少可能的路径？

示例 1:

输入: m = 3, n = 2
输出: 3
解释:
从左上角开始，总共有 3 条路径可以到达右下角。
1. 向右 -> 向右 -> 向下
2. 向右 -> 向下 -> 向右
3. 向下 -> 向右 -> 向右

示例 2:

输入: m = 7, n = 3
输出: 28

提示：

1 <= m, n <= 100
题目数据保证答案小于等于 2 * 10 ^ 9

问题分析

这个问题和爬楼梯的问题看着很类似，最后都是求总共有多少中走法或者路径。这种问题看着毫无章法，其实暗地中都有着彼此的联系。首先我们先随便代入几个值，看有几条路径。

例子1

输入m=3,n=1
从左上角开始，总共有 1 条路径可以到达右下角。
1、向右 ->向右

例子2

输入m=1,n=4
从左上角开始，总共有 1 条路径可以到达右下角。
1、向下 ->向下 ->向下 

例子3

输入m=2,n=3
从左上角开始，总共有 3 条路径可以到达右下角。
1、向右 ->向下 ->向下
2、向下 ->向下 ->向右 
3、向下 ->向右 ->向下

上面几个示例和例子中可以发现规律：

1. 如果m或者n有一个为1的话，就只有一个条路径。
2. 如果m和n互换，最后结果还是一样的。

似乎上面的的两个发现，任然解决不了问题，接着我们可以多算几组，然后将算好的结果填到对应的表格中。（画的有点丑）

从中不难发现此题的规律，表格的第一行和第一列都为1，而其他地方的值分别是它左边和上面相邻的值的和。

提取出来就是: num(m,n) = num(m-1,n)+num(m,n-1)

方法一：递归法（LeetCode中超时）

class Solution {
    public int uniquePaths(int m, int n) {
        if(m==1||n==1) return 1;
        int result=0;
        result+=uniquePaths(m,n-1)+uniquePaths(m-1,n);
        return result;
    }
}

方法二：动态规划算法
1、二维数组方法

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        for (int i = 0; i < n; i++) dp[0][i] = 1;
        for (int i = 0; i < m; i++) dp[i][0] = 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];  
    }
}

2、优化为一维数组

class Solution {
    public int uniquePaths(int m, int n) {
        int[] a = new int[n];
        Arrays.fill(a, 1);
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++) {
                a[j]+=a[j-1];
            }
        }
        return a[n-1];
    }
}

其实对这些数字敏感的话，马上就能发现它们就是杨辉三角嘛。

而杨辉三角中有一条特性：第n行的m个数可表示为 C(n-1，m-1)，即为从n-1个不同元素中取m-1个元素的组合数。举个例子：第五行第二个为4，也就是从4个元素中取一个的组合数，等于4。

而将表格中的数据转换成接近杨辉三角排列方式

比如输入的是m=7,n=3,那么该数在第9行，第三个，通过自由组合即可算出值。

方法三：公式法

 class Solution {
    public int uniquePaths(int m, int n) {
        if(m==1||n==1) return 1;
        int num = m+n-1-1;
        int select = n-1;
        if(select>num/2) select = num-select;
        return factorial(num,num-select)/factorial(select,1);
        
    }
    public int factorial(int n,int m) {
        int result=1;
        while (n>m) {
            result*=n;
            n--;
        }
        return result;
    }
}

如果m,n大于10，会出现溢出的情况。