Leetcode 动态规划 Unique Paths II

本文为senlie原创，转载请保留此地址：http://blog.csdn.net/zhengsenlie

Unique Paths II

  Total Accepted: 13655  Total Submissions: 49081 My Submissions

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.

题意：给定一个 m * n 的网格，网格中1表示障碍，不可走；0表示可走。
一个机器人要从左上角走到右下角，每次只能向下或向右移动一个位置，
问有多少种走法
思路1：记忆化搜索
使用一个两维 paths[i][j]记录 (i,j)到(m,n)的路径数
先把 paths 数组里的所有元素都置为 -1，表示之前没有搜索过(i,j)到(m,n）的路径
再把 obstacleGrid[i][j] 数组里为 1的对应 paths[i][j] 转为 0，表示从(i,j)到不了(m,n)
用 dfs 去枚举各种可能的路径情况
复杂度：时间 O(2^n) 空间O(n)


思路2：dp
用 f[i][j] 表示从 (0,0)到 (i, j)的路径数，则状态转移方程为
f[i][j] = f[i - 1][j] + f[i][j - 1]
实现的时候，可以只用一个一维的数组paths[j]表示外循环第i次迭代内循环第j次迭代对应的paths值
在还没更新状态时，paths[j]对应f[i - 1][j]; paths[j - 1]对应f[i][j - 1]
复杂度：时间 O(n)，空间O(n)

int paths[101][101];
int mm, nn;
int dfs(int x, int y){
	if(x >= mm || y >= nn) return 0;
	if(paths[x][y] >= 0) return paths[x][y];
	if(x == mm - 1 && y == nn - 1) return 1;
	return paths[x][y] = dfs(x + 1, y) + dfs(x, y + 1);
}
int uniquePathsWithObstacles(vector<vector<int> >&obstacleGrid){
	mm = obstacleGrid.size(), nn = obstacleGrid[0].size();
	memset(paths, -1, sizeof(paths));
	for(unsigned int i = 0; i < obstacleGrid.size(); ++i)
		for(unsigned int j = 0; j < obstacleGrid[0].size(); ++j){
			if(obstacleGrid[i][j] == 1) paths[i][j] = 0;
		}
	return dfs(0, 0);
}




int paths[101];
int uniquePathsWithObstacles(vector<vector<int> > &obstacleGrid){
	memset(paths, 0, sizeof(paths));
	int m = obstacleGrid.size(), n = obstacleGrid[0].size();
	if(obstacleGrid[0][0] || obstacleGrid[m- 1][n - 1]) return 0;
	paths[0] = obstacleGrid[0][0] ? 0 : 1;
	for(int i = 0 ; i < m; ++i){
		for(int j = 0; j < n; ++j){
			if(obstacleGrid[i][j] ) paths[j] = 0; 
			else paths[j] = obstacleGrid[i][j] ? 0 : ( j == 0 ? 0: paths[j - 1]) + paths[j];
		}
	}
	return paths[n - 1];
}