【LeetCode】解题63：Unique Paths II

Problem 63: Unique Paths II [Medium]

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:

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

来源：LeetCode

解题思路

动态规划题，解题思路与Problem 62 Unique Paths类似。

状态方程：
$$step[i,j]=(step[i,j-1]+step[i-1,j])\ast (1-obstacleGrid[i,j])$$
每一格可以通过左边格/上边格到达，因此到达的方法个数为左边一格的方法个数与上边一格的方法个数之和，如果当前格子有障碍（obstacleGrid[i, j] = 1），则不能到达，方法个数为0。

具体思路：

• 由上一篇Unique Paths题解可知，实现该状态方程只需要创建一个长度为n的一维数组：step[n]。
• 初始化：step[0] = 1，step[1~n-1] = 0.
• 双重循环：
  a. 第一重循环：计算每行首列的值，即step[0]。由于第一列只能由上边一格到达，因此只要上边某格有障碍，下面所有的第一列格子都无法到达，更新公式为：step[0] = step[0] * (1 - obstacleGrid[i, 0])。
  b. 第二重循环：计算每行当前格方法个数公式：step[j] = (step[j-1] + step[j]) * (1 - obstacleGrid[i, j])，当前格有障碍时step[j] = 0。

整个算法时间复杂度为$O(m\ast n)$，空间复杂度为$O(n)$。

运行结果：

Solution (Java)

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[] step = new int[n];
        step[0] = 1;
        for(int i = 0; i < m; i++){
            step[0] *= (1 - obstacleGrid[i][0]);
            for(int j = 1; j < n; j++){
                step[j] += step[j-1];
                step[j] *= (1 - obstacleGrid[i][j]);
            }
        }
        return step[n-1];
    }
}