从左上角走到右下角的走法数量（中间有障碍）

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 as1and0respectively 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 is2.

Note: m and n will be at most 100.

package leetcode;

public class Unique_paths_ii {
public static void main(String[] args) {
   int [][]a = {{0,1,0,0,0},{1,0,0,0,0},{0,0,0,0,0},{0,0,0,0,0}};
       System.out.println(uniquePathsWithObstacles(a));
   }

public static int uniquePathsWithObstacles(int[][] obstacleGrid) {
       int m = obstacleGrid.length; //取得行数
       int n = obstacleGrid[0].length; //取得列数
       if(obstacleGrid[0][0] == 1 || obstacleGrid[m-1][n-1] == 1 ) {
           return 0; //若起点或者终点有障碍，则结果为0
       }
       for(int i = 0 ; i < m ; i ++) {
           if(obstacleGrid[i][0] == 1) { //若是有障碍则设置为-100
               obstacleGrid[i][0] = -100;
           }else if(i>=1 && obstacleGrid[i-1][0] == -100){ //若第一列的上方有一个有障碍，则这一列均不能通过，所以全部设置为-100
               obstacleGrid[i][0] = -100;
           }else {
               obstacleGrid[i][0] = 1; //无障碍设置为1，表示可行
           }
   }
   for(int j = 1 ; j < n ; j ++) {
       if(obstacleGrid[0][j] == 1){
               obstacleGrid[0][j] = -100; //若是有障碍则设置为-100
           }else if(j >= 1 &&obstacleGrid[0][j-1] == -100){ //若第一行的左方有一个有障碍，则这一行均不能通过，所以全部设置为-100
               obstacleGrid[0][j] = -100;
           }else {
               obstacleGrid[0][j] = 1; //无障碍设置为1，表示可行
           }
   }
   for(int i = 1 ; i < m ; i ++) {
       for(int j = 1 ;j < n ; j ++) {
           if(obstacleGrid[i][j] == 1) {
               obstacleGrid[i][j] = -100; //若是有障碍则设置为-100
               continue;
           }else if(obstacleGrid[i-1][j] == -100 && obstacleGrid[i][j-1] == -100) {
               obstacleGrid[i][j] = -100; //左方和上方均有障碍，则此位置无法通过，相当于有障碍，设置为-100
           }else if(obstacleGrid[i-1][j] == -100 && obstacleGrid[i][j-1] != -100) {
               obstacleGrid[i][j] = obstacleGrid[i][j-1]; //上方有障碍，则从左方通过，把左方位置存入的走法数量继承过来
           }else if(obstacleGrid[i-1][j] != -100 && obstacleGrid[i][j-1] == -100) {
               obstacleGrid[i][j] = obstacleGrid[i-1][j]; //左方有障碍，则从上方通过，把上方位置存入的走法数量继承过来
           }else {
               obstacleGrid[i][j] = obstacleGrid[i-1][j]+obstacleGrid[i][j-1];//左方和上方均无障碍，则此位置可以通过，可以把两个方向的走法数量相加之后继承
           }
       }
   }
   if(obstacleGrid[m-1][n-1] == -100) { //若最后没有继承任何走法则返回为0
       return 0;
   }else {
       return obstacleGrid[m-1][n-1];
   }
}
}
//以下是牛客网上的最优解法
/*public class Solution {
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
int m = obstacleGrid.length; //取得行数
if(m == 0 || obstacleGrid[0][0] == 1) //行数为0,或者起点有障碍,直接返回为0
return 0;
int n = obstacleGrid[0].length; //取得列数
int[][] steps = new int[m][n]; //定义同等大小的二维数组
steps[0][0] = 1; //此时起点已经排除有障碍的情况,所以直接赋值为1
for(int i=1; i<n; i++){ //对于第一列的元素如果有障碍则为1,否则无障碍就和其上方元素一样
if(obstacleGrid[0][i] == 1)
steps[0][i] = 0;
else
steps[0][i] = steps[0][i-1];
}
for(int i=1; i<m; i++){ //对于第一行的元素如果有障碍则为1,否则无障碍就和其左方元素一样
if(obstacleGrid[i][0] == 1)
steps[i][0] = 0;
else
steps[i][0] = steps[i-1][0];
}
for(int i=1; i<m; i++){
for(int j=1; j<n; j++){
if(obstacleGrid[i][j] == 1) //此处有障碍,则赋值为0,表示到此位置的走法数目为0
steps[i][j] = 0;
else
steps[i][j] = steps[i-1][j] + steps[i][j-1]; //此处无障碍,则是其左方和上方的走法数目的和
}
}
return steps[m-1][n-1]; //最后返回
}
}
*/

从左上角走到右下角的走法数量（中间有障碍）

猜你喜欢