【动态规划】【打卡111天】：leetcode 63. 不同路径 II

1、题目描述

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

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

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

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

 

 2、算法分析

上一题是没有障碍的情况，求出到达最右下角的网格有多少种走法。

本题是到达终点期间有障碍物。且障碍物和空位置分别用 1 和 0 来表示。

步骤如下：

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

dp[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]：obstacleGrid[0][0]是0的话，dp[0][0] = 1；obstacleGrid[0][0]是1的话，dp[0][0] = 0

所以dp[0][0] = 1 - obstacleGrid[0][0]

接着对第一行，第一列进行初始化。从(0, 0)的位置到(i, 0)的路径只有一条，所以dp[i][0]一定为1，dp[0][j]也同理。

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;

④确定遍历顺序

从递归公式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];
    }
}

注意：当遍历数组obstacleGrid中遇到1的时候，跳过，后面的是0呢

3、代码实现

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        // 定义二维数组的行，列
        int row = obstacleGrid.length;
        int column = obstacleGrid[0].length;
        // 行列都需要是row-1,column-1
        // 0...row-1
        // 0...column-1
        int[][] dp = new int[row][column];
        // 初始化dp数组
        // obstacleGrid[0][0] 为0的时候，dp[0][0]的路径为1
        // obstacleGrid[0][0] 为1有障碍物的时候，dp[0][0]的路径为0
        dp[0][0] = 1 - obstacleGrid[0][0]; 
        
        // 初始化第1列
        for(int i = 1;i < row;i++){
            // obstacleGrid[i][0] == 0 当前位置为0无障碍物
            // dp[i-1][0] == 1 且之前的都没有障碍，路径为1
            if(obstacleGrid[i][0] == 0 && dp[i-1][0] == 1){
                // 从（0,0）到（i,0）的路径只有一条，所以dp[i][0]一定为1。
                dp[i][0] = 1;
            }
        }

        // 初始化第一行
        // 同理
        for(int i = 1;i < column;i++){
            if(obstacleGrid[0][i] == 0 && dp[0][i-1] == 1){
                dp[0][i] = 1;
            }
        }

        // 遍历一般情况，因为（0,j），（i,0）第1行和第1列都已经初始化。所以i，j = 1开始。
        for(int i = 1;i < row;i++){
            for(int j = 1;j < column;j++){
                // 遇到障碍物跳过这个位置的1，继续下一个。
                if(obstacleGrid[i][j] == 1){
                    continue;
                }
                // 递推公式
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        return dp[row-1][column-1];
    }
}