63. 不同路径 II

63. 不同路径 II

难度中等772收藏分享切换为英文接收动态反馈

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

用数组dp表示可到达每个点的路径数

• 通过所有到达(i-1,j)这个点的路径往下走一步可到达(i,j), 这路径数总共有dp[i-1][j]条

• 通过所有到达(i,j-1)这个点的路径往右走一步可到达(i,j), 这路径数总共有dp[i][j-1]条

• 由此可以推出递推式dp[i][j] = dp[i-1][j]+dp[i][j-1]

• 如果数组长宽都为0的话返回0

• 设dp数组的大小与obstacleGrid数组大小一致

• 对于左边界，在第一个障碍物前面（或者到达边界）的所有点皆可到达

• 对于上边界，在第一个障碍物左边（或者到达边界）的所有点皆可到达

• 从dp[1][1]开始遍历网格，根据递推式dp[i][j] = dp[i-1][j]+dp[i][j-1]更新当前点可到达路径数

• 结果存在网格右下角，即dp[n-1][m-1]

复杂度分析

• 时间复杂度O(n*m)
  • 遍历一遍网格，复杂度即网格大小

• 空间复杂度O(n*m)
  • 需要开一个数组记录当前路径数量

public class Solution {
    /**
     * @param obstacleGrid: A list of lists of integers
     * @return: An integer
     */
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        //获取网格的长宽
        int n = obstacleGrid.length,m = obstacleGrid[0].length;
        if (n == 0 || m == 0) {
            return 0;
        }
        int[][] dp = new int[n][m];
        //对于左边界，第一个障碍物或边界前的所有边界点皆可到达
        if (obstacleGrid[0][0] == 0) {
            dp[0][0] = 1;
        }
        for (int i = 0;i < n;i++) {
            for (int j = 0;j < m;j++){  
                if (i==0 && j==0) {  
                    continue;
                }
                //若遇到障碍物，则跳过
                if (obstacleGrid[i][j] == 1) {
                    continue;
                }
                //对于上边界，第一个障碍物或边界左边的所有边界点皆可到达
                if (i == 0) {
                    dp[i][j] = dp[i][j-1];
                    continue;
                }
                //对于左边界，第一个障碍物或边界前的所有边界点皆可到达
                if (j == 0) {
                    dp[i][j] = dp[i-1][j];
                    continue;
                }
                //到达当前点的路径数等于能到达此点上面的点和左边点的路径数之和
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        return dp[n-1][m-1];
    }
}