每日算法33_2020-12-09

来源：题库 - 力扣 (LeetCode) (leetcode-cn.com)。侵删。

题目一

62. 不同路径

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

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

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

示例 1:

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

1. 向右 -> 向右 -> 向下
2. 向右 -> 向下 -> 向右
3. 向下 -> 向右 -> 向右

示例 2:

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

提示：

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

我的答案递归，但超时了

class Solution {
    public int uniquePaths(int m, int n) {
        // 先一直向右，右边没路了，再回退一格然后向下，再接着向右
        // 起始点是1,1;终止点是m,n
        int ret = 0;
        
        return ret + go(1, 1, m, n);
    }

    // 递归
    public int go(int x, int y, int m, int n){
        int ret = 0;
        if(x == m && y == n){
            return 1;
        }else{
            if(x+1 <= m) ret += go(x+1, y, m, n); // 先往右走
            if(y+1 <= n) ret += go(x, y+1, m, n); // 再向下走
        }
        return ret;
    }
}

官方答案方法一：动态规划

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] f = new int[m][n];
        for (int i = 0; i < m; ++i) {
            f[i][0] = 1;
        }
        for (int j = 0; j < n; ++j) {
            f[0][j] = 1;
        }
        /*
        这两行的目的是
        假设为7,3的地盘，就变为
        1 1 1 1 1 1 1
        1
        1
        这些1为边界点，也是到这些1点的行走方案
        那么再往下执行代码就变成
        1 1 1 1  1  1  1
        1 2 3 4  5  6  7
        1 3 6 10 15 21 28
        即(2,2)这个点的方案数，就等于到(1,2)和(2,1)的方案数之和
        其他等同
        这有点类似于杨辉三角
        */
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                f[i][j] = f[i - 1][j] + f[i][j - 1];
            }
        }
        return f[m - 1][n - 1]; // 返回右下角在数组中的值即为结果
    }
}

复杂度分析

时间复杂度：O(mn。

空间复杂度：O(mn)，即为存储所有状态需要的空间。注意到 f(i, j) 仅与第 i 行和第 i-1 行的状态有关，因此我们可以使用滚动数组代替代码中的二维数组，使空间复杂度降低为 O(n)。此外，由于我们交换行列的值并不会对答案产生影响，因此我们总可以通过交换 m 和 n 使得 m≤n，这样空间复杂度降低至O(min(m,n))。

优化1：空间复杂的O(2n)

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

优化2：空间复杂度O(n)

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

优化1/2来自于

作者：powcai
链接：https://leetcode-cn.com/problems/unique-paths/solution/dong-tai-gui-hua-by-powcai-2/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

官方方法二：组合数学

思路与算法

从左上角到右下角的过程中，我们需要移动 m+n−2 次，其中有m−1 次向下移动，n-1次向右移动。因此路径的总数，就等于从m+n−2 次移动中选择 m−1 次向下移动的方案数，即组合数：

$$C_{m+n-2}^{m-1}=\left(\genfrac{}{}{0ex}{}{m+n-2}{m-1}\right)=\frac{(m+n-2)(m+n-3)\cdots n}{(m-1)!}=\frac{(m+n-2)!}{(m-1)!(n-1)!}$$

因此我们直接计算出这个组合数即可。计算的方法有很多种：

如果使用的语言有组合数计算的 API，我们可以调用 API 计算；

如果没有相应的 API，我们可以使用
$$\frac{(m+n-2)(m+n-3)\cdots n}{(m-1)!}$$

进行计算。

class Solution {
    public int uniquePaths(int m, int n) {
        long ans = 1;
        for (int x = n, y = 1; y < m; ++x, ++y) {
            ans = ans * x / y;
        }
        return (int) ans;
    }
}

复杂度分析

时间复杂度：O(m)。由于我们交换行列的值并不会对答案产生影响，因此我们总可以通过交换 m 和 n 使得 m≤n，这样空间复杂度降低至O(min(m,n))。

空间复杂度：O(1)。

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/unique-paths/solution/bu-tong-lu-jing-by-leetcode-solution-hzjf/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

其他方法：排列组合

class Solution {
    public int uniquePaths(int m, int n) {
        //只跟第几行第几列有关，从m+n-2步中抽出m-1步
        long ans=1;
        for(int i=0;i<Math.min(m-1,n-1);i++){            
            ans*=m+n-2-i;
            ans/=i+1;           
        }
        return (int)ans;
    }
}

来自于：https://leetcode-cn.com/problems/unique-paths/solution/dong-tai-gui-hua-by-powcai-2/477342