一、套路
复现代码随想录DP专题
动态规划五部曲
确定dp数组以及下标的含义
确定递推公式
dp数组如何初始化
确定遍历顺序
打印数组（与自己的推导比较，看哪里错了）
二、DP基础
1. 斐波那契数（LeetCode-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[i] 的意义为：第 i 个数的斐波那契数值为 dp[i]
d p [ i ] = d p [ i − 1 ] + d p [ i − 2 ]
dp[0]=0 dp[1]=1
根据递推公式可知，dp[i] 依赖它的前两个元素，所以一定是从前往后遍历
推导一下前十项 0 1 1 2 3 5 8 13 21 34 55
代码展示
class Solution { public: int fib(int n) { vector<int> dp(35); 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[i] 只依赖它的前两个元素，只需维护两个元素，没有必要写出整个数组，浪费了空间
class Solution { public: int fib(int n) { vector<int> dp(3); dp[0] = 0; dp[1] = 1; if (n < 2) { return dp[n]; } int result; for (int i = 2; i <= n; i++) { result = dp[0] + dp[1]; dp[0] = dp[1]; dp[1] = result; } return result; } };
2. 爬楼梯（LeetCode-70）
题目
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
**注意：**给定 n 是一个正整数。
示例 1：
输入： 2 输出： 2 解释： 有两种方法可以爬到楼顶。 1. 1 阶 + 1 阶 2. 2 阶
示例 2：
输入： 3 输出： 3 解释： 有三种方法可以爬到楼顶。 1. 1 阶 + 1 阶 + 1 阶 2. 1 阶 + 2 阶 3. 2 阶 + 1 阶
思路
第⼀层楼梯再跨两步就到第三层 ，第⼆层楼梯再跨⼀步就到第三层。 所以到第三层楼梯的状态可以由第⼆层楼梯和到第⼀层楼梯状态推导出来
五部曲
dp[i] 定义：爬到第 i 阶有 dp[i] 种方法
d p [ i ] = d p [ i − 2 ] + d p [ i − 1 ]
dp[1]=1 dp[2]=2 正整数不用考虑 dp[0]
肯定从前往后
前五项 1 2 3 5 8
代码展示
class Solution { public: int climbStairs(int n) { // 这步忘记了，导致n=1时访问不到dp[2] if (n<=1) { return n; } vector<int> dp(n + 1); dp[1] = 1, dp[2] = 2; for (int i = 3; i <= n; i++) { dp[i] = dp[i - 1] + dp[i - 2]; cout << dp[i]; } return dp[n]; } };
也是可以优化，滚动数组优化空间
class Solution { public: int climbStairs(int n) { if (n <= 2) { return n; } vector<int> dp(3); dp[1] = 1, dp[2] = 2; int result; for (int i = 3; i <= n; i++) { result = dp[1] + dp[2]; dp[1] = dp[2]; dp[2] = result; } return result; } };
3. 使用最小花费爬楼梯（LeetCode-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
思路
五部曲
1.定义： 爬到第 i 个台阶的最低花费为 dp[i]
2.当前台阶的最低花费与 i-1 和 i-2 台阶有关，应该是从（ i-1 台阶最低消费+从 i-1 台阶向上爬的费用）和（i-2 台阶最低消费+从 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[0]=0 dp[1]=0
显然从前往后
示例一应该是 dp[N]={0,0,10,15}
代码展示
class Solution { public: int minCostClimbingStairs(vector<int> &cost) { int N = cost.size() + 1; vector<int> dp(N); for (int i = 2; i < N; i++) { dp[i] = min((dp[i - 1] + cost[i - 1]), (dp[i - 2] + cost[i - 2])); } return dp[N-1]; } };
这题还是可以滚动数组优化
class Solution { public: int minCostClimbingStairs(vector<int> &cost) { int N = cost.size() + 1; vector<int> dp(2); int result; for (int i = 2; i < N; i++) { result = min((dp[1] + cost[i - 1]), (dp[0] + cost[i - 2])); dp[0] = dp[1]; dp[1] = result; } return result; } };
