【算法/动态规划/基础题目】题解+详细备注(共7题)
动态规划解题步骤
- 确定dp数组以及下标的含义
- 确定递推公式
- dp数组如何初始化
- 确定遍历顺序
- 举例推导dp数组
509.斐波那契数
class Solution {
public:
int fib(int n) {
if(n <= 1) return n;
// 1.确定dp数组以及下标的含义
// dp[i]的定义是:第i个数的斐波那契数值是dp[i]
vector<int> dp(n+1);
// 3.dp数组初始化
dp[0] = 0;
dp[1] = 1;
// 4.遍历顺序,从前往后遍历
for(int i = 2;i<=n;++i){
// 2.确定递推公式:dp[i] = dp[i-1] + dp[i-2];
dp[i] = dp[i-1]+dp[i-2];
}
// 5.举例推导
return dp[n];
}
};
70.爬楼梯
class Solution {
public:
int climbStairs(int n) {
// 1.确定dp数组以及下标的含义
// dp[i] 表示爬i阶楼梯一共右dp[i]种不同的方法
vector<int> dp(n+1);
// 3.dp数组的初始化
dp[0] = 0;
dp[1] = 1;
if(n > 1) dp[2] = 2;
// 4.确定遍历顺序,从前向后遍历
for(int i = 3;i<=n;++i){
// 2.确定递推公式:dp[i] = dp[i-1] + dp[i-2]
dp[i] = dp[i-1] + dp[i-2];
}
return dp[n];
// 5.举例推导dp数组
}
};
746.使用最小花费爬楼梯
class Solution {
public:
int minCostClimbingStairs(vector<int>& cost) {
int n = cost.size();
// 1.确定dp数组以及下标的含义
// dp[i]表示:到达第i个台阶所需要花费的最小体力值dp[i]
// 3.dp数组的初始化
vector<int> dp(n);
dp[0] = cost[0];
dp[1] = cost[1];
// 4.确定遍历顺序
for(int i = 2;i<n;++i){
// 2.确定递推公式:dp[i] = min(dp[i-1],dp[i-2]) + cost[i];
dp[i] = min(dp[i-1],dp[i-2]) + cost[i];
}
// 5.举例推导dp数组
// 返回值很重要,到达楼梯顶部的选择有两种:从n-1爬上来和n-2爬上来
return min(dp[n-1],dp[n-2]);
}
};
62.不同路径
class Solution {
public:
int uniquePaths(int m, int n) {
// 1.确定dp数组以及下标的含义
// dp[i][j]表示从(0,0)到(i,j)有dp[i][j]种不同的路径
vector<vector<int>> dp(m,vector<int>(n));
// 3.dp数组初始化
for(int i{};i<m;++i) dp[i][0] = 1;
for(int i{};i<n;++i) dp[0][i] = 1;
// 4.确定遍历顺序,从左到右,从上到下
for(int i{1};i<m;++i){
for(int j{1};j<n;++j){
// 2.确定递推公式:dp[i][j] = dp[i-1][j] + dp[i][j-1]
dp[i][j] = dp[i-1][j] + dp[i][j-1];
}
}
return dp[m-1][n-1];
// 5.举例推导
}
};
63.不同路径II
class Solution {
public:
// 与62.不同路径相比,处理障碍问题即可
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
int m = obstacleGrid.size();
int n = obstacleGrid[0].size();
// 1.确定dp数组以及下标的含义
// dp[i][j]表示从(0,0)到(i,j)有dp[i][j]种不同的路径
vector<vector<int>> dp(m,vector<int>(n));
// 3.dp数组初始化
for(int i{};i<m && obstacleGrid[i][0] == 0;++i){
dp[i][0] = 1;
}
for(int j{};j<n && obstacleGrid[0][j] == 0;++j){
dp[0][j] = 1;
}
// 4.确定遍历顺序,从左到右,从上到下
for(int i{1};i<m;++i){
for(int j{1};j<n;++j){
if(obstacleGrid[i][j] == 0){
// 2.确定递推公式:dp[i][j] = dp[i-1][j] + dp[i][j-1]
dp[i][j] = dp[i-1][j] + dp[i][j-1];
}
}
}
return dp[m-1][n-1];
}
};
343.整数拆分
class Solution {
public:
int integerBreak(int n) {
// 1.确定dp数组以及下标的含义
// dp[i]:分拆数字i,可以得到的最大乘积为dp[i]
vector<int> dp(n+1);
// 3.dp数组初始化(根据题意dp[0] 与 dp[1]的初始化意义不大)
dp[2] = 1;
// 4.确定遍历顺序 从小到大获取dp[i]
for(int i = 3;i<=n;++i){
for(int j = 1;j<i-1;++j){
// 2.确定递推公式 (i-j)*j表示拆分成了两个数 j*dp[i-j]表示拆分成了 2个以上的数
// dp[i] = max(dp[i],max((i-j)*j,j*dp[i-j]))
dp[i] = max(dp[i],max((i-j)*j,j*dp[i-j]));
}
}
return dp[n];
}
};
96.不同的二叉搜索树
class Solution {
public:
int numTrees(int n) {
// 1.确定dp数组以及下标的含义
// dp[i]:1到i为节点组成的二叉搜索树的个数为dp[i]
vector<int> dp(n+1);
// 3.dp数组的初始化,0个节点的数量为1
dp[0] = 1;
// 4.确定遍历顺序
for(int i = 1;i<=n;++i){
for(int j = 1;j<=i;++j){
// 2.确定递推公式:dp[i]+= dp[j-1]*dp[i-j]
// j-1为j为头节点左子树节点数量、i-j为j为头节点右子树的数量
dp[i] += dp[j-1]*dp[i-j];
}
}
// 5.举例推导dp数组
return dp[n];
}
};