算法训练 | 动态规划Part2 | 62.不同路径、63.不同路径 II

目录

62.不同路径

动态规划法

63. 不同路径 II

动态规划法

---

62.不同路径

• 题目链接：62. 不同路径 - 力扣（LeetCode）

• 文章讲解：代码随想录

动态规划法

• 解题思路

  • 机器人从(0 , 0) 位置出发，到(m - 1, n - 1)终点。

  • 注意思考是先确定数组含义，确实递推公式，初始化数组，确定遍历顺序。但写代码是先确定数组含义，初始化数组，确定遍历顺序，确定递推公式。

• 解题步骤

  • 确定dp数组（dp table）以及下标的含义：dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径。

  • 确定递推公式：想要求dp[i][j]，只能有两个方向来推导出来，即dp[i - 1][j] 和 dp[i][j - 1]。此时在回顾一下 dp[i - 1][j] 表示啥，是从(0, 0)的位置到(i - 1, j)有几条路径，dp[i][j - 1]同理。dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，因为dp[i][j]只有这两个方向过来。

  • dp数组的初始化：如何初始化呢，首先dp[i][0]一定都是1，因为从(0, 0)的位置到(i, 0)的路径只有一条，那么dp[0][j]也同理。

  • 确定遍历顺序：这里要看一下递推公式dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，dp[i][j]都是从其上方和左方推导而来，那么从左到右一层一层遍历就可以了。这样就可以保证推导dp[i][j]的时候，dp[i - 1][j] 和 dp[i][j - 1]一定是有数值的。

  • 举例推导dp数组：

• 代码注意

  • return dp[m - 1][n - 1]; mn实际数组从0开始，需要减1

• 代码一：动态规划

// 时间复杂度：O(m × n)
// 空间复杂度：O(m × n)
class Solution {
public:
    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 - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
};

63. 不同路径 II

• 题目链接：63. 不同路径 II - 力扣（LeetCode）

• 文章讲解：代码随想录

动态规划法

• 解题思路

  • 62.不同路径 (opens new window)中已经详细分析了没有障碍的情况，有障碍的话，其实就是标记对应的dp table（dp数组）保持初始值(0)就可以了

• • 确定dp数组（dp table）以及下标的含义：p[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径。

  • 确定递推公式：递推公式和62.不同路径一样，dp[i][j] = dp[i - 1][j] + dp[i][j - 1]。但这里需要注意一点，因为有了障碍，(i, j)如果就是障碍的话应该就保持初始状态（初始状态为0）。

  • dp数组如何初始化：从(0, 0)的位置到(i, 0)的路径只有一条，所以dp[i][0]一定为1，dp[0][j]也同理。但如果(i, 0) 这条边有了障碍之后，障碍之后（包括障碍）都是走不到的位置了，所以障碍之后的dp[i][0]应该还是初始值0。下标(0, j)的初始化情况同理。注意代码里for循环的终止条件，一旦遇到obstacleGrid[i][0] == 1的情况就停止dp[i][0]的赋值1的操作，dp[0][j]同理。注意起始位置或终止位置有障碍，则结果直接为0。

  • 确定遍历顺序：从递归公式dp[i][j] = dp[i - 1][j] + dp[i][j - 1] 中可以看出，一定是从左到右一层一层遍历，这样保证推导dp[i][j]的时候，dp[i - 1][j] 和 dp[i][j - 1]一定是有数值。

  • 举例推导dp数组：

• 代码一：动态规划

// 时间复杂度：O(n × m)，n、m 分别为obstacleGrid 长度和宽度
// 空间复杂度：O(n × m)
class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1) //如果在起点或终点出现了障碍，直接返回0
            return 0;
        vector<vector<int>> dp(m, vector<int>(n, 0));
        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];
    }