代码随想录算法训练营第三期day39-动态规划02

目录

1. T62：不同路径

1.1 版本Ⅰ、非压缩版（二维数组）

1.2 版本Ⅱ、压缩版（一维数组，比较不好理解）

2. T63：不同路径Ⅱ

2.1 版本Ⅰ、非压缩版

2.2 版本Ⅱ、压缩版

---

1. T62：不同路径

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

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

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

提示：

• 1 <= m, n <= 100

• 题目数据保证答案小于等于 2 * 109

S：一度想着是不是要用递归，不过早就不太会写了。。。

版本Ⅱ相对来说不那么好理解，还是首先理解版本Ⅰ为重~

1.1 版本Ⅰ、非压缩版（二维数组）

C++：

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

Java：

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

• 时间复杂度：O(m × n)

• 空间复杂度：O(m × n)

其实用一个一维数组（也可以理解是滚动数组）就可以了，但是不利于理解，可以优化点空间，建议先理解了二维，再理解一维。

1.2 版本Ⅱ、压缩版（一维数组，比较不好理解）

C++：

    int uniquePaths(int m, int n) {
        vector<int> dp(n, 1);
        for (int i = 1; i < m; ++i) {
            for (int j = 1; j < n; ++j) {
                dp[j] += dp[j - 1];// 🚩【就是这行不太好理解！】
            }
        }
        return dp[n - 1];
    }

Java：

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

• 时间复杂度：O(m × n)

• 空间复杂度：O(n)

2. T63：不同路径Ⅱ

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

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

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。

提示：

• m == obstacleGrid.length

• n == obstacleGrid[i].length

• 1 <= m, n <= 100

• obstacleGrid[i][j] 为 0 或 1

S：跟上一题的唯一区别就是有障碍物。

版本Ⅱ和上一题又有不同，不是完全照搬就可以的！

2.1 版本Ⅰ、非压缩版

C++：

    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
        // 如果在起点或终点出现了障碍，直接返回0
        if (obstacleGrid[0][0] || obstacleGrid[m - 1][n - 1]) return 0;
        vector<vector<int>> dp(m, vector<int>(n, 0));
        // for (int i = 0; i < m; ++i) dp[i][0] = 1;
        // for (int j = 0; j < n; ++j) dp[0][j] = 1;
        for (int i = 0; i < m && !obstacleGrid[i][0]; ++i) dp[i][0] = 1;
        for (int j = 0; j < n && !obstacleGrid[0][j]; ++j) dp[0][j] = 1;
        for (int i = 1; i < m; ++i) {
            for (int j = 1; j < n; ++j) {
                // if (obstacleGrid[i][j] == 1) continue;
                // dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                
                // if (!dp[i][j]) {// 犯傻！
                if (!obstacleGrid[i][j]) {
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }
            }
        }
        return dp[m - 1][n - 1];
    }

Java：

    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length, n = obstacleGrid[0].length;
        if (obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1) return 0;
        int[][] dp = new int[m][n];
        for (int i = 0; i < m && obstacleGrid[i][0] == 0; ++i) dp[i][0] = 1;
        for (int j = 0; j < n && obstacleGrid[0][j] == 0; ++j) dp[0][j] = 1;
        for (int i = 1; i < m; ++i) {
            for (int j = 1; j < n; ++j) {
                if (obstacleGrid[i][j] == 1) continue;
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }

• 时间复杂度：O(n × m)，n、m 分别为obstacleGrid 长度和宽度

• 空间复杂度：O(n × m)

同样可以升级为空间优化版本：

2.2 版本Ⅱ、压缩版

有3处🚩：不同于上一题一维数组版的重要理解点~

C++：

    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
        if (obstacleGrid[0][0] || obstacleGrid[m - 1][n - 1]) return 0;
        vector<int> dp(n, 0);
        // for (int j = 0; j < n && !obstacleGrid[0][j]; ++j) dp[j] = 1;
        for (int j = 0; j < n; ++j) {
            if (!j) {
                dp[j] = 1;
            } else if (obstacleGrid[0][j]) {
                dp[j] = 0;
            } else {
                dp[j] = dp[j - 1];// 1、🚩
            }
        }
        for (int i = 1; i < m; ++i) {
            // for (int j = 1; j < n; ++j) { // 2、🚩障碍物的位置随机
            for (int j = 0; j < n; ++j) {
                // if (obstacleGrid[i][j]) continue;
                if (obstacleGrid[i][j] == 1) {
                    dp[j] = 0;// 3、🚩
                // } else {
                } else if (j){
                    dp[j] += dp[j - 1];
                }
            }
        }
        return dp.back();
    }

Java：

    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length, n = obstacleGrid[0].length;
        if (obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1) return 0;
        int[] dp = new int[n];
        for (int i = 0; i < n; ++i) {
            if (i == 0) {
                dp[i] = 1;
            } else if (obstacleGrid[0][i] == 1) {
                dp[i] = 0;
            } else {
                dp[i] = dp[i - 1];
            }
        }
        for (int i = 1; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (obstacleGrid[i][j] == 1) {
                    dp[j] = 0;
                } else if (j != 0) {
                    dp[j] += dp[j - 1];
                }
            }
        }
        return dp[n - 1];
    }