leetcode：63. 不同路径 II

题目来源

• leetcode：unique-paths-ii

题目描述

[0][0]直接就是障碍物我是万万想不到的[震惊]

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {

    }
};

题目解析

递归

• 如果没有障碍物的话，从(0, 0)出发，每次只能往下走、或者往右走。
• 假设i表示行、j表示列，当前点为(i,j)，那么每次只能往(i + 1, j)移动、或者往(i, j + 1)移动。、
  
• 对于有障碍物的情况下怎么办呢？其实也简单，直接返回0就可以了，此时不可能移动到已经被占的位置
• 可以看成是跳格子。如果格子已经被占了，那么无论如何都不可能跳到这个格式上了。也不可能通过这个格子跳过其他的格子上了
  
• 有了上述条件，递归就很容易写了，每次往右、或者往下走。
• 到达边界条件返回0，到达终点返回1。
  
• 上图中橙色的(2,2)这个点，表示从这里发出到达终点有多少路径。
• 同理，(0,0)就是从起点出发，走到终点有多少路径，也就是题目的要求。
• 注意，纯递归是不行的，因为有大量的重复计算，需要加个缓存。

class Solution {
    int N, M;
    std::map<std::pair<int, int>, int> cache;
    int dfs(int i, int j, vector<vector<int>>& o){
        std::pair<int, int> p = {i, j};
        if(cache.count(p)){
            return cache[p];
        }
        
        //边界/障碍物检查
        if(i < 0 || j < 0 || i >= N || j >= M || o[i][j] == 1){
            return 0;
        }

        //达到终点了
        if(i == N - 1 && j == M - 1){
            return 1;
        }

        //继续往右(i,j+1)、往下(i+1,j)递归调用
        int res = dfs(i , j + 1, o) + dfs( i + 1, j, o);
        cache[p] = res;
        return res;
    }
public:
    int uniquePathsWithObstacles(vector<vector<int>>& o) {
        if(o.empty() || o[0].empty() || o[0][0] == 1 || o[o.size() - 1][o[0].size() -1] == 1){
            return 0;
        }
        N = o.size(), M = o[0].size();
        return dfs(0, 0, o);
    }
};

动态规划

1）确定dp数组以及下标的含义

• dp(i, j)表示从坐标(0, 0)到坐标(i, j)的路径总数

2）确定状态转移方程

• 因为机器人每次只能向下或者向右移动一步，所以从坐标(0, 0)到指标(i，j)的路径总数只取决于从坐标(0, 0)到坐标(i - 1, j)的路径总数 和从坐标 (0,0) 到坐标(i,j−1) 的路径总数，**即 dp(i,j) 只能通过dp(i−1,j) 和 dp(i,j−1) 转移得到。
• 如果坐标(i, j)本身就有障碍时，任何路径都到不了坐标(i, j)（dp是从下向上推导的），所以dp[(i, j) = 0
• 也就是说：

if (obstacleGrid[i][j] == 0) { // 当(i, j)没有障碍的时候，再推导dp[i][j]
    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}

3）确定dp数组如何初始化
+当没有障碍物时，初始化应该是：

vector<vector<int>> dp(m, vector<int>(n, 0)); // 初始值为0
for (int i = 0; i < m; i++) dp[i][0] = 1;
for (int j = 0; j < n; j++) dp[0][j] = 1;

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

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循环的终止条件，一旦遇到obstacleGrid[i][0] == 1的情况就停止dp[i][0]的赋值1的操作，dp[0][j]同理

4）确定递归顺序

• 从递归公式dp[i][j] = dp[i - 1][j] + dp[i][j - 1] 中可以看出，一定是从左到右一层一层遍历，这样保证推导dp[i][j]的时候，dp[i - 1][j] 和 dp[i][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];
    }
}

5）举例推导dp数组

对应的dp table 如图：

class Solution {

public:
    int uniquePathsWithObstacles(vector<vector<int>>& o) {
        if(o.empty() || o[0].empty()
           || o[0][0] == 1
           || o[o.size() - 1][o[0].size() - 1] == 1){
            return 0;
        }

        int m = o.size(), n = o[0].size();

        std::vector<std::vector<int>> dp(m, std::vector<int>(n));


        for (int i = 0; i < m && o[i][0] == 0; ++i) {
            dp[i][0] = 1;
        }

        for (int j = 0; j < n && o[0][j] == 0; ++j) {
            dp[0][j] = 1;
        }

        for (int i = 1; i < m; ++i) {
            for (int j = 1; j < n; ++j) {
                if(o[i][j] == 1){
                    dp[i][j] = 0;
                }else{
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }
            }
        }

        return dp[m - 1][n - 1];
    }
};

空间优化

对于动态规划的两种解法，都是只需要上一层的解，而不需要上上一层的。

dp[i][j] = dp[i - 1][j] + dp[i][j - 1]

也就是求第i行时，只需要i-1行已求解过的值，不需要i-2行的了。

所以这里可以用滚动数组进行优化，将二维数组改为一维数组。

一维数组的大小为列的长度。

第三次迭代时，求第三个格子6时，由于左边的值已经是已知的，第二次迭代时同位置的值也是已知的。所以当前值的计算方式就是：

计算当前值 = 以求出的左边值 + 上一次迭代同位置的值
dp[j] = dp[j - 1] + dp[j]

代码如下：

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& o) {
        int n = o.size(), m = o.at(0).size();
        vector <int> dp(m);
        
        dp[0] = (o[0][0] == 0);
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                if (o[i][j] == 1) {
                    dp[j] = 0;
                    continue;
                }
                if (j - 1 >= 0 && o[i][j - 1] == 0) {
                    dp[j] += dp[j - 1];
                }
            }
        }
        
        return dp.back();
    }
};