LeetCode Unique Paths II

Follow up for "Unique Paths":

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.

For example,

There is one obstacle in the middle of a 3x3 grid as illustrated below.

[
  [0,0,0],
  [0,1,0],
  [0,0,0]
]

The total number of unique paths is 2.

Note: m and n will be at most 100.

思路分析：这题是Unique Path问题的变形题目，现在网格中出现了用1标记的障碍物，有障碍物的网格不可以通过。同样可以用动态规划来解决。类似于Unique Path，设网格是m行n列，我们定义m*n的数组dp[][],其中dp[i][j]表示从起点(0,0)到达(i,j)的所有合法的路径数量，那么考虑到障碍物，我们有递推公式

dp[i,j] = dp[i-1,j] + dp[i,j-1];  if(i-1,j) and (i,j-1) are 0

dp[i,j] = dp[i-1,j] if(i,j-1) is 1

dp[i,j] = dp[i,j-1] if(i-1,j) is 1

dp[i,j] = 0 if both(i,j-1) and (i-1,j) are 1

然后我们可以从左上向右下填表格计算。注意考虑几个corner case：1 当m或者n为1的时候，应该搜索网格是否包含1，如果有就没有合法路径，如果没有则存在一条合法路径； 2 当起点或者终点是1的时候，应该返回0.由于只需要使用相邻一行或者一列的计算结果，我们也可以定义一个一维数组来保存中间计算结果，进一步节省空间。

AC Code

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