数组-不同的路径 II-简单

描述
"不同的路径" 的跟进问题：
现在考虑网格中有障碍物，那样将会有多少条不同的路径？
网格中的障碍和空位置分别用 1 和 0 来表示。
m 和 n 均不超过100

样例
如下所示在3x3的网格中有一个障碍物：
[
  [0,0,0],
  [0,1,0],
  [0,0,0]
]

一共有2条不同的路径从左上角到右下角。

题目链接

分析

该题目是不同路径问题的升级版，但是也不是太难。当只有一行或者一列的路径时，如果出现1障碍物，则只后的路径都是走不通的，后面的部分全部为0；否则这一行或者这一列为1。

这里初始化动态规划的存储数组不像上一题那么简单，如果每一行（列）存在障碍物，则只会的部分为0，否则全部为1。

在使用递归方程p[i][j] = p[i-1][j] + p[i][j-1]时，如果obstacleGrid[i][j]位置为1，则p[i][j]=0；否则正常使用递归方程求解。

程序

class Solution {
public:
    /**
     * @param obstacleGrid: A list of lists of integers
     * @return: An integer
     */
    int uniquePathsWithObstacles(vector<vector<int>> &obstacleGrid) {
        // write your code here
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        //只含有1列
        if(n==1){
            int k = 0;
            while(k<m){
                if(obstacleGrid[k][0] == 1)
                    return 0;
                k++;
            }
            return 1;
        }
        //只含有1行
        if(m == 1){
            int k = 0;
            while(k<n){
                if(obstacleGrid[0][k] == 1)
                    return 0;
                k++;
            }
            return 1;
        }
        //动态规划
        int p[101][101];
        //初始化第一列
        for(int i = 0; i < m; i++){
            if(obstacleGrid[i][0] == 0)
                p[i][0] = 1;
            else{
                while(i < m){
                    p[i][0] = 0;
                    i++;
                }
                break;
            }
        }
        //初始化第一行
        for(int i = 0; i < n; i++){
            if(obstacleGrid[0][i] == 0)
                p[0][i] = 1;
            else{
                while(i < n){
                    p[0][i] = 0;
                    i++;
                }
                break;
            }
        }
        
        int i,j;
        for(int i = 1; i < m; i++)
            for(int j = 1; j < n; j++){
                if(obstacleGrid[i][j] == 1)
                    p[i][j] = 0;
                else
                    p[i][j] = p[i-1][j] + p[i][j-1];
            }
        return p[m-1][n-1];
    }
};