A robot is located at the top-left corner of a m x n grid (marked ‘Start’ in the diagram below).
The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked ‘Finish’ in the diagram below).
How many possible unique paths are there?
Above is a 3 x 7 grid. How many possible unique paths are there?
Note: m and n will be at most 100.
咋一看,深搜之,直接超时~~
然后发现是可以拿DP做的,思考出来一个DP方程,虽然不是很优化但是一次过了还是很开心的
以下代码展现了一些思考过程:
1、深搜
2、visit标记数组,仔细分析发现不会走过已经走的路
3、dp[i][j]=dp[i-1][j]+dp[i][j-1] 一开始想着倒推,然后一想似乎不能倒推,是从第一步开始走的
class Solution {
public:
int dir[2][2]={{1,0},{0,1}};
int route=0;
int m,n;
int uniquePaths(int m, int n) {
this->m=m;
this->n=n;
// vector<vector<char> > visit(m,n);
// char visit[m][n];
// memset(visit,0,sizeof(visit));
// dfs(1,1);
// return route;
// vector<vector<int> > dp(m,n);
int dp[m+2][n+2];
memset(dp,0,sizeof(dp));
dp[1][1]=1;
for(int i=1;i<=m;i++){
for(int j=1;j<=n;j++){
dp[i][j+1]=dp[i][j]+dp[i-1][j+1];
dp[i+1][j]=dp[i][j]+dp[i+1][j-1];
}
}
return dp[m][n];
//不能倒推
// for(int i=m-1;i>0;i--){
// for(int j=n-1;j>0;j--){
// dp[i][j]=dp[i-1][j]+dp[i][j-1];
// }
// }
}
void dfs(int x,int y){
if(x==m && y==n){
route++;
return;
}
for(int i=0;i<2;i++){
int next_x=x+dir[i][0];
int next_y=y+dir[i][1];
//只存在越界,不存在反复访问
if(next_x>m || next_y>n) continue;
// if(visit[next_x][next_y])
dfs(next_x,next_y);
}
}
};
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.
相比较I的话,II只是增加了一点障碍,使得在进入DP的时候需要一些条件。
由于不小心写错了一个条件所以导致debug好久
不过执行的时间似乎有点长,还有待优化:
参考链接:https://discuss.leetcode.com/topic/15267/4ms-o-n-dp-solution-in-c-with-explanations
class Solution {
public:
int m,n;
vector<vector<int> > obstacleGrid;
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
int m=obstacleGrid.size();
if(m==0) return 0;
int n=obstacleGrid[0].size();
// if(m==1 && n==1) return !obstacleGrid[0][0];
if(obstacleGrid[0][0]) return 0;
int dp[m+2][n+2];
this->m=m;
this->n=n;
this->obstacleGrid=obstacleGrid;
memset(dp,0,sizeof(dp));
dp[1][1]=1;
for(int i=1;i<=m;i++){
for(int j=1;j<=n;j++){
if(!reachAble(i,j)) continue;
//这一点是可达的
if(reachAble(i,j+1)){
dp[i][j+1]=dp[i][j]+reachAble(i-1,j+1)*dp[i-1][j+1];
}
if(reachAble(i+1,j)){
dp[i+1][j]=dp[i][j]+reachAble(i+1,j-1)*dp[i+1][j-1];
}
}
}
return dp[m][n];
}
int reachAble(int x,int y){
int i=x-1,j=y-1;
if(i>=m || i<0 || j>=n || j<0) return 0;
return !obstacleGrid[i][j];
}
};