Day 39 62.不同路径 63.不同路径Ⅱ

不同路径

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

示例 1：

• 输入：m = 3, n = 7
• 输出：28

示例 2：

• 输入：m = 2, n = 3
• 输出：3

解释： 从左上角开始，总共有 3 条路径可以到达右下角。

1. 向右 -> 向右 -> 向下
2. 向右 -> 向下 -> 向右
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 条不同的路径：
  1. 向右 -> 向右 -> 向下 -> 向下
  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;
}