62.不同路径
1.动规5部曲。(1)确定dp数组及下标含义:dp数组下标通常和我们求取的目标相联系起来。本题是求左上角到右下角的不同路径个数,一个很容易想到的定义是dp[i][j] :表示从(0 ,0)出发,到(i, j) 有dp[i][j]条不同的路径。(2)确定递推公式,机器人每次只能向下或者向右移动一步。那么很自然,dp[i][j] = dp[i - 1][j] + dp[i][j - 1],因为dp[i][j]只有这两个方向过来。(事实上,递推公式就是状态转移方程。推导公式时,一个很重要的思路就是想一下当前状态可能由哪几种状态转移过来,或者说抵达目前状态之前可能有几种状态)(3)数组初始化:首先dp[i][0]一定都是1,因为从(0, 0)的位置到(i, 0)的路径只有一条,那么dp[0][j]也同理。所以初始化代码为:
for (int i = 0; i < m; i++) dp[i][0] = 1;
for (int j = 0; j < n; j++) dp[0][j] = 1;
(4)确定遍历顺序这里要看一下递推公式dp[i][j] = dp[i - 1][j] + dp[i][j - 1],dp[i][j]都是从其上方和左方推导而来,那么从左到右一层一层遍历就可以了。这样就可以保证推导dp[i][j]的时候,dp[i - 1][j] 和 dp[i][j - 1]一定是有数值的。(5)举例推导dp数组验证结果。
class Solution {
public:
int uniquePaths(int m, int n) {
if (m == 1 || n == 1)
return 1;
vector<vector<int>> dp(m, vector<int>(n, 1));
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
dp[i][j] = dp[i][j - 1] + dp[i - 1][j];
}
}
return dp[m - 1][n - 1];
}
};
2.数论法:直接求组合数。(求组合的时候,要防止两个int相乘溢出!求取的时候要保证除得尽才做除法,还是有难度的。)
class Solution {
public:
int uniquePaths(int m, int n) {
long long numerator = 1; // 分子
int denominator = m - 1; // 分母
int count = m - 1;
int t = m + n - 2;
while (count--) {
numerator *= (t--);
while (denominator != 0 && numerator % denominator == 0) {
numerator /= denominator;
denominator--;
}
}
return numerator;
}
};
3.一维数组空间优化版。(注意到dp[i][j] = dp[i][j - 1] + dp[i - 1][j]中dp[i - 1][j]状态可以拷贝到dp[i][j]上,那么状态转移方程可变为dp[i][j] = dp[i][j - 1] + dp[i][j],不再需要i即变为dp[i] += dp[i - 1])
class Solution {
public:
int uniquePaths(int m, int n) {
vector<int> dp(n);
for (int i = 0; i < n; i++) dp[i] = 1;
for (int j = 1; j < m; j++) {
for (int i = 1; i < n; i++) {
dp[i] += dp[i - 1];
}
}
return dp[n - 1];
}
};
63.不同路径 II
1.和不同路径相同的思路。区别在于初始化和遍历过程中要多考虑有石块的情况。
class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
int m = obstacleGrid.size();
int n = obstacleGrid[0].size();
//起始位置堵住直接返回
if (obstacleGrid[0][0] == 1)
return 0;
//起始位置没被堵住设为1
obstacleGrid[0][0] = 1;
//边界位置没被石头堵住之前设为1,堵住之后设为0
for (int i = 1; i < n; i++) {
if (obstacleGrid[0][i] != 1)
obstacleGrid[0][i] = obstacleGrid[0][i - 1];
else
obstacleGrid[0][i] = 0;
}
for (int j = 1; j < m; j++) {
if (obstacleGrid[j][0] != 1)
obstacleGrid[j][0] = obstacleGrid[j - 1][0];
else
obstacleGrid[j][0] = 0;
}
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
//堵住,该点路径条数为0
if (obstacleGrid[i][j] == 1) {
obstacleGrid[i][j] = 0;
} else {
//没堵住路径等于之前路径之和
obstacleGrid[i][j] =
obstacleGrid[i - 1][j] + obstacleGrid[i][j - 1];
}
}
}
return obstacleGrid[m - 1][n - 1];
}
};
2.随想录版
class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
int m = obstacleGrid.size();
int n = obstacleGrid[0].size();
if (obstacleGrid[m - 1][n - 1] == 1 ||
obstacleGrid[0][0] == 1) //如果在起点或终点出现了障碍,直接返回0
return 0;
vector<vector<int>> dp(m, vector<int>(n, 0));
for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++)
dp[i][0] = 1;
for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++)
dp[0][j] = 1;
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
if (obstacleGrid[i][j] == 1)
continue;
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
}
return dp[m - 1][n - 1];
}
};
3.空间优化版
class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
if (obstacleGrid[0][0] == 1)
return 0;
vector<int> dp(obstacleGrid[0].size());
for (int j = 0; j < dp.size(); ++j)
if (obstacleGrid[0][j] == 1)
dp[j] = 0;
else if (j == 0)
dp[j] = 1;
else
dp[j] = dp[j-1];
for (int i = 1; i < obstacleGrid.size(); ++i)
for (int j = 0; j < dp.size(); ++j){
if (obstacleGrid[i][j] == 1)
dp[j] = 0;
else if (j != 0)
dp[j] = dp[j] + dp[j-1];
}
return dp.back();
}
};
今日总结:不同路径。