标签：障碍物 obstacleGrid return 示例 int length II 算法 dp

一、题目要求

• 一个机器人位于一个 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

• 提示：
• • m == obstacleGrid.length；
• • n == obstacleGrid[i].length；
• • 1 <= m, n <= 100；
• • obstacleGrid[i][j] 为 0 或 1。

二、求解算法

① 递归

• 如果是没有障碍物的话，从 (0,0) 出发，每次只能往下走、或者往右走。假设 i 表示行、j 表示列，当前点为 (i,j)，那么每次只能往 (i + 1, j) 移动、或者往 (i, j + 1) 移动，递归方向：
• • 往右：i 不动，j+1；
• • 往下：j+1，i 不动；
• 对于有障碍物的情况下怎么办呢？其实也简单，直接返回 0 就可以了，这表能走到障碍物的路径总和为 0：

• 有了上述条件，递归就很容易了，每次往右、或者往下走，到达边界条件返回 0，到达终点返回 1，如下所示，橙色的 (2,2) 这个点，表示从这里发出到达终点有多少路径：

• 同理，(0,0) 就是从起点出发，走到终点有多少路径，也就是题目的要求。
• Java 示例：

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        return dfs(new HashMap<Pair,Integer>(), obstacleGrid, 0, 0);
    }

    private int dfs(Map<Pair,Integer> cache, int[][] arr, int i, int j) {
        Pair p = new Pair(i,j);
        if(cache.containsKey(p)) {
            return cache.get(p);
        }
        // 边界/障碍物检查
        if(i >= arr.length || j >= arr[0].length || arr[i][j] == 1) {
            return 0;
        }
        // 达到终点
        if(i == arr.length - 1 && j == arr[0].length - 1) {
            return 1;
        }
        // 继续往右(i,j+1)、往下(i+1,j)递归调用
        int res = dfs(cache, arr, i + 1, j) + dfs(cache, arr, i, j + 1);
        cache.put(p, res);
        return res;
    }
}

② 动态规划 1

• 对于动态规划，反过来想，如何到达下图中橙色的 (2,2) 这个点呢？只能从上方和左方到达 (2,2) 这个点，到达障碍物 (3,2) 这个点的路径总和为 0：

• 只能由两个方向而来，上方、或者是左方；对于 (3,2) 障碍物这个点来说，能到达这里的路径就是 0，因此对于 (i,j) 这个点来说，其动态规划转移方程就是：

if 当前点不是障碍物：
    dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
else:
    dp[i][j] = 0

• 还需要处理下边界情况，也就是第一列、第一行时，如下图，只要第一列中的某个格子是障碍物，那么这个格子跟后面的都无法到达：

• 同理，第一行中如果有格子是障碍物，那么这个格子跟后面的都无法到达。
• Java 示例：

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int n = obstacleGrid.length;
        int m = obstacleGrid[0].length;
        int[][] dp = new int[n][m];
        // (0,0)这个格子可能有障碍物
        dp[0][0] = (obstacleGrid[0][0] == 1) ? 0 : 1;
        // 处理第一列
        for(int i = 1; i < n; ++i) {
            if(obstacleGrid[i][0] == 1 || dp[i - 1][0] == 0) {
                dp[i][0] = 0;
            } else {
                dp[i][0] = 1;
            }
        }
        // 处理第一行
        for(int j = 1; j < m; ++j) {
            if(obstacleGrid[0][j] == 1 || dp[0][j - 1] == 0) {
                dp[0][j] = 0;
            } else {
                dp[0][j] = 1;
            }
        }
        for(int i = 1; i < n; ++i) {
            for(int j = 1; j < m; ++j) {
                 // 如果当前格子是障碍物
                if(obstacleGrid[i][j] == 1) {
                    dp[i][j] = 0;
                // 路径总数来自于上方(dp[i-1][j])和左方(dp[i][j-1])    
                } else {
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }
            }
        }
        return dp[n - 1][m - 1];
    }
}

③ 动态规划 2

• 跟动态规划 1 解法正好是反过来的，动态规划 1 解法中，是从 (0,0) 走到 (n-1,m-1)，动态规划 2 中，是从 (n-1,m-1) 走到 (0,0)。因此反过来推导，对于 (2,2) 这个点，只能从下方、右方转移过来：

• 同样，反着推的时候也需要处理下边界问题，也就是最后一行，最后一列需要单独处理一下。这里的思路跟前一种解法是一样的，只是倒退来的：

• Java 示例：

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int n = obstacleGrid.length;
        int m = obstacleGrid[0].length;
        int[][] dp = new int[n][m];
        // 判断终点是否有障碍物
        dp[n - 1][m - 1] = (obstacleGrid[n - 1][m - 1] == 1) ? 0 : 1;
        // 处理最后一列
        for(int i = n -2; i >=0; --i) {
            if(obstacleGrid[i][m - 1] == 1 || dp[i + 1][m - 1] == 0) {
                dp[i][m - 1] = 0;
            } else {
                dp[i][m - 1] = 1;
            }
        }
        // 处理最后一行
        for(int j = m - 2; j >=0; --j) {
            if(obstacleGrid[n - 1][j] == 1 || dp[n - 1][j + 1] == 0) {
                dp[n - 1][j] = 0;
            } else {
                dp[n - 1][j] = 1;
            }
        }
        for(int i = n - 2; i >= 0; --i) {
            for(int j = m - 2; j >= 0; --j) {
                // 如果当前格子是障碍物
                if(obstacleGrid[i][j] == 1) {
                    dp[i][j] = 0;
                // 路径总数来自于下方(dp[i+1][j])和右方(dp[i][j+1])     
                } else {
                    dp[i][j] = dp[i + 1][j] + dp[i][j + 1];
                }
            }
        }
        return dp[0][0];
    }
}

④ 动态规划+空间优化

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

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

• 也就是求第 i 行时，只需要 i-1 行已求解过的值，不需要 i-2行 ，因此可以用滚动数组进行优化，将二维数组改为一维数组（一维数组的大小为列的长度）。

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

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

• Java 示例：

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int n = obstacleGrid.length;
        int m = obstacleGrid[0].length;
        int[] dp = new int[m];
        // 起点可能有障碍物
        dp[0] = (obstacleGrid[0][0] == 1) ? 0 : 1;
        for(int i = 0; i < n; ++i) {
            for(int j = 0; j < m; ++j) {
                // 有障碍物的格子直接赋0
                if(obstacleGrid[i][j] == 1) {
                    dp[j] = 0;
                }
                // 否则dp[j]的值由左方和上一次迭代的dp[j]累加而来
                else if(obstacleGrid[i][j] == 0 && j - 1 >= 0) {
                    dp[j] = dp[j] + dp[j - 1];
                }
            }
        }
        return dp[m - 1];
    }
}

标签：障碍物,obstacleGrid,return,示例,int,length,II,算法,dp
来源： https://blog.csdn.net/Forever_wj/article/details/122848216

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。