LeetCode-63. 不同路径（II）(中等)

63. 不同路径（II）(中等)

题目地址：https://leetcode-cn.com/problems/unique-paths-ii/

1. 题目描述及示例

      一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。
      现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
      网格中的障碍物和空位置分别用 1 和 0 来表示。

示例一：

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

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

示例二：

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

2. 题解和代码实现

      该题和 62.不同路径的主要区别在于所给的网格里夹杂障碍物；在这里依然使用动态规划的解决方案。对于障碍物的处理，不仅仅是该点不可达，而且也不能够通过该点到达别处，即不可到达它的右方和下方。同样使用paths[i][j]来代表该位置的路径数目。

     转移矩阵

      首先，我们要进行锁定转移矩阵。在这里，在obstacleGrid[i][j]==0，即i和j所对应的位置没有障碍物，该位置可以到达，那么针对**paths[i][j]**位置上的路径总共有种情况：

注意：在这里使用paths[i][j] == -1来表示该点没有路径也就是不可到达

1. paths[i-1][j] != -1 && paths[i][j-1] != -1（即通过该位置的左边和上边均能到达该位置）
   即：paths[i][j] = paths[i-1][j] + paths[i][j-1]
2. paths[i-1][j] != -1 && paths[i][j-1] == -1（即通过该位置的上边可以到达该位置）
   即：**paths[i][j] = paths[i-1][j] **
3. paths[i-1][j] == -1 && paths[i][j-1] != -1（即通过该位置的左边能到达该位置）
   即：paths[i][j] = paths[i][j-1]
4. paths[i-1][j] == -1 && paths[i][j-1] == -1（即通过该位置的左边和上边均不能到达该位置）
   即：paths[i][j] = -1

在obstacleGrid[i][j]==1，即i和j所对应的位置有障碍物，那么该位置不可到达，即paths[i][j] = -1。

     初始状态

      在这里同样进行初始化第一行和第一列，在没有障碍物的情况下，第一行和第一列上所有元素均只有一条路径可以抵达；此时有障碍物，那么我们思考，对于第一行上，某一元素位置有障碍物，那么肯定的是，该位置后面的位置均不可抵达，对于第一列有着同样的效果。
      那么对第一行的初始化有以下代码：

for(i=0;i<m;i++){ // m 代表行数
   if(obstacleGrid[i][0]!=1){
       paths[i][0] = 1;
    }else{
          while(i<m){  // 针对障碍物后面的位置均不可到达
             paths[i][0] = -1;
             i++;
          }
          break;
     }
}

      那么对第一列的初始化有以下代码：

for(j=0;j<n;j++){// n代表列数
    if(obstacleGrid[0][j]!=1){
          paths[0][j] = 1;
     }else{
           while(j<n){ // 针对障碍物后面的位置均不可到达
               paths[0][j] = -1;
               j++;
           }
           break;
     }
}  

代码实现（C++ 2022-3-14）

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        // 其实和不同路径 I 很类似，只是，该点有障碍物，那么该点不可达
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        int paths[m][n];
        int i,j;
        // 初始化第一行
        for(i=0;i<m;i++){ // m代表行数
            if(obstacleGrid[i][0]!=1){
                paths[i][0] = 1;
            }else{
                while(i<m){ // 针对障碍物后面的位置均不可到达
                    paths[i][0] = -1;
                    i++;
                }
                break;
            }
        }
        // 初始化第一列
        for(j=0;j<n;j++){// n代表列数
            if(obstacleGrid[0][j]!=1){
                paths[0][j] = 1;
            }else{
                while(j<n){ // 针对障碍物后面的位置均不可到达
                    paths[0][j] = -1;
                    j++;
                }
                break;
            }
        }  
        // 初始化所有元素  
        for(i=1;i<m;i++){
            for(j=1;j<n;j++){
                if(obstacleGrid[i][j]!=1){
                    if(paths[i-1][j]!=-1&&paths[i][j-1]!=-1){
                        paths[i][j] = paths[i-1][j] + paths[i][j-1];
                    }else if(paths[i-1][j]!=-1&&paths[i][j-1]==-1){
                         paths[i][j] = paths[i-1][j];
                    }else if(paths[i-1][j]==-1&&paths[i][j-1]!=-1){
                        paths[i][j] = paths[i][j-1];
                    }else{
                        paths[i][j] = -1;
                    }
                }else{
                    paths[i][j] = -1;
                }
            }
        }
        if(paths[m-1][n-1]==-1) //代表终点不可达
            return 0;
        return paths[m-1][n-1];
    }
};

3. 总结

      其实也没那么复杂，只要掌握好位置走向，初始化状态，终结状态，参照62.不同路径该题迎刃而解。