63. 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.

比较容易想起的方法是递归寻找，每个分支向下或者向右（有点像二叉树），遇到1代表无法通过，如果 到终点则数量加一，可惜这种方式递归调用的层次太深，查找量很大，会超时。
实现方式：

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        if (obstacleGrid.size() == 0 || obstacleGrid[0].size() == 0)
        {
            return 0;
        }
        int result = 0;
        if (obstacleGrid[0][0] != 1)
        {
            find_way(obstacleGrid,0,0,result);
        }
        return result;
    }

    void find_way(vector<vector<int>>& obstacleGrid,int m,int n,int &result){
        if (m == obstacleGrid.size() - 1 && n == obstacleGrid[0].size() - 1 && obstacleGrid[m][n] != 1)
        {
            result++;
            return;
        }
        if (n + 1 < obstacleGrid[0].size() && obstacleGrid[m][n + 1] != 1)
        {
            find_way(obstacleGrid,m,n + 1,result);
        }
        if (m + 1 < obstacleGrid.size() && obstacleGrid[m + 1][n] != 1)
        {
            find_way(obstacleGrid,m + 1,n,result);
        }
    }
};

考虑四4*5的方块

–	–	–	–	–
0	0	0	0	0
0	0	0	1	0
0	0	1	0	0
0	0	0	0	0

第一块如果可达，则只有一种方式。
到达各个点的方式的数量。
（2，2）

–	–	–	–	–
1	1	1	1	1
1	2
1
1

（3，3）

–	–	–	–	–
1	1	1	1	1
1	2	3
1	3	0
1

实际上到达一个方块的所有方式等于它上边与右边到达方式的和。
那么可以用递推的方式计算出所有块到达的方式，需要一个保存所有达到方式的二维数组。
实现：

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        //先去除非正常情形
        if (obstacleGrid.size() == 0 || obstacleGrid[0].size() == 0 || obstacleGrid[0][0] == 1 || 
            obstacleGrid[obstacleGrid.size() - 1][obstacleGrid[0].size() - 1] == 1)
        {
            return 0;
        }
        int height = obstacleGrid.size();
        int width = obstacleGrid[0].size();
        vector<vector<int>> assis_array(height,vector<int>(width,0));       //全部为0的二维数组

        assis_array[0][0] = 1;//第一个点如果可达，到达方式为数目为1
        for (int i = 0; i < height; ++i)
        {
            for (int j = 0; j < width; ++j)
            {
                if (i == 0 && j == 0) continue;//我们已经设置过了
                if(obstacleGrid[i][j] == 1) continue;
                int left = 0;
                int up = 0;
                if (j > 0)
                {
                    left = assis_array[i][j - 1];
                }
                if (i > 0)
                {
                    up = assis_array[i - 1][j];
                }
                assis_array[i][j] = left + up;
            }
        }
        return assis_array[height - 1][width - 1];
    }
};