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
思路
五部曲
第一步：确定dp数组和下标的含义
我们可以定义一个数组dp，其中dp[i]表示斐波那契数列中的第i个数字，即 ( F(i) )。
第二步：确定递推公式
根据斐波那契数列的定义，递推公式为：
第三步：dp数组如何初始化
- ( dp[0] = 0 )
- ( dp[1] = 1 )
第四步：确定遍历顺序
由递推公式可知，( dp[i] )是基于( dp[i - 1] )和( dp[i - 2] )的，所以我们从小到大遍历数组。
第五步：举例推导dp数组
- ( dp[0] = 0 )
- ( dp[1] = 1 )
- ( dp[2] = dp[1] + dp[0] = 1 )
- ( dp[3] = dp[2] + dp[1] = 2 )
- ( dp[4] = dp[3] + dp[2] = 3 )
- ( ... )
题解
class Solution {
public:
int fib(int n) {
if (n == 0) return 0;
if (n == 1) return 1;//这两步很重要，不然会堆缓冲区溢出
vector<int> dp(n + 1, 0);
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; ++i) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}
};
思路
第一步：确定dp数组和下标的含义
我们定义一个数组dp，其中dp[i]表示到达第i级台阶的不同方式数量。
第二步：确定递推公式
到达第i级台阶可以从第i-1级台阶爬一个台阶上来，也可以从第i-2级台阶爬两个台阶上来。因此，递推公式为：
第三步：dp数组如何初始化
- ( dp[0] = 1 )（没有台阶，只有一种方式，即不爬）
- ( dp[1] = 1 )（1级台阶有一种方式，即爬一步）
第四步：确定遍历顺序
由递推公式可知，( dp[i] )是基于( dp[i - 1] )和( dp[i - 2] )的，所以我们从小到大遍历数组。
第五步：举例推导dp数组
- ( dp[0] = 1 )
- ( dp[1] = 1 )
- ( dp[2] = dp[1] + dp[0] = 2 )
- ( dp[3] = dp[2] + dp[1] = 3 )
- ( dp[4] = dp[3] + dp[2] = 5 )
- ( ... )
题解
class Solution {
public:
int climbStairs(int n) {
// 如果n等于1，直接返回1，因为只有1种方式爬到楼顶。
if(n == 1) {
return 1;
}
// 定义一个动态数组dp，长度为n+1，并将所有元素初始化为1。
// dp[i]表示到达第i级台阶的不同方式数量。
vector<int> dp(n + 1, 1);
// 到达第2级台阶有2种方式：1 + 1 或 2。
dp[2] = 2;
// 从第3级台阶开始，遍历到第n级台阶。
for(int i = 3; i < n + 1; ++i) {
// 使用递推公式计算dp[i]。
// 到达第i级台阶的方式等于到达第i-1级台阶的方式和第i-2级台阶的方式之和。
dp[i] = dp[i - 1] + dp[i - 2];
}
// 返回到达第n级台阶的不同方式数量。
return dp[n];
}
};
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，其中 ( dp[i] ) 表示到达第 (i) 台阶的最低成本。
第二步：确定递推公式
到达第 (i) 台阶的最低成本可以有两种方式：
- 从第 (i-1) 台阶一步到达，成本为 ( dp[i-1] + cost[i-1] )
- 从第 (i-2) 台阶两步到达，成本为 ( dp[i-2] + cost[i-2] )
因此，递推公式为：
第三步：dp数组如何初始化
由于你可以选择从下标为 0 或 1 的台阶开始爬楼梯，因此初始成本都是 0。
- ( dp[0] = 0 )
- ( dp[1] = 0 )
第四步：确定遍历顺序
由于 ( dp[i] ) 是基于 ( dp[i-1] ) 和 ( dp[i-2] ) 计算的，所以我们需要从小到大遍历数组。
第五步：举例推导dp数组
假设 cost = [10, 15, 20]：
- ( dp[0] = 0 )
- ( dp[1] = 0 )
- ( dp[2] = min(0 + 10, 0 + 15) = 10 )
- ( dp[3] = min(0 + 15, 10 + 20) = 15 )
题解
class Solution {
public:
int minCostClimbingStairs(std::vector<int>& cost) {
// 获取楼梯的总台阶数
int n = cost.size();
// 初始化动态规划数组dp，长度为n+1，所有元素初始化为0。
// dp[i]表示到达第i个台阶的最低成本。
std::vector<int> dp(n + 1, 0);
// 从第2个台阶开始遍历，因为dp[0]和dp[1]都是0（从第0或第1个台阶开始都不需要成本）
for(int i = 2; i <= n; ++i) {
// 使用递推公式来更新dp[i]。
// 到达第i个台阶的最低成本是从第i-1个或第i-2个台阶来的。
dp[i] = std::min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
}
// 返回dp[n]，即到达楼梯顶部的最低成本。
return dp[n];
}
};
