代码随想录算法训练营第三十八天 | 理论基础、509. 斐波那契数、70. 爬楼梯、746. 使用最小花费爬楼梯

打卡第38天，开始动态规划了。

今日任务

• 理论基础
• 509.斐波那契数
• 70.爬楼梯
• 746.使用最小花费爬楼梯

[理论基础]

什么是动态规划

动态规划，英文：Dynamic Programming，简称DP。如果一个问题有很多重叠子问题，使用动态规划是最有效的。

动态规划中的每一个状态都是由上一状态推演出来的，区别于贪心，贪心是求局部最优，达到全局最优。

动态规划的解题步骤

动态规划五部曲

1. 确认dp数组以及下标的定义
2. 确定递推公式
3. dp数组如何初始化
4. 确定遍历顺序
5. 举例推导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

我的题解

1. 确定dp数组以及下标定义
   本题求斐波那契数列，还给出推导公式，dp是斐波那契数列，dp[i]表示第i项斐波那契数。
2. 递推公式
   题中已经给出$F(n)=F(n-1)+F(n-2)$，推导公式为$dp[i]=dp[i-1]+dp[i-2]$
3. dp初始化
   题目给出$F(0)=0，F(1)=1$
   dp初始化$dp[0]=0，dp[1]=1$
4. 确定遍历顺序
   因为想要求第 i 项的斐波那契数，必须知道第 i - 1 项和第 i - 2 项的数，所以遍历顺序从左到右。
5. 举例推导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

我的题解

1. 确定dp数组以及下标定义
   本题多少种不同的方法上到第n个台阶。第n个台阶可以由第n-1个台阶爬 1 个台阶 和 第n-2个台阶爬 2 个台阶到达，而第n-1个台阶可以由第n-2个台阶爬 1 个台阶 和 第n-3个台阶爬 2 个台阶到达.
   由此推导，dp用来表示上第 i 个台梯 有dp[i] 种方法
2. 递推公式
   推导公式为$dp[i]=dp[i-1]+dp[i-2]$
3. dp初始化
   第一个台梯只有一种方法，第二个台梯有两种方法，爬两次 1，和爬一次 2
   dp初始化 $dp[1]=1，dp[2]=2$
4. 确定遍历顺序
   因为想要求第 i 个的台阶方法数，必须知道第 i - 1 项和第 i - 2 项的数，所以遍历顺序从左到右。
5. 举例推导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

我的题解

1. 确定dp数组以及下标定义
   dp用来表示上第 i 个台梯 花费最少的费用

2. 递推公式
   第n个台阶可以由第n-1个台阶爬 1 个台阶 和 第 n-2 个台阶爬 2 个台阶到达，而dp表示上第 i 个台梯 花费最少的费用，所以dp[i] 存放 min(dp[i - 1] + dp[i - 2]) + cost[i]。

   推导公式为$dp[i]=min(dp[i-1]+dp[i-2])+cost[i]$

3. dp初始化
   可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。
   dp初始化 $dp[0]=cost[0]，dp[1]=cost[1]$

4. 确定遍历顺序
   因为想要求第 i 个的台阶最少花费费用，必须知道第 i - 1 项和第 i - 2 项的数，所以遍历顺序从左到右。

5. 举例推导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);

代码随想录

1. 确定dp数组以及下标的含义
   dp[i]的定义：到达第i台阶所花费的最少体力为dp[i]。

2. 确定递推公式
   可以有两个途径得到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]跳呢？
   一定是选最小的，所以$dp[i]=min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);$

3. dp数组如何初始化
   初始化 dp[0] = 0，dp[1] = 0;

4. 确定遍历顺序
   因为是模拟台阶，而且dp[i]由dp[i-1]dp[i-2]推出，所以是从前到后遍历cost数组就可以了。

5. 举例推导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()];
    }
};