力扣63-不同路径Ⅱ

        一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

              

解题思路：                                                                                                                                   

        假设遍历到第i行时，路径数用数组currentArray，上一行路径数用upArray数组标识
解题过程中需要考虑三种场景：
               1.如果第一个数或者最后一个数有障碍物，直接返回0，不需要进行遍历
               2.如果只有一行或 只有一列，只要有一个存在障碍物，则直接返回0，不需要遍历
               3.如果不满足场景1或者2，则需要先通过数组upArray和currentArray来进行判断
                   3.1 当遍历到第i个节点时，需要判断第i个节点是否有障碍物，如果有障碍物，则currentArray[i] = 0,
                   3.2 如果没有障碍物，则currentArray[i] = currentArray[i-1]+upArray[i](该节点的上一行的方法数)
                   3.4 基于此，需要先计算第0行的方法数，赋值给upArray
                   3.5 对每一行数据遍历后，将currentArray赋值给upArray
               4.返回upArray[n-1]值,即为方法数

package likou;
/*
 * 63.不同路径Ⅱ
 * 题干：
 * 	一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）
 * 	机器人每次只能向下或者向右移动一步
 * 	机器人试图达到网格的右下角（在下图中标记为“Finish”）
 * 	现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
 */
public class Demo63 {
     /*
      * 解题思路：
      * 	从最左上角到最右下角的路径有多少，假设遍历到第i行时，路径数用数组currentArray，上一行路径数用upArray数组标识
      *     解题过程中需要考虑三种场景
      *     	1.如果第一个数或者最后一个数有障碍物，直接返回0，不需要进行遍历
      *         2.如果只有一行或 只有一列，只要有一个存在障碍物，则直接返回0，不需要遍历
      *         3.如果不满足场景1或者2，则需要先通过数组upArray和currentArray来进行判断
      *         	3.1 当遍历到第i个节点时，需要判断第i个节点是否有障碍物，如果有障碍物，则currentArray[i] = 0,
      *             3.2 如果没有障碍物，则currentArray[i] = currentArray[i-1]+upArray[i](该节点的上一行的方法数)
      *             3.4 基于此，需要先计算第0行的方法数，赋值给upArray
      *             3.5 对每一行数据遍历后，将currentArray赋值给upArray
      *         4.返回upArray[m-1][n-1],即为方法数
      */
	public int uniquePathsWithObstacles(int[][] obstacleGrid) {
            int m = obstacleGrid.length;
            int n = obstacleGrid[0].length;
            //特殊场景1：第一个或最后一个有障碍物，直接返回0
            if(obstacleGrid[0][0] ==1 || obstacleGrid[m-1][n-1] == 1) {
            	return 0;
            }
            //特殊场景2：只有一列或只有一行，只要有一个元素存在1，就直接返回0
            if(m <2 || n<2) {
            	for(int i=0;i<m;i++) {
            		for(int j=0;j<n;j++) {
            			if(obstacleGrid[i][j] == 1) {
                        	return 0;
                        }
            		}
            	}	
            	return 1;
            }
            //通用场景
            int[] upArray = new int[n]; 
            upArray = obstacleGrid[0];
            upArray[0] = upArray[0] == 0?1:0; 
            for(int i=1;i<n;i++) {
            	if(upArray[i] == 1) {
            		upArray[i] = 0;
            	}else {
                	upArray[i] = upArray[i-1];
            	}
            }
            for(int k=1;k<m;k++) {
            	int[] currentArray = new int[n]; 
            	int[] tempArray = obstacleGrid[k];
            	if(tempArray[0] == 1) {
            		currentArray[0] = 0;
            	}else {
                	currentArray[0] = upArray[0];
            	}
            	
            for(int i=1;i<n;i++) {
            	if(tempArray[i] == 0) {
        			currentArray[i] = currentArray[i-1]+upArray[i];
        		}else {
        			currentArray[i] = 0;
        		}
            }
            upArray = currentArray;
            }
           return upArray[n-1];
    }
	
	public static void main(String args[]) {
		Demo63 demo = new Demo63();
		//int[][] obstacleGrid = {{0,0,0},{0,1,0},{0,0,0}};
		//int[][] obstacleGrid = {{0,0,0},{0,1,0},{0,0,0}};
		int[][] obstacleGrid = {{0,0},{1,0}};
		System.out.println(demo.uniquePathsWithObstacles(obstacleGrid));
	}
	
}