递归，动态规划，排列组合解决不同路径|

题目描述：一个机器人位于一个 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

方法一：

递归法

该方法参考博客不同路径|，直接上代码，可以举一个例子，多画一画，好理解了
java语言实现

class Solution
{


public int uniquePaths(int m, int n) {

    HashMap<String, Integer> visited = new HashMap<>();

    return getAns(0, 0, m - 1, n - 1, 0, visited); 



}

private int getAns(int x, int y, int m, int n, int num, HashMap<String, Integer> visited) {

    if (x == m && y == n) {

        return 1;

    }

    int n1 = 0;

    int n2 = 0;

    String key = x + 1 + "." + y;

    //判断当前点是否已经求过了

    if (!visited.containsKey(key)) {

        if (x + 1 <= m) {

            n1 = getAns(x + 1, y, m, n, num, visited);

        }

    } else {

        n1 = visited.get(key);

    }

    key = x + "@" + (y + 1);

    if (!visited.containsKey(key)) {

        if (y + 1 <= n) {

            n2 = getAns(x, y + 1, m, n, num, visited);

        }

    } else {

        n2 = visited.get(key);

    }

    //将当前点加入 visited 中

    key = x + "." + y;

    visited.put(key, n1+n2);

    return n1 + n2;

}}

方法二：

动态规划

1. 定义状态转移方程
   dp[i][j]表示是从起点到终点i，j的最多的路径数

2. 方程描述
   dp[i][j]=dp[i-1][j]+dp[i][j-1]

3. 初始化
   对于第一行，或者第一列的所有数都初始化为1，因为终点在第一行或者第一列的话，总起点到终点只会有一条路径，要不就一直向下，要不就一直向右

4. 考虑优化空间

java代码实现

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];  
    }
}

也可以只使用一维数组实现
首先一维数组初始化全为1

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

方法三:

排列组合

假设网格规格为m*n,那么不管那一条可以到达终点的路径，始终是向右走了n-1次，向下走了m-1次，所以一共走了m+n-2次，我们需要解决的是有多少可走的方案，那么问题可以转化为在这m+n-2次中选择m-1步向右的组合问题，
总共有C(m+n-2,m-1)种排列方式。

根据公式C(n,m) = n!/m!*(n-m)!==(n∗(n−1)∗(n−2)∗…(n−m+1))/m!。

但是实际上也不需要把所有的阶乘都算出来，如下

public int uniquePaths(int m, int n) {

    int N = n + m - 2; 

    int k = m - 1;  

    long res = 1; 

    for (int i = 1; i <= k; i++)

        res = res * (N - k + i) / i;

    return (int) res; 

}