打卡第38天,开始动态规划了。
今日任务
- 理论基础
- 509.斐波那契数
- 70.爬楼梯
- 746.使用最小花费爬楼梯
[理论基础]
什么是动态规划
动态规划,英文:Dynamic Programming,简称DP。如果一个问题有很多重叠子问题,使用动态规划是最有效的。
动态规划中的每一个状态都是由上一状态推演出来的,区别于贪心,贪心是求局部最优,达到全局最优。
动态规划的解题步骤
动态规划五部曲
- 确认dp数组以及下标的定义
- 确定递推公式
- dp数组如何初始化
- 确定遍历顺序
- 举例推导dp数组
动态规划如何debug
最好的方式就是把dp数组打印出来,看看是否按照自己的思路推导的。
做动态规划的题目最好就是,写代码之前在纸上把状态转移在dp数组上具体情况模拟一遍,做到心中有数。
如果debug发现dp数组与自己所推演的不一样,说明代码处理有问题。
509.斐波那契数
斐波那契数 (通常用 F(n)
表示)形成的序列称为 斐波那契数列 。该数列由 0
和 1
开始,后面的每一项数字都是前面两项数字的和。也就是:
F(0) = 0,F(1) = 1
F(n) = F(n - 1) + F(n - 2),其中 n > 1
给定 n
,请计算 F(n)
。
示例 1:
输入:n = 2
输出:1
解释:F(2) = F(1) + F(0) = 1 + 0 = 1
示例 2:
输入:n = 3
输出:2
解释:F(3) = F(2) + F(1) = 1 + 1 = 2
示例 3:
输入:n = 4
输出:3
解释:F(4) = F(3) + F(2) = 2 + 1 = 3
提示:
0 <= n <= 30
我的题解
- 确定dp数组以及下标定义
本题求斐波那契数列,还给出推导公式,dp是斐波那契数列,dp[i]表示第i项斐波那契数。 - 递推公式
题中已经给出 F ( n ) = F ( n − 1 ) + F ( n − 2 ) F(n) = F(n - 1) + F(n - 2) F(n)=F(n−1)+F(n−2),推导公式为 d p [ i ] = d p [ i − 1 ] + d p [ i − 2 ] dp[i] = dp[i - 1] + dp[i - 2] dp[i]=dp[i−1]+dp[i−2] - dp初始化
题目给出 F ( 0 ) = 0 , F ( 1 ) = 1 F(0) = 0,F(1) = 1 F(0)=0,F(1)=1
dp初始化 d p [ 0 ] = 0 , d p [ 1 ] = 1 dp[0] = 0,dp[1] = 1 dp[0]=0,dp[1]=1 - 确定遍历顺序
因为想要求第 i 项的斐波那契数,必须知道第 i - 1 项和第 i - 2 项的数,所以遍历顺序从左到右。 - 举例推导dp数组
代码如下
class Solution {
public:
int fib(int n) {
if(n == 0) return 0;
vector<int> dp(n + 1); //定义dp数组,dp[i]表示第i项的斐波那契数
dp[0] = 0; //初始化
dp[1] = 1; //初始化
for(int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + dp[i - 2]; // 递推公式
}
return dp[n];
}
};
- 时间复杂度O(n);
- 空间复杂度O(n);
优化
可以看到要求每一个斐波那契数,只需要直到前两个斐波那契数,在往前的斐波那契数没有作用,所以我们不需要用一个dp数组去保存所有结果,只需要保存每次前两个斐波那契数。
class Solution {
public:
int fib(int n) {
if(n < 2) return n;
int a = 0, b = 1; // a 是 i-2 项, b 是 i - 1 项
int res = 0;
for(int i = 2; i <= n; i++) {
res = a + b; // 递推公式
a = b;
b = res;
}
return res;
}
};
- 时间复杂度O(n);
- 空间复杂度O(1);
代码随想录
补充一个递归做法
class Solution {
public:
int fib(int N) {
if (N < 2) return N;
return fib(N - 1) + fib(N - 2);
}
};
时间复杂度:O(2^n)
空间复杂度:O(n),算上了编程语言中实现递归的系统栈所占空间
70.爬楼梯
假设你正在爬楼梯。需要 n
阶你才能到达楼顶。
每次你可以爬 1
或 2
个台阶。你有多少种不同的方法可以爬到楼顶呢?
示例 1:
输入:n = 2
输出:2
解释:有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶
示例 2:
输入:n = 3
输出:3
解释:有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶
提示:
1 <= n <= 45
我的题解
- 确定dp数组以及下标定义
本题多少种不同的方法上到第n个台阶。第n个台阶可以由第n-1个台阶爬1
个台阶 和 第n-2个台阶爬2
个台阶到达,而第n-1个台阶可以由第n-2个台阶爬1
个台阶 和 第n-3个台阶爬2
个台阶到达.
由此推导,dp用来表示上第 i 个台梯 有dp[i] 种方法 - 递推公式
推导公式为 d p [ i ] = d p [ i − 1 ] + d p [ i − 2 ] dp[i] = dp[i - 1] + dp[i - 2] dp[i]=dp[i−1]+dp[i−2] - dp初始化
第一个台梯只有一种方法,第二个台梯有两种方法,爬两次1
,和爬一次2
dp初始化 d p [ 1 ] = 1 , d p [ 2 ] = 2 dp[1] = 1,dp[2] = 2 dp[1]=1,dp[2]=2 - 确定遍历顺序
因为想要求第 i 个的台阶方法数,必须知道第 i - 1 项和第 i - 2 项的数,所以遍历顺序从左到右。 - 举例推导dp数组
class Solution {
public:
int climbStairs(int n) {
if(n <= 2) return n;
vector<int> dp(n + 1); //定义dp,dp表示上第i阶阶梯有dp[i]种方法
dp[1] = 1; dp[2] = 2; // 初始化
for(int i = 3; i <= n; i++) {
dp[i] = dp[i - 1] + dp[i - 2]; //递推公式
}
return dp[n];
}
};
- 时间复杂度O(n);
- 空间复杂度O(n);
此题优化思路与上一题一样
代码随想录
这道题目还可以继续深化,就是一步一个台阶,两个台阶,三个台阶,直到 m个台阶,有多少种方法爬到n阶楼顶。
class Solution {
public:
int climbStairs(int n) {
vector<int> dp(n + 1, 0);
dp[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
// 把m换成2,就可以AC爬楼梯这道题
if (i - j >= 0) dp[i] += dp[i - j];
}
}
return dp[n];
}
};
代码中m表示最多可以爬m个台阶。
以上代码不能运行哈,我主要是为了体现只要把m换成2,粘过去,就可以AC爬楼梯这道题,不信你就粘一下试试。
746.使用最小花费爬楼梯
给你一个整数数组 cost
,其中 cost[i]
是从楼梯第 i
个台阶向上爬需要支付的费用。一旦你支付此费用,即可选择向上爬一个或者两个台阶。
你可以选择从下标为 0
或下标为 1
的台阶开始爬楼梯。
请你计算并返回达到楼梯顶部的最低花费。
示例 1:
输入:cost = [10,15,20]
输出:15
解释:你将从下标为 1 的台阶开始。
- 支付 15 ,向上爬两个台阶,到达楼梯顶部。
总花费为 15 。
示例 2:
输入:cost = [1,100,1,1,1,100,1,1,100,1]
输出:6
解释:你将从下标为 0 的台阶开始。
- 支付 1 ,向上爬两个台阶,到达下标为 2 的台阶。
- 支付 1 ,向上爬两个台阶,到达下标为 4 的台阶。
- 支付 1 ,向上爬两个台阶,到达下标为 6 的台阶。
- 支付 1 ,向上爬一个台阶,到达下标为 7 的台阶。
- 支付 1 ,向上爬两个台阶,到达下标为 9 的台阶。
- 支付 1 ,向上爬一个台阶,到达楼梯顶部。
总花费为 6 。
提示:
2 <= cost.length <= 1000
0 <= cost[i] <= 999
我的题解
-
确定dp数组以及下标定义
dp用来表示上第 i 个台梯 花费最少的费用 -
递推公式
第n个台阶可以由第n-1个台阶爬1
个台阶 和 第 n-2 个台阶爬2
个台阶到达,而dp表示上第 i 个台梯 花费最少的费用,所以dp[i] 存放 min(dp[i - 1] + dp[i - 2]) + cost[i]。推导公式为 d p [ i ] = m i n ( d p [ i − 1 ] + d p [ i − 2 ] ) + c o s t [ i ] dp[i] = min(dp[i - 1] + dp[i - 2]) + cost[i] dp[i]=min(dp[i−1]+dp[i−2])+cost[i]
-
dp初始化
可以选择从下标为0
或下标为1
的台阶开始爬楼梯。
dp初始化 d p [ 0 ] = c o s t [ 0 ] , d p [ 1 ] = c o s t [ 1 ] dp[0] = cost[0],dp[1] = cost[1] dp[0]=cost[0],dp[1]=cost[1] -
确定遍历顺序
因为想要求第 i 个的台阶最少花费费用,必须知道第 i - 1 项和第 i - 2 项的数,所以遍历顺序从左到右。 -
举例推导dp数组
class Solution {
public:
int minCostClimbingStairs(vector<int>& cost) {
vector<int> dp(cost.size() + 1); //爬到i台阶花费最少的钱
dp[0] = cost[0];
dp[1] = cost[1];
cost.push_back(0);
for(int i = 2; i < dp.size(); i++) {
dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];
}
return dp[cost.size() - 1];
}
};
- 时间复杂度:O(n);
- 空间复杂度:O(n);
代码随想录
-
确定dp数组以及下标的含义
dp[i]的定义:到达第i台阶所花费的最少体力为dp[i]。 -
确定递推公式
可以有两个途径得到dp[i],一个是dp[i-1] 一个是dp[i-2]。- dp[i - 1] 跳到 dp[i] 需要花费 dp[i - 1] + cost[i - 1]。
- dp[i - 2] 跳到 dp[i] 需要花费 dp[i - 2] + cost[i - 2].
那么究竟是选从dp[i - 1]跳还是从dp[i - 2]跳呢?
一定是选最小的,所以 d p [ i ] = m i n ( d p [ i − 1 ] + c o s t [ i − 1 ] , d p [ i − 2 ] + c o s t [ i − 2 ] ) ; dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]); dp[i]=min(dp[i−1]+cost[i−1],dp[i−2]+cost[i−2]); -
dp数组如何初始化
初始化 dp[0] = 0,dp[1] = 0; -
确定遍历顺序
因为是模拟台阶,而且dp[i]由dp[i-1]dp[i-2]推出,所以是从前到后遍历cost数组就可以了。 -
举例推导dp数组
class Solution {
public:
int minCostClimbingStairs(vector<int>& cost) {
vector<int> dp(cost.size() + 1);
dp[0] = 0; // 默认第一步都是不花费体力的
dp[1] = 0;
for (int i = 2; i <= cost.size(); i++) {
dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
}
return dp[cost.size()];
}
};