1不同路径
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
问总共有多少条不同的路径？
示例 1：
输入：m = 3, n = 7 输出：28
示例 2：
输入：m = 3, n = 2 输出：3 解释： 从左上角开始，总共有 3 条路径可以到达右下角。 1. 向右 -> 向下 -> 向下 2. 向下 -> 向下 -> 向右 3. 向下 -> 向右 -> 向下
示例 3：
输入：m = 7, n = 3 输出：28
示例 4：
输入：m = 3, n = 3 输出：6
提示：
1 <= m, n <= 100- 题目数据保证答案小于等于
2 * 109
思路：
. 确定dp数组（dp table）以及下标的含义
在本问题中，我们定义一个二维dp数组：
dp[i][j]表示从左上角（0, 0）到达格子(i, j)的不同路径数量。
2. 确定递推公式
到达格子 (i, j) 的路径数量可以由以下两种方式得到：
- 从上方的格子
(i-1, j)到达(i, j)，因此路径数量为dp[i-1][j]。 - 从左边的格子
(i, j-1)到达(i, j)，因此路径数量为dp[i][j-1]。
因此，递推公式为：
𝑑𝑝[𝑖][𝑗]=𝑑𝑝[𝑖−1][𝑗]+𝑑𝑝[𝑖][𝑗−1]dp[i][j]=dp[i−1][j]+dp[i][j−1]
3. dp数组如何初始化
根据问题的特性，初始化dp数组的边界值：
- 第一列的每个格子的路径数量都为1，因为只能从上方走到这些格子。
- 第一行的每个格子的路径数量都为1，因为只能从左边走到这些格子。
4. 确定遍历顺序
我们从 i = 1 和 j = 1 开始遍历，因为第一行和第一列已经初始化了，然后按照从上到下、从左到右的顺序更新dp数组的值。
5. 举例推导dp数组
以一个具体的例子来推导dp数组的值（假设 m = 3 和 n = 3）：
-
初始化：
𝑑𝑝=[111100100]dp=⎣⎡111100100⎦⎤
第一行和第一列都初始化为1。
-
计算
dp[1][1]：dp[1][1] = dp[0][1] + dp[1][0] = 1 + 1 = 2 -
计算
dp[1][2]：dp[1][2] = dp[0][2] + dp[1][1] = 1 + 2 = 3 -
计算
dp[2][1]：dp[2][1] = dp[1][1] + dp[2][0] = 2 + 1 = 3 -
计算
dp[2][2]：dp[2][2] = dp[1][2] + dp[2][1] = 3 + 3 = 6
最终的dp数组：
𝑑𝑝=[111123136]dp=⎣⎡111123136⎦⎤
因此，到达右下角 (2, 2) 的路径数量是6。
代码：
class Solution {
public:
int uniquePaths(int m, int n) {
vector<vector<int>> dp(m, vector<int>(n, 0)); // 创建一个大小为 m x n 的二维动态规划数组，用于记录到达每个格子的路径数量
for (int i = 0; i < m; i++) dp[i][0] = 1; // 初始化第一列，只能向下走，所以路径数量都为 1
for (int j = 0; j < n; j++) dp[0][j] = 1; // 初始化第一行，只能向右走，所以路径数量都为 1
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
// 到达当前格子的路径数量等于从上方格子到达当前格子的路径数量加上从左边格子到达当前格子的路径数量
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
}
return dp[m - 1][n - 1]; // 返回到达右下角格子的路径数量
}
};
2不同路径 II
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。
现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
网格中的障碍物和空位置分别用 1 和 0 来表示。
示例 1：
输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
输出：2
解释：3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：
1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右
示例 2：
输入：obstacleGrid = [[0,1],[0,0]] 输出：1
提示：
m == obstacleGrid.lengthn == obstacleGrid[i].length1 <= m, n <= 100obstacleGrid[i][j]为0或1
思路：
1. 确定dp数组（dp table）以及下标的含义
在这个问题中，我们定义一个二维dp数组：
dp[i][j]表示从起点 (0, 0) 到达格子(i, j)的不同路径数量。
2. 确定递推公式
到达格子 (i, j) 的路径数量可以由以下两种方式得到：
- 从上方的格子
(i-1, j)到达(i, j)，因此路径数量为dp[i-1][j]。 - 从左边的格子
(i, j-1)到达(i, j)，因此路径数量为dp[i][j-1]。
因此，递推公式为：
𝑑𝑝[𝑖][𝑗]=𝑑𝑝[𝑖−1][𝑗]+𝑑𝑝[𝑖][𝑗−1]dp[i][j]=dp[i−1][j]+dp[i][j−1]
但是，如果 obstacleGrid[i][j] 为障碍（即1），则 dp[i][j] 为0，表示无法到达该位置。
3. dp数组如何初始化
-
首先处理边界情况：如果起点
(0, 0)或终点(m-1, n-1)有障碍，路径数量为0，直接返回0。 -
初始化第一列和第一行：
- 第一列：如果没有障碍，那么路径数量为1，因为只能从上方走到达。
- 第一行：如果没有障碍，那么路径数量为1，因为只能从左边走到达。
需要注意的是，如果第一列或第一行中有障碍，那么障碍之后的所有格子的路径数量都应为0，因为障碍会阻挡路径。
4. 确定遍历顺序
我们从 i = 1 和 j = 1 开始遍历，因为第一行和第一列已经初始化了，然后按照从上到下、从左到右的顺序更新dp数组的值。
5. 举例推导dp数组
以一个具体的例子来推导dp数组的值（假设 obstacleGrid 为 [[0,0,0],[0,1,0],[0,0,0]]）：
第一行和第一列根据障碍情况进行初始化为1。
-
计算
dp[1][1]：因为obstacleGrid[1][1]是障碍，因此dp[1][1] = 0。 -
计算
dp[1][2]：dp[1][2] = dp[0][2] + dp[1][1] = 1 + 0 = 1。 -
计算
dp[2][1]：dp[2][1] = dp[1][1] + dp[2][0] = 0 + 1 = 1。 -
计算
dp[2][2]：dp[2][2] = dp[1][2] + dp[2][1] = 1 + 1 = 2。
因此，到达右下角 (2, 2) 的路径数量是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)); // 创建一个大小为 m x n 的二维动态规划数组，用于记录到达每个格子的路径数量
for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) dp[i][0] = 1; // 初始化第一列，如果没有障碍，路径数量都为 1
for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1; // 初始化第一行，如果没有障碍，路径数量都为 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]; // 返回到达右下角格子的路径数量
}
};
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
