不同路径
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。问总共有多少条不同的路径？
例如，上图是一个7 x 3 的网格。有多少可能的路径？
说明：m 和 n 的值均不超过 100。
示例 : 输入: m = 3, n = 2; 输出: 3
解释: 从左上角开始，总共有 3 条路径可以到达右下角。
- 向右 -> 向右 -> 向下
- 向右 -> 向下 -> 向右
- 向下 -> 向右 -> 向右
分析：采用动态规划，如果采用回溯则时间复杂度高
//动态规划
class Solution {
public:
int uniquePaths(int m, int n) {
if (m == 0 || n == 0) {
return 0;
}
vector<vector<int>> dp(m, vector<int>(n));
dp[0][0] = 1;
for (int i = 1; i < m; i++) {
dp[i][0] = dp[i - 1][0];
}
for (int j = 1; j < n; j++) {
dp[0][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];
}
}
return dp[m - 1][n - 1];
}
};
//回溯
class Solution {
public:
int uniquePaths(int m, int n) {
if (m <= 0 || n <= 0)
return 0;
return findPath(0,0,m,n);
}
int findPath(int x, int y,int m,int n)
{
if ( x >= m || y >= n)
return 0;
if (x == m - 1 && y == n - 1)
return 1;
return findPath(x + 1, y, m, n) + findPath(x, y + 1, m, n);
}
};不同路径II
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
分析： 采用动态规划
class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
int m = obstacleGrid.size();
if (m == 0)
return 0;
int n = obstacleGrid[0].size();
if (n == 0)
return 0;
vector<vector<long>> dp(m, vector<long>(n, 0));
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
{
if (obstacleGrid[i][j] == 1)
{
dp[i][j] = 0;
continue;
}
if (i == 0 && j == 0) {
dp[i][j] = 1;
continue;
}
if (i == 0)
{
dp[i][j] = dp[0][j - 1];
}
else if (j == 0) {
dp[i][j] = dp[i - 1][j];
}
else
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
return dp[m - 1][n - 1];
}
};不同路径 III
在二维网格 grid 上，有 4 种类型的方格：1 表示起始方格。且只有一个起始方格。2 表示结束方格，且只有一个结束方格。0 表示我们可以走过的空方格。-1 表示我们无法跨越的障碍。返回在四个方向（上、下、左、右）上行走时，从起始方格到结束方格的不同路径的数目，每一个无障碍方格都要通过一次。
示例 ：输入：[[1,0,0,0],[0,0,0,0],[0,0,2,-1]], 输出：2
解释：我们有以下两条路径：
- (0,0),(0,1),(0,2),(0,3),(1,3),(1,2),(1,1),(1,0),(2,0),(2,1),(2,2)
- (0,0),(1,0),(2,0),(2,1),(1,1),(0,1),(0,2),(0,3),(1,3),(1,2),(2,2)
分析： 让我们尝试遍历每一个 0 方格，并在走过的方格里留下一个障碍。回溯的时候，我们要删除那些自己留下的障碍。介于输入数据的限制，这个方法是可以通过的，因为一个不好的路径很快就会因没有无障碍的方格可以走而被卡住。dfs.首先统计空的个数作为必须走的步数.当达到grid[i][j]==2时,判断步数step是否为0.
class Solution {
int dfs(vector<vector<int>>& grid, int r, int c, int n) {
if (r < 0 || r >= grid.size() || c < 0 || c >= grid[r].size() || grid[r][c] == -1) return 0;
if (grid[r][c] == 2) return n == 0 ? 1 : 0;
grid[r][c] = -1;
int sum = dfs(grid, r + 1, c, n - 1) + dfs(grid, r - 1, c, n - 1) + dfs(grid, r, c + 1, n - 1) + dfs(grid, r, c - 1, n - 1);
grid[r][c] = 0;
return sum;
}
public:
int uniquePathsIII(vector<vector<int>>& grid) {
int step = 1, r = 0, c = 0;
for (int i = 0; i < grid.size(); ++i)
for (int j = 0; j < grid[i].size(); ++j)
if (grid[i][j] == 1) r = i, c = j;
else if (grid[i][j] == 0) ++step;
return dfs(grid, r, c, step);
}
};最小路径和
给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。说明：每次只能向下或者向右移动一步。
示例: 输入: [ [1,3,1], [1,5,1], [4,2,1] ]，输出: 7。解释: 因为路径 1→3→1→1→1 的总和最小。
分析： 动态规划
class Solution {
public:
int minPathSum(vector<vector<int>>& grid) {
int row = grid.size();
if (row == 0)
return 0;
int column = grid[0].size();
vector<vector<int>>dp(row,vector<int>(column,0));
dp[0][0] = grid[0][0];
for (int i = 1; i < row; i++)
dp[0][i] = dp[0][i-1]+grid[0][i];
for (int i = 1; i < column; i++)
dp[i][0] = dp[i-1][0] + grid[i][0];
for(int i=1;i<row;i++)
for (int j = 1; j < column; j++)
dp[i][j] = min(dp[i-1][j],dp[i][j-1])+grid[i][j];
return dp[row-1][column-1];
}
};
