不同路径
一个机器人位于一个 m x n 网格的左上角 (起始点在下图中标记为 “Start” )。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角(在下图中标记为 “Finish” )。
问总共有多少条不同的路径?
示例 1:
- 输入:m = 3, n = 7
- 输出:28
示例 2:
- 输入:m = 2, n = 3
- 输出:3
解释: 从左上角开始,总共有 3 条路径可以到达右下角。
- 向右 -> 向右 -> 向下
- 向右 -> 向下 -> 向右
- 向下 -> 向右 -> 向右
示例 3:
- 输入:m = 7, n = 3
- 输出:28
示例 4:
- 输入:m = 3, n = 3
- 输出:6
提示:
- 1 <= m, n <= 100
- 题目数据保证答案小于等于 2 * 10^9
图和路径,DFS可解决此题但超时;
使用动态规划:
1.确定dp数组及其下标含义
很明显,此题为二维数组dp[i][j],含义为从dp[0][0]到下标dp[i][j]位置的所有路径
2.确定递推公式:
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];因为要求求的是路径总和,而不是步数总和;
3.初始化dp数组:
从递归公式可以看出,每个dp[i][j]都是由左边或者上边的元素得到的;
所以初始化应该初始化最左边和最上边的元素,即dp[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.确定遍历顺序:
由题目可知,要求路径从左往右,从上往下;
所以只需要从上往下按照层数依次遍历,每一层从左往右遍历即可,这样可以避免左方或上方数值为空的情况;
(这里先纵向再横向也是可以ac的)
for(int i = 0; i < m; i++){
for(int j = 0; j < n; j++){
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
}
5.打印dp数组:
代码实现如下:
#include<iostream>
#include<stdio.h>
#include<vector>
using namespace std;
class solution {
public:
int differentPaths(int m, int n) {
vector<vector<int>> dp(m, vector<int>(n, 0));//定义dp数组
//初始化dp数组
for (int i = 0; i < m; i++) {//因为纵向只能向下走
dp[i][0] = 1;
}
for (int j = 0; j < n; j++) {//因为横向只能向右走
dp[0][j] = 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];//遍历过程
}
}
cout << "The DP array will be shown as below:" << endl;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cout << dp[i][j] << "\t";
}
cout << endl;
}
cout << endl;
return dp[m - 1][n - 1];
}
};
int main() {
int m, n;
cout << "Please enter the target length and width of this graph, separated by enter:" << endl;
cin >> m >> n;
solution mySolution;
cout << "There are " << mySolution.differentPaths(m, n) << " path(s) in this graph." << endl;
return 0;
}
不同路径Ⅱ
一个机器人位于一个 m x n 网格的左上角 (起始点在下图中标记为“Start” )。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角(在下图中标记为“Finish”)。
现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径?
网格中的障碍物和空位置分别用 1 和 0 来表示。
示例 1:
- 输入:obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
- 输出:2 解释:
- 3x3 网格的正中间有一个障碍物。
- 从左上角到右下角一共有 2 条不同的路径:
- 向右 -> 向右 -> 向下 -> 向下
- 向下 -> 向下 -> 向右 -> 向右
示例 2:
- 输入:obstacleGrid = [[0,1],[0,0]]
- 输出:1
提示:
- m == obstacleGrid.length
- n == obstacleGrid[i].length
- 1 <= m, n <= 100
- obstacleGrid[i][j] 为 0 或 1
思路和上题是一模一样的,没有什么太难的地方,就是在障碍格加上条件;
1.确定dp数组及其下标含义:
dp[i][j]依然是到达对应下标处可能的路径数;
2.确认递推公式:
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
3.dp数组初始化:
这里就可以看出和之前明显的区别了;引入了obstacles数组,所以当初始化遇到的obstacles[i][j] == 0的时候,直接停止接下来的初始化操作;
4.确定遍历顺序:
也就小小的差别,当遍历到障碍物的时候,不改变此处的dp[i][j]的值即可,别的和上题一直;
5.打印dp数组:
以例一为例:
整体代码如下:
#include<iostream>
#include<vector>
using namespace std;
class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int>> obstacleGrid) {
int m = obstacleGrid.size();
int n = obstacleGrid[0].size();
if (obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1) 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];
}
}
cout << "The dp array will be shown as below:" << endl;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cout << dp[i][j] << "\t";
}
cout << endl;
}
cout << endl;
return dp[m - 1][n - 1];
}
};
int main() {
cout << "Please enter the rows and cols of obstacle grid, separated by enter:" << endl;
int rows, cols;
cin >> rows >> cols;
vector<vector<int>> arr(rows, vector<int>(cols, 0));
cout << "Please enter the obstacle grid, '1' symbolizes obstacle while '0' means clear:" << endl;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
cin >> arr[i][j];
}
}
Solution mySolution;
cout << mySolution.uniquePathsWithObstacles(arr) << endl;
return 0;
}