【Unique Paths II】cpp

题目：

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.

代码：

class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int> >& obstacleGrid)
{
const int m = obstacleGrid.size();
const int n = obstacleGrid[0].size();
vector<vector<int> > cache(m+1,vector<int>(n+1,0));
return Solution::dfs(m, n, cache, obstacleGrid);
}
static int dfs( int i, int j, vector<vector<int> >& cache, vector<vector<int> >& obstacleGrid )
{
if ( i<1 || j<1 || obstacleGrid[i-1][j-1]==1 ) return 0;
if ( i==1 && j==1 ) return 1;
return Solution::getDFS(i-1, j, obstacleGrid, cache) + Solution::getDFS(i, j-1, obstacleGrid, cache);
}
static int getDFS(int i, int j, vector<vector<int> >& obstacleGrid, vector<vector<int> >& cache)
{
if ( cache[i][j]>0 ){
return cache[i][j];
}
else{
return cache[i][j] = Solution::dfs(i, j, cache, obstacleGrid);
}
}
};

tips：

上述的代码采用了深搜+缓存（“备忘录”）法。照比Unique Paths多了一个判断条件，如果obstacleGrid上该位置为1则直接返回0。

有个细节上的技巧：

obstacleGrid是题目给出的定义，下标[m-1][n-1]

cache是自定义的缓存数组，下标[m]

同样的位置，cache的坐标比obstacleGrid大1；因此，只要深搜过程中保证了cache的坐标在合理范围内，无论是横坐标-1还是纵坐标-1，映射到cache的坐标中总不会越界。

上述代码的效率并不高，但是比较容易处理各种case。再尝试动态规划的解法。

==========================================

在Unique Paths的基础上，用动规又把Unqiue Paths II写了一遍。

class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int> >& obstacleGrid)
{
const int m = obstacleGrid.size();
const int n = obstacleGrid[0].size();
vector<int> dp(n, 0);
if ( obstacleGrid[0][0]==1 ) return 0;
dp[0] = 1;
for ( size_t i = 0; i < m; ++i )
{
dp[0] = obstacleGrid[i][0]==1 ? 0 : dp[0];
for ( size_t j =1; j < n; ++j )
{
dp[j] = obstacleGrid[i][j]==1 ? 0 : dp[j-1] + dp[j];
}
}
return dp[n-1];
}
};

tips：

沿用了滚动数组的技巧，额外空间缩减为O(n)，代码的效率也提升了。

==========================================

第二次过这道题，用dp过的。

class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
if (obstacleGrid.empty()) return 0;
const int m = obstacleGrid.size();
const int n = obstacleGrid[0].size();
int dp[m]
;
fill_n(&dp[0][0], m*n, 0);
for ( int i=0; i<n; ++i )
{
if ( obstacleGrid[0][i]==0 )
{
dp[0][i]=1;
}
else
{
break;
}
}
for ( int i=0; i<m; ++i )
{
if ( obstacleGrid[i][0]==0 )
{
dp[i][0]=1;
}
else
{
break;
}
}
for ( int i=1; i<m; ++i )
{
for ( int j=1; j<n; ++j )
{
if ( obstacleGrid[i][j]==0 )
{
dp[i][j] = dp[i-1][j] + dp[i][j-1];
}
}
}
return dp[m-1][n-1];
}
};