148、【动态规划】leetcode ——63. 不同路径 II：递归法+迭代法（C++/Python版本）

题目描述

原题链接：63. 不同路径 II

解题思路

本题和 62. 不同路径（递归法+迭代法） 的区别在于多了障碍物，并不是所有的路径都可以走。因此，可以让遇到为1的时候不统计，遇到为0的时候统计。这样子就可以让障碍物的位置对应的为0。例如dp[i-1][j]为障碍物位置，dp[i][j]和dp[i][j-1]不为障碍物，此时dp[i][j] = 0 + dp[i][j-1]，仅有非障碍物的路径才能被统计上。

动态规划五部曲：

（1）dp[i][j]含义： 从1,1出发到达i,j时，可以有几种方式。

（2）递推公式： dp[i][j] = d[i - 1][y] + d[i][j - 1]，因为从1,1到达m,n，只能通过右移或下移。到达i,j位置，可以基于i-1,j或i,j-1的位置移动过来。

（3）dp数组初始化： 递归法初始化为0，迭代法将dp[1][1]初始化为1。

（4）遍历顺序： 递归方式从m,n到1,1相当于后序遍历，迭代方式从1,1到m,n相当于先序遍历。

（5）举例： 2,2，可来自于1,2或2,1，而1,2和2,1都只能来自于1,1因此，到达1,2和2,1的方式有一种，到达2,2的方式有两种：dp[2][2] = dp[2 - 1][1] + dp[2][2 - 1]。

（1）递归法

class Solution {
public:
    int dp[101][101] = {0};
    int traversal(vector<vector<int>>& obstacleGrid, int x, int y) {
        if(x < 0 || y < 0 || obstacleGrid[x][y] == 1)       return 0;
        else if(x == 0 && y == 0)                           return 1;

        if(dp[x][y] != 0)                                   return dp[x][y];
        dp[x][y] = traversal(obstacleGrid, x - 1, y) + traversal(obstacleGrid, x, y - 1);
        
        return dp[x][y];
    }
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        return traversal(obstacleGrid, obstacleGrid.size() - 1, obstacleGrid[0].size() - 1);
    }
};

（2）迭代法

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        if(obstacleGrid[0][0] == 1)            return 0;

        int dp[101][101] = {0};
        dp[0][0] = 1;
        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
        
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                if(obstacleGrid[i][j] == 0) {   
                    // 仅统计不为1的路径
                    if(i > 0 && obstacleGrid[i - 1][j] != 1)       dp[i][j] = dp[i - 1][j];
                    if(j > 0 && obstacleGrid[i][j - 1] != 1)       dp[i][j] += dp[i][j - 1];
                }
            }
        }
        
        return dp[m - 1][n - 1];
    }
};

Python

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        m, n = len(obstacleGrid), len(obstacleGrid[0])
        if obstacleGrid[0][0] == 1 or obstacleGrid[m - 1][n - 1] == 1:
            return 0

        dp = [[0] * (n + 1) for _ in range(m + 1)]
        dp[1][1] = 1
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if obstacleGrid[i - 1][j - 1] == 0:
                    if i > 1 and obstacleGrid[i - 2][j - 1] == 0:
                        dp[i][j] = dp[i - 1][j]
                    if j > 1 and obstacleGrid[i - 1][j - 2] == 0:
                        dp[i][j] += dp[i][j - 1]                


        return dp[m][n]

另一种写法

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        if(obstacleGrid[0][0] == 1)         return 0;
        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
        // 边界顺着一条路走，只有一种方案，当遇到石头时停止，后续都为0
        for(int i = 1; i <= m && obstacleGrid[i - 1][0] == 0; i++)       dp[i][1] = 1;
        for(int i = 1; i <= n && obstacleGrid[0][i - 1] == 0; i++)       dp[1][i] = 1;

		// (1, j)和(i, 1) 都已经探寻过，从(2, 2)开始。（若从1，1开始的话，由于dp[0][j]和dp[i][0]都是0，就i会将已经初始化好的(1, 1)的值给覆盖掉。）
        for(int i = 2; i <= m; i++) {
            for(int j = 2; j <= n; j++) {
                if(obstacleGrid[i - 1][j - 1] == 0) {                    
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }
            }
        }

        return dp[m][n];

    }
};

Python

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        m, n = len(obstacleGrid), len(obstacleGrid[0])
        if obstacleGrid[0][0] == 1 or obstacleGrid[m - 1][n - 1] == 1:
            return 0

        dp = [[0] * (n + 1) for _ in range(m + 1)]
        for i in range(1, m + 1):
            if obstacleGrid[i - 1][0] == 1:
                break
            dp[i][1] = 1
                
        for i in range(1, n + 1):
            if obstacleGrid[0][i - 1] == 1:
                break
            dp[1][i] =1 
        for i in range(2, m + 1):
            for j in range(2, n + 1):
                if obstacleGrid[i - 1][j - 1] == 0:
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
        
        return dp[m][n]



        return dp[m][n]

参考文章：[63. 不同路径 II] (https://programmercarl.com/0063.%E4%B8%8D%E5%90%8C%E8%B7%AF%E5%BE%84II.html#%E6%80%9D%E8%B7%AF)