63. Unique Paths II

最新推荐文章于 2020-07-12 23:29:12 发布

原创最新推荐文章于 2020-07-12 23:29:12 发布 · 115 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LeetCode #算法 #Java

LeetCode 同时被 2 个专栏收录

117 篇文章

订阅专栏

Arrays

79 篇文章

订阅专栏

本文探讨了在存在障碍物的网格中，机器人从起点到终点的路径规划问题。使用动态规划方法，通过计算可达节点的路径数，解决了路径规划问题。文章提供了两种解决方案，一种是深度遍历但可能超时的方法，另一种是高效的动态规划方法。

Problem 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

Analysis:

使用动态规划方法，每个节点的上一步都是来自于它的左边和上面的两个节点，因此在动态规划中只需要将可通过的节点的上两个节点的路径数相加即可。代码如下：

Code:

方法一（使用深度遍历，但是会超时）：

class Solution {
    private int cnt = 0;
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int r = obstacleGrid.length;
        int c = obstacleGrid[0].length;
        if(obstacleGrid[0][0] == 1 || obstacleGrid[r - 1][c - 1] == 1)
            return 0;
        int[][] flag = new int[r][c];
        for(int i = 0; i < r; i++) {
            for(int j = 0; j < c; j++) {
                flag[i][j] = 0;
            }
        }
        flag[0][0] = 1;
        dfs(obstacleGrid, flag, 0, 0);
        return cnt;
    }
    
    private void dfs(int[][] obstacleGrid, int[][] flag, int ii, int jj) {
        System.out.println(ii + ", " + jj);
        if(ii == obstacleGrid.length - 1 && jj == obstacleGrid[0].length - 1) {
            cnt++;
            System.out.println(cnt + ": tue");
            return;
        }
        //right
        if(jj + 1 < obstacleGrid[0].length && flag[ii][jj + 1] == 0 && obstacleGrid[ii][jj + 1] == 0) {
            flag[ii][jj + 1] = 1;
            dfs(obstacleGrid, flag, ii, jj + 1);
            flag[ii][jj + 1] = 0;
        }
        //down
        if(ii + 1 < obstacleGrid.length && flag[ii + 1][jj] == 0 && obstacleGrid[ii + 1][jj] == 0) {
            flag[ii + 1][jj] = 1;
            dfs(obstacleGrid, flag, ii + 1, jj);
            flag[ii + 1][jj] = 0;
        }
    }
}

方法二DP:

class Solution {
    private int cnt = 0;
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int r = obstacleGrid.length;
        int c = obstacleGrid[0].length;
        if(obstacleGrid[0][0] == 1 || obstacleGrid[r - 1][c - 1] == 1)
            return 0;
        obstacleGrid[0][0] = 1;
        for(int i = 1; i < r; i++) {
            obstacleGrid[i][0] = (obstacleGrid[i][0] == 0 && obstacleGrid[i - 1][0] == 1? 1 : 0);
        }
        for(int i = 1; i < c; i++) {
            obstacleGrid[0][i] = (obstacleGrid[0][i] == 0 && obstacleGrid[0][i - 1] == 1? 1 : 0);
        }
        
        for(int i = 1; i < r; i++) {
            for(int j = 1; j < c; j++) {
                obstacleGrid[i][j] = (obstacleGrid[i][j] == 0 ? obstacleGrid[i-1][j] + obstacleGrid[i][j-1] : 0);
            }
        }
        return obstacleGrid[r - 1][c - 1];
    }
}