算法学习记录～2023.5.21～动规Day1～509. 斐波那契数 & 70. 爬楼梯 & 746. 使用最小花费爬楼梯

基础知识

1. 什么是动态规划

动态规划，英文 Dynamic Programming，简称DP。

如果某一问题有很多重叠子问题，使用动态规划是最有效的。

和贪心算法的区别在于：
贪心没有状态推导，而是从局部直接选最优的；
动态规划中，每一个状态一定是由上一个状态推导出来的

2. 动态规划的解题步骤

如果只是死记硬背状态转移公式然后生搬硬套一定会出问题，因为并没有真的了解。

对于动态规划问题，可以拆解为五步曲，需要搞清楚每一步才行：

1. 确定 dp 数组（dp table）以及下标的含义
2. 确定递推公式
3. dp 数组如何初始化
4. 确定遍历顺序
5. 举例推导 dp 数组

这五步后面会经常用到，需要好好体会。

3. 动态规划的debug方法

做动态规划的题，代码出问题很正常，找问题的最好方式是把 dp 数组打印出来，看看到底是不是按照自己思路推导的。

如果对 dp 学习处于类似黑盒的状态，一气写下来如果能通过就ok不能通过就凭感觉改，是非常坏的习惯，而且很可能解决不了问题。

做 dp 的题目，写代码前一定要把状态转移在 dp 数组上的具体情况模拟一遍，确定最后推出的是想要的结果。

然后再写代码，如果代码没通过就打印 dp 数组，看看是不是和自己预先推导的哪里不一样。

如果打印出来和自己预先模拟推导的一样，那就是递归公式、初始化或者遍历顺序有问题。

如果和预先模拟推导的不一样，那就是代码实现细节有问题。

---

509. 斐波那契数

题目链接

力扣题目链接

思路1：动态规划

按五步曲来做：

1. 确定 dp 数组（dp table）以及下标的含义

这里我们要用一个一维 dp 数组来保存递归的结果。
dp[i] 的定义为：第 i 个数的斐波那契数值是 dp[i]

2. 确定递推公式

本题题目中已经给出了递推公式，状态转移方程 dp[i] = dp[i - 1] + dp[i - 2]

3. dp 数组如何初始化

题目中也给了初始化，dp[0] = 0; dp[1] = 1;

4. 确定遍历顺序

从递推公式中可以看出，dp[i] 依赖于 dp[i - 1] 和 dp[i - 2] ，所以遍历的顺序一定是从前向后的

5. 举例推导 dp 数组

按照这个递推公式dp[i] = dp[i - 1] + dp[i - 2]，我们来推导一下，当N为10的时候，dp数组应该是如下的数列：
0 1 1 2 3 5 8 13 21 34 55
如果代码写出来，发现结果不对，就把dp数组打印出来看看和我们推导的数列是不是一致的。

代码

class Solution {
public:
    int fib(int n) {
        if (n <= 1) return n;
        vector<int> dp(n + 1);
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; i++){
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
};

思路2：递归

正常递归思路，没有太特殊的

代码

class Solution {
public:
    int fib(int n) {
        if (n < 2)
            return n;
        return fib(n - 1) + fib(n - 2);
    }
};

总结

简单题用来掌握方法论，困难题应用方法论。

---

70. 爬楼梯

题目链接

力扣题目链接

思路：动态规划

由于每次只能爬 1 或 2 个台阶，所以爬第 1 层有 1 种，爬第 2 层有 2 种，爬第 3 层则可以从第 1 层再爬 2 层，或第 2 层再爬 1 层。因此可以发现第 3 层楼梯状态可以由第 1 和第 2 层楼梯状态推导而来，因此想到动态规划

动规五步曲：

1. 确定 dp 数组以及下标的含义：

dp[i]：爬到第 i 层楼，有 dp[i] 种方法

2. 确定递推公式：

从dp[i]的定义可以看出，dp[i] 可以有两个方向推出来。

首先是 dp[i - 1]，上 i - 1 层楼梯，有dp[i - 1]种方法，那么再 1 步跳1个台阶就是 dp[i]。
还有就是 dp[i - 2]，上 i - 2 层楼梯，有dp[i - 2]种方法，那么再 1 步跳 2 个台阶就是 dp[i]。

（需要注意 dp[i - 2] 到 i - 2 层楼梯后，除了 1 步跳 2 个台阶到达 dp[i] 以外，不要考虑跳 2 次每次 1 步到达 dp[i]，因为那样其实就和 dp[i - 1] 跳 1 步上 dp[i] 重复了。）

所以dp[i] = dp[i - 1] + dp[i - 2] 。

在推导dp[i]的时候，一定要时刻想着dp[i]的定义，否则容易跑偏。
这也体现出确定dp数组以及下标的含义的重要性！

3. dp 数组如何初始化：

根据前面的定义和举例，可以知道 dp[1] = 1，dp[2] = 2

4. 确定遍历顺序：

从递推公式dp[i] = dp[i - 1] + dp[i - 2] 中可以看出，遍历顺序一定是从前向后遍历的

5. 举例推导 dp 数组：

比如 n 为 5 时，dp 数组应该如下所示。

如果代码出问题了，就把dp table 打印出来，看看究竟是不是和自己推导的一样

代码

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 1)         //因为下面直接对dp[2]操作了，防止空指针
            return n;
        vector<int> dp(n + 1);      //注意 + 1
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++){
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
};

总结

题目还是不难，因此重点还是在于更熟悉动态规划的思维和步骤。

---

746. 使用最小花费爬楼梯

题目链接

力扣题目链接

思路

思路上和 70. 爬楼梯 很相似，主要区别在于判断爬楼方式的时候还需要记录一下体力花费。

动规五步曲：

1. 确定 dp 数组（dp table）以及下标的含义

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] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])

3. dp 数组如何初始化

初始可以从第 0 或第 1 层出发，因此到这两层花费的体力都为 0
所以初始化 dp[0] = 0，dp[1] = 0

4. 确定遍历顺序

根据递推公式模拟台阶，确定为从前往后

5. 举例推导 dp 数组

拿示例2：cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1] ，来模拟一下dp数组的状态变化，如下：

如果代码写出来有问题，就把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 ++){        //注意边界范围不能是 cost.size() - 1
            dp[i] = min((dp[i - 1] + cost[i - 1]), (dp[i - 2] + cost[i - 2]));
        }
        return dp[cost.size()];         //注意不能是 cost.size() - 1
    }
};

总结

简单题，为了练习方法论，然后难度按梯度向上，一环扣一环。