62. 不同路径
题目描述
一个机器人位于一个 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
思路分析
方法一:深搜
机器人只能向下和向右走,所以按照Dfs的书写步骤来操作即可. 但是由于深搜的时间复杂度是 O ( 2 ( m + n − 1 ) ) O(2^(m+n-1)) O(2(m+n−1)) 的,所以会超时!
方法二:动态规划
机器人从(0 , 0) 位置出发,到(m - 1, n - 1)终点。
按照 动规五部曲 来分析:
- 确定dp数组以及下标的含义
dp[i][j]
:表示从(0 ,0)出发,到(i, j) 有 dp[i][j] 条不同的路径。
- 确定递推公式
要求dp[i][j]
,只能有两个方向来推导出来,即dp[i - 1][j]
和 dp[i][j - 1]
。
此时在回顾一下 dp[i - 1][j]
表示啥,是从(0, 0)的位置到(i - 1, j)有几条路径,dp[i][j - 1]
同理。
那么很自然,dp[i][j] = dp[i - 1][j] + dp[i][j - 1],因为dp[i][j]只有这两个方向过来。
- dp数组的初始化
如何初始化呢,首先dp[i][0]
一定都是1,因为从(0, 0)的位置到(i, 0)的路径只有一条,那么dp[0
][j]也同理。
- 定遍历顺序
这里要看一下递归公式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]
一定是有数值的。
- 举例推导dp数组
参考代码
方法一:深搜
//方法一:深搜..
int sum;//路的条数
int Next[2][2] = {{1,0},{0,1}} ;//定义方向数组
void dfs(int m,int n,int x,int y) {
if(x==m && y==n) { //递归结束条件
sum++;
return;
}
for(int i = 0; i <2; i++) {
//判断是否越界
int nextX = x + Next[i][0];
int nextY = y + Next[i][1];
if(nextX>m || nextY > n) {//越界
continue;
}
//继续dfs
dfs(m,n,nextX,nextY);
//不需要回溯,因为 每次这条路不行就走另外一条了,x,y还和之前一样.. 另外行进也是越来越靠近目标点的,也不用做标记啥的.
}
}
int uniquePaths(int m, int n) {
dfs(m,n,1,1) ;
return sum;
}
//备注:大佬的dfs,呜呜呜,同样的深搜,人家可以写的如此短小精悍
int dfs(int i, int j, int m, int n) {
if(i>m || j > n) {//越界了
return 0;
}
if(i==m&&j==n) {//找到了另外一种方法
return 1;
}
return dfs(i+1,j,m,n) + dfs(i,j+1,m,n);
}
方法二:动态规划
//方法二:动归
int uniquePaths(int m, int n) {
vector<vector<int>> dp(m,vector<int>(n,0));
//dp[0][j]和dp[i][0]初始化为1,因为路径只有一条
for(int i = 0; i < m; i++){
dp[i][0] = 1;
}
for(int j = 0; j < n;j++){
dp[0][j] = 1;
}
//根据状态转移方程dp[i][j] = dp[i-1][j] + dp[i][j-1],推出dp[m-1][n-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];
}
63. 不同路径 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
思路分析
这道题相对于62.不同路径 (opens new window)就是有了障碍。这有障碍了,应该怎么算呢?
动规五部曲:
- 确定dp数组以及下标的含义
dp[i][j]
:表示从(0 ,0)出发,到(i, j) 有dp[i][j]
条不同的路径。
- 确定递推公式
递推公式和 62.不同路径 一样,dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
。
但这里需要注意一点,因为有了障碍,(i, j)如果就是障碍的话应该就保持初始状态(初始状态为0)。
- dp数组如何初始化
因为从(0, 0)的位置到(i, 0)的路径只有一条,所以dp[i][0]
一定为1,dp[0][j]
也同理。
但如果(i, 0) 这条边有了障碍之后,障碍之后(包括障碍)都是走不到的位置了,所以障碍之后的dp[i][0]
应该还是初始值0。
如图:
- 确定遍历顺序
从递归公式dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
中可以看出,一定是从左到右一层一层遍历,这样保证推导dp[i][j]
的时候,dp[i - 1][j] 和 dp[i][j - 1]
一定是有数值。
- 举例推导dp数组
拿示例1来举例如题:
对应的dp 如图:
参考代码
#include<bits/stdc++.h>
using namespace std;
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
int m = obstacleGrid.size();
int n = obstacleGrid[0].size();
vector<vector<int>> dp(m,vector<int>(n,0));
//dp初始化 第一行和第一列初始化为1,但是障碍物之后初始化为0
for(int i = 0; i < m; i++) {
if(!obstacleGrid[i][0]) {
dp[i][0] = 1;
} else {
break;//如果此处是障碍物,后序dp[i][0]为0
}
}
for(int j = 0; j < n; j++) {
if(obstacleGrid[i][j]==0) {
dp[0][j] = 1;
} else {
break;//如果此处是障碍物,后序dp[i][0]为0
}
}
//推导dp
for(int i = 1; i < m; i++) {
for(int j = 1; j < n; j++) {
if(obstacleGrid[0][j]) { //如果是障碍物,则跳过.
continue;
}
dp[i][j] = dp[i-1][j] + dp[i][j-1];
}
}
return dp[m-1][n-1];
}
343. 整数拆分
题目描述
给定一个正整数 n
,将其拆分为 k
个 正整数 的和( k >= 2
),并使这些整数的乘积最大化。
返回 你可以获得的最大乘积 。
示例 1:
输入: n = 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1。
示例 2:
输入: n = 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。
思路分析
动规五部曲
- 确定dp数组以及下标的含义
dp[i]:分拆数字i,可以得到的最大乘积为dp[i]。
- 确定递推公式
可以想 dp[i]
最大乘积是怎么得到的呢?
其实可以从1遍历j,然后有两种渠道得到dp[i].
一个是j * (i - j)
直接相乘。
一个是j * dp[i - j]
,相当于是拆分(i - j),对这个拆分不理解的话,可以回想dp数组的定义。
那有同学问了,j怎么就不拆分呢?
j是从1开始遍历,拆分j的情况,在遍历j的过程中其实都计算过了。
所以递推公式:dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
那么在取最大值的时候,为什么还要比较dp[i]呢?
因为在递推公式推导的过程中,每次计算dp[i],要取最大值。
- dp的初始化
dp[0] dp[1]应该初始化多少呢?
有的题解里会给出dp[0] = 1,dp[1] = 1的初始化,但解释比较牵强,主要还是因为这么初始化可以把题目过了。
严格从dp[i]的定义来说,dp[0] dp[1] 就不应该初始化,也就是没有意义的数值。而且题目中 n >=2
这里我只初始化dp[2] = 1,从dp[i]的定义来说,拆分数字2,得到的最大乘积是1,这个没有任何异议!
- 确定遍历顺序
确定遍历顺序,先来看看递归公式:dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
dp[i] 是依靠 dp[i - j]的状态,所以遍历i一定是从前向后遍历,先有dp[i - j]再有dp[i]。
枚举j的时候,是从1开始的。i是从3开始,这样dp[i - j]就是dp[2]正好可以通过我们初始化的数值求出来。
另外 i-j > 1 => j < i - 1
,这个可以作为j的循环条件
- 举例推导dp数组
当n为10 的时候,dp数组里的数值,如下:
参考代码
#include<bits/stdc++.h>
using namespace std;
/*
1.DP定义:将整数i进行拆分后乘积最大值为dp[i]
2.状态转移方程:
2.1 设一个j为i拆分后的一个数 则另外一个数为(i-j)
2.2 (i-j)可以直接与j进行相乘 也可以进行拆分后与i进行相乘
2.3 dp[i] = max(j*(i-j),j*dp[i-j])
3.初始化base case:
0和1进行拆分是无意义的 由n的范围[2,58]也可知
因此dp[0]/dp[1]是无意义的 同时也不需要进行赋值 在后面的程序中也不应该用到dp[0]/dp[1]
故初始化dp[2]=1.
4.遍历顺序:见下文
*/
int integerBreak(int n) {
vector<int> dp(n+1,0);
dp[2] = 1;
//遍历从3到n 填充这些数对应的dp值
//目标结果:dp[n]
for(int i = 3; i <= n; i++) {
// 由于dp[2]及其之后才有意义,所以 i-j >1 即j<i-1
for(int j = 1; j < i - 1; j++) {
dp[i] = max(dp[i],max(j*(i-j),j*dp[i-j]));//因为求的是最大值,所以max中也需要dp[i]
}
}
//n拆分后的数集的最大乘积 即dp[n]
return dp[n];
}
96. 不同的二叉搜索树
题目描述
给你一个整数 n
,求恰由 n
个节点组成且节点值从 1
到 n
互不相同的 二叉搜索树 有多少种?返回满足题意的二叉搜索树的种数。
示例 1:
输入:n = 3
输出:5
示例 2:
输入:n = 1
输出:1
思路分析
我们先观察下有没有什么规律,如图:
来看看n为3的时候,有哪几种情况。
-
当1为头结点的时候,其右子树有两个节点,看这两个节点的布局,是不是和 n 为2的时候两棵树的布局是一样的啊!(我们求的是树的数量,所以不用关心其具体数值的差异)
-
当3为头结点的时候,其左子树有两个节点,看这两个节点的布局,是不是和n为2的时候两棵树的布局也是一样的啊!
-
当2为头结点的时候,其左右子树都只有一个节点,布局是不是和n为1的时候只有一棵树的布局也是一样的啊!
发现到这里,其实我们就找到了重叠子问题了,其实也就是发现可以通过dp[1] 和 dp[2] 来推导出来dp[3]的某种方式。
思考到这里,这道题目就有眉目了。
dp[3],就是 元素1为头结点搜索树的数量 + 元素2为头结点搜索树的数量 + 元素3为头结点搜索树的数量
-
元素1为头结点搜索树的数量 = 右子树有2个元素的搜索树数量 * 左子树有0个元素的搜索树数量
-
元素2为头结点搜索树的数量 = 右子树有1个元素的搜索树数量 * 左子树有1个元素的搜索树数量
-
元素3为头结点搜索树的数量 = 右子树有0个元素的搜索树数量 * 左子树有2个元素的搜索树数量
有2个元素的搜索树数量就是dp[2]。
有1个元素的搜索树数量就是dp[1]。
有0个元素的搜索树数量就是dp[0]。
所以dp[3] = dp[2] * dp[0] + dp[1] * dp[1] + dp[0] * dp[2]
如图所示:
此时我们已经找到递推关系了,那么可以用**动规五部曲**再系统分析一遍。
- 确定dp数组(dp table)以及下标的含义
dp[i] : 1到i为节点组成的二叉搜索树的个数为dp[i]。
以下分析如果想不清楚,就来回想一下dp[i]的定义
- 确定递推公式
在上面的分析中,其实已经看出其递推关系, dp[i] += dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量] (j相当于是头结点的元素,从1遍历到i为止。)
所以递推公式:dp[i] += dp[j - 1] * dp[i - j];
j-1 为j为头结点左子树节点数量,i-j 为以j为头结点右子树节点数量
- dp数组如何初始化
初始化,只需要初始化dp[0]就可以了,推导的基础,都是dp[0]。
那么dp[0]应该是多少呢?
从定义上来讲,空节点也是一棵二叉树,也是一棵二叉搜索树,这是可以说得通的。
从递归公式上来讲,dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量] 中以j为头结点左子树节点数量为0,也需要dp[以j为头结点左子树节点数量] = 1, 否则乘法的结果就都变成0了。
所以初始化dp[0] = 1
- 确定遍历顺序
首先一定是遍历节点数,从递归公式:dp[i] += dp[j - 1] * dp[i - j]
可以看出,节点数为i的状态是依靠 i之前节点数的状态。
那么遍历i里面每一个数作为头结点的状态,用j来遍历。
- 举例推导dp数组
n为5时候的dp数组状态如图:
参考代码
#include<bits/stdc++.h>
using namespace std;
int numTrees(int n) {
vector<int> dp(n+1,0) ;
dp[0] = 1;
for(int i = 1;i <= n;i++){
// cout<<"dp["<<i<<"]: ";
for(int j = 1; j <= i;j++){
dp[i] += dp[j-1] * dp[i-j];//状态转移方程
// cout<<dp[j-1] * dp[i-j]<<" ";
}
cout<<endl;
}
return dp[n];
}
如果有收获!!! 希望老铁们来个三连,点赞、收藏、转发。
创作不易,别忘点个赞,可以让更多的人看到这篇文章,顺便鼓励我写出更好的博客