LeetCode 63 _ Unique Paths II 全部不同路径2

最新推荐文章于 2021-02-24 07:42:14 发布

weixin_30674525

最新推荐文章于 2021-02-24 07:42:14 发布

阅读量98

点赞数

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/zingg7/p/10656809.html

本文介绍了一种使用动态规划解决网格中带有障碍物的路径计数问题的方法。通过遍历网格并考虑障碍物的影响，该算法有效地计算了从左上角到右下角的所有可能路径数量。

Description:

A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).

The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).

Now consider if some obstacles are added to the grids. How many unique paths would there be?

An obstacle and empty space is marked as 1 and 0 respectively in the grid.

Note: m and n will be at most 100.

Example 1:

Input:
[
  [0,0,0],
  [0,1,0],
  [0,0,0]
]
Output: 2
Explanation:
There is one obstacle in the middle of the 3x3 grid above.
There are two ways to reach the bottom-right corner:
1. Right -> Right -> Down -> Down
2. Down -> Down -> Right -> Right

Solution:

这道题的要求是求从m*n的方格左上行至右下的所有路径总数，路中若有障碍则不能通行

这道题主要用到了动态规划的思想，所谓动态规划呢，就是将一个大问题分成多个小问题，找到每个小问题的最优解，最终得到最后的结果。

落实到这一题上，就是依次对每一个方格进行遍历。

首先先看这个方格是否有障碍物，如果有，那么这个方格被遍历到的可能性为0；

如果没有障碍物，当它是首行或首列时，它的值就等于它前一个位置的值。这里我们发现必须先设定一个起点的初值，否则就全部都是0啦！若起点无障碍物，则将起点值设置为1，表示起点会被遍历一次；

如果无障碍物且不是首行或首列时，它被遍历到的可能性就是它左边和上边的被遍历到的可能性之和。

最后输出最后一格的值即为答案。

Code:

public int uniquePathsWithObstacles(int[][] obstacleGrid) {
   int row = obstacleGrid.length;
    int col = obstacleGrid[0].length;

    if (obstacleGrid[0][0] == 1){
        return 0;
    }

    for (int i = 0; i < row; i++){
        for (int j = 0; j < col; j++){
            if (obstacleGrid[i][j] == 1){  // 如果此处有障碍,那么无路可通
                obstacleGrid[i][j] = 0;
            }else if (i == 0 && j == 0){  // 对第一个数赋值
                obstacleGrid[i][j] = 1;
            }else if (i == 0){
                obstacleGrid[i][j] = obstacleGrid[i][j-1];
            }else if (j == 0){
                obstacleGrid[i][j] = obstacleGrid[i-1][j];
            }else{
                obstacleGrid[i][j] = obstacleGrid[i][j-1] + obstacleGrid[i-1][j];
            }
        }
    }

    return obstacleGrid[row - 1][col - 1];
}

提交情况:

Runtime: 0 ms, faster than 100.00% of Java online submissions for Unique Paths II.

Memory Usage: 38.8 MB, less than 22.61% of Java online submissions for Unique Paths II.

LeetCode的标答是这样写的，我觉得没必要单独将第一行和第一列拎出来遍历呀，不过这样看起来更清楚一点，最后运行的效率和上面那种差不多，代码如下：

public int uniquePathsWithObstacles(int[][] obstacleGrid) {
    int row = obstacleGrid.length;
    int col = obstacleGrid[0].length;

    if (obstacleGrid[0][0] == 1){
        return 0;
    }

    obstacleGrid[0][0] = 1;

    for (int i = 1; i < row; i++){
        if (obstacleGrid[i][0] == 0 && obstacleGrid[i-1][0] == 1){
            obstacleGrid[i][0] = 1;
        }else{
            obstacleGrid[i][0] = 0;
        }
    }

    for (int i = 1; i < col; i++){
        if (obstacleGrid[0][i] == 0 && obstacleGrid[0][i-1] == 1){
            obstacleGrid[0][i] = 1;
        }else{
            obstacleGrid[0][i] = 0;
        }
    }        

    for (int i = 1; i < col; i++){
        for (int j = 1; j < row; j++){
            if (obstacleGrid[j][i] == 1){
                obstacleGrid[j][i] = 0;
            }else{
                obstacleGrid[j][i] = obstacleGrid[j-1][i] +obstacleGrid[j][i-1];
            }
        }
    }

    return obstacleGrid[row-1][col-1];
}

运行情况:

Runtime: 0 ms, faster than 100.00% of Java online submissions for Unique Paths II.

Memory Usage: 38.3 MB, less than 29.66% of Java online submissions for Unique Paths II.

转载于:https://www.cnblogs.com/zingg7/p/10656809.html