LeetCode 63. Unique Paths II

题目：

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

---

这道题和62的题目背景一样，但是62是任意一个格子都能走，这道题有些格子是走不通的。按照62的思路，首先在初始化dp数组的时候，第一行和第一列中只要有任意一个格子不能走通，那它和它后面的格子都走不通了（如果第一个格子就走不通，那整个grid都走不通了，可以直接return 0了）。然后在遍历其他格子的时候，dp式子和62应该是相同的，只是如果当前这个格子是有障碍的，那就不需要经过dp计算，可以直接设置为0了。时空复杂度依旧是O(mn)。

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

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

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[][] dp = new int[m][n];
        
        if (obstacleGrid[0][0] == 1) {
            return 0;
        }
        dp[0][0] = 1;
        for (int i = 1; i < n; i++) {
            dp[0][i] = (obstacleGrid[0][i] == 1 || dp[0][i - 1] == 0) ? 0 : 1;
        }
        for (int i = 1; i < m; i++) {
            dp[i][0] = (obstacleGrid[i][0] == 1 || dp[i - 1][0] == 0) ? 0 : 1;
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (obstacleGrid[i][j] == 1) {
                    dp[i][j] = 0;
                } else {
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }
            }
        }
        return dp[m - 1][n - 1];
        
    }
}

然后看了solutions发现并不需要另外单独再开一个dp数组，可以直接使用参数的那个数组，这样空间复杂度就降为了O(1)。

然后又看了下discussion，发现其实只需要一维dp就可以了，就像前两天的64一样，因为每次只从上或者左来更新，所以可以直接用一维的dp[j] = dp[j] + dp[j - 1]。但是懒得写了orz

然后又看了下solutions里的comment，有人提出这道题的解法顺序应该是backtracking -> backtracking+memo -> bottom-up -> greedy……鉴于我现在还不太会backtracking，而且时间有限，就，算了吧2333