【动态规划】leetcode 63. 不同路径 II

63. 不同路径 II

题目描述

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

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

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

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

示例1：

输入： obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
输出： 2
解释： 3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：

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

示例2：

输入： obstacleGrid = [[0,1],[0,0]]
输出： 1

示例3：

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

示例4：

输入： m = 3, n = 3
输出： 6

提示

• $m==obstacleGrid.length$
• $n==obstacleGrid[i].length$
• $1<=m,n<=100$
• $obstacleGrid[i][j]为0或1$

方法：动态规划

解题思路

这道题与 62. 不同路径 的区别是多了障碍。

1. 确定 dp 数组以及下标的含义
   dp[i][j] 的定义：表示 (0,0) 出发到 (i,j) 共有 dp[i][j] 条路径。

2. 确定递推公式
   想要求 dp[i][j]，只能有两个方向来推导出来，即 dp[i - 1][j] 和 dp[i][j - 1]。

   但这里需要注意一点，因为有了障碍，(i, j) 如果就是障碍的话应该就保持初始状态（初始状态为0）。

   所以代码为

   if(obstacleGrid[i][j] == 1) continue;
   dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
   

3. dp 数组如何初始化
   (0,0) 到 (0,i) 和 (i,0) 都只有一条路径。

   但如果 (i, 0) 这条边有了障碍之后，障碍之后（包括障碍）都是走不到的位置了，所以障碍之后的dp[i][0] 应该还是初始值0。下标 (0, j) 的初始化情况同理。

   所以初始化代码为：

   for(int i = 0; i < m && obstacleGrid[i][0] == 0; i++)   dp[i][0] = 1;
   for(int i = 0; i < n && obstacleGrid[0][i] == 0; i++)   dp[0][i] = 1;
   

4. 确定遍历顺序
   这里要看一下递归公式 dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，dp[i][j] 都是从其上方和左方推导而来，那么从左到右一层一层遍历就可以了。

5. 举例推导 dp 数组
   拿示例 1：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]

   1	1	1
   1	0	1
   1	1	2

代码

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
        if(obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1)    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 i = 0; i < n && obstacleGrid[0][i] == 0; i++)   dp[0][i] = 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\times m)$。
• 空间复杂度：$O(n\times m)$。