专题一：斐波那契数列模型算法_将 fibonacci() 函数模板化,使其输出值的类型与它对应的值一致(这样它就可以输出-CSDN博客

本文链接：https://blog.csdn.net/AAlykk/article/details/144342232

> 作者：დ旧言~
> 座右铭：松树千年终是朽，槿花一日自为荣。

> 目标：了解什么是记忆化搜索，并且掌握记忆化搜索算法。

> 毒鸡汤：有些事情，总是不明白，所以我不会坚持。早安!

> 专栏选自：动态规划算法_დ旧言~的博客-CSDN博客

> 望小伙伴们点赞👍收藏✨加关注哟💕💕

一、算法讲解

动态规划（Dynamic Programming）算法的核心思想是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法：

动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。
与分治法不同的是，适合于用动态规划求解的问题，经分解得到的子问题往往不是互相独立的（即下一个子阶段的求解是建立在上一个子阶段的解的基础上）。

【Tips】动态规划算法解决问题的分类

计数：有多少种方式走到右下角 / 有多少种方法选出k个数使得和是 sum。
求最大值/最小值：从左上角走到右下角路径的最大数字和最长上升子序列长度。
求存在性：取石子游戏，先手是否必胜 / 能不能取出 k 个数字使得和是 sum。

【Tips】动态规划dp算法一般步骤

确定状态表示（dp[ i ] 的含义是什么，来源：1、题目要求；2、经验+题目要求；3、分析问题时发现重复子问题）
状态转移方程（可求得 dp[ i ] 的数学公式，来源：题目要求+状态表示）
初始化（dp 表中特别的初始值，保证填 dp 表时不会越界，来源：题目要求+状态表示）
填表顺序（根据状态转移方程修改 dp[ i ] 的方式，来源：题目要求+状态表示）
返回值（题目求解的结果，来源：题目要求+状态表示）

二、算法习题

2.1 第一题

题目链接：1137. 第 N 个泰波那契数 - 力扣（LeetCode）

题目描述：

算法流程：

1. 状态表⽰：

这道题可以「根据题⽬的要求」直接定义出状态表⽰：
dp[i] 表⽰：第 i 个泰波那契数的值。

2. 状态转移⽅程：

题⽬已经⾮常贴⼼的告诉我们了：
dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3]

3. 初始化：

从我们的递推公式可以看出， dp[i] 在 i = 0 以及 i = 1 的时候是没有办法进⾏推导的，因为 dp[-2] 或 dp[-1] 不是⼀个有效的数据。
因此我们需要在填表之前，将 0, 1, 2 位置的值初始化。题⽬中已经告诉我们 dp[0] = 0,dp[1] = dp[2] = 1 。

4. 填表顺序：

毫⽆疑问是「从左往右」。

5. 返回值：

应该返回 dp[n] 的值。

代码呈现：

class Solution {
public:
    int tribonacci(int n) 
    {
        if (n == 0 || n == 1)
            return n;
        vector<int> dp(n + 1);           // dp[i] 表⽰：第 i 个泰波那契数的值。
        dp[0] = 0, dp[1] = 1, dp[2] = 1; // 初始化
        // 从左往右填表
        for (int i = 3; i <= n; i++)
            dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];
        // 返回结果
        return dp[n];
    }
};

2.2 第二题

题目链接：面试题 08.01. 三步问题 - 力扣（LeetCode）

题目描述：

算法思路：

1. 状态表⽰

这道题可以根据「经验 + 题⽬要求」直接定义出状态表⽰：
dp[i] 表⽰：到达 i 位置时，⼀共有多少种⽅法。

2. 状态转移⽅程

以 i 位置状态的最近的⼀步，来分情况讨论：
如果 dp[i] 表⽰⼩孩上第 i 阶楼梯的所有⽅式，那么它应该等于所有上⼀步的⽅式之和：

上⼀步上⼀级台阶， dp[i] += dp[i - 1] ；
上⼀步上两级台阶， dp[i] += dp[i - 2] ；
上⼀步上三级台阶， dp[i] += dp[i - 3] ；

综上所述， dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3] 。
需要注意的是，这道题⽬说，由于结果可能很⼤，需要对结果取模。
在计算的时候，三个值全部加起来再取模，即 (dp[i - 1] + dp[i - 2] + dp[i - 3]) % MOD 是不可取的，同学们可以试验⼀下， n 取题⽬范围内最⼤值时，⽹站会报错 signed integer overflow 。
对于这类需要取模的问题，我们每计算⼀次（两个数相加/乘等），都需要取⼀次模。否则，万⼀
发⽣了溢出，我们的答案就错了。

3. 初始化

从我们的递推公式可以看出， dp[i] 在 i = 0, i = 1 以及 i = 2 的时候是没有办法进⾏
推导的，因为 dp[-3] dp[-2] 或 dp[-1] 不是⼀个有效的数据。
因此我们需要在填表之前，将 1, 2, 3 位置的值初始化。
根据题意， dp[1] = 1, dp[2] = 2, dp[3] = 4 。

4. 填表顺序

毫⽆疑问是「从左往右」。

5. 返回值

应该返回 dp[n] 的值。

代码呈现：

class Solution {
public:
    const int MOD = 1e9 + 7;
    int waysToStep(int n) 
    {
        // 1. 创建 dp 表
        // 2. 初始化
        // 3. 填表
        // 4. 返回
        // 处理边界情况
        if (n == 1 || n == 2)
            return n;
        if (n == 3)
            return 4;
        vector<int> dp(n + 1);
        dp[1] = 1, dp[2] = 2, dp[3] = 4;
        for (int i = 4; i <= n; i++)
            dp[i] = ((dp[i - 1] + dp[i - 2]) % MOD + dp[i - 3]) % MOD;
        return dp[n];
    }
};

2.3 第三题

题目描述：746. 使用最小花费爬楼梯 - 力扣（LeetCode）

题目描述：

注意注意：

在这道题中，数组内的每⼀个下标 [0, n - 1] 表⽰的都是楼层，⽽顶楼的位置其实是在 n 的位置！！！

算法思路：

1. 状态表⽰：

这道题可以根据「经验 + 题⽬要求」直接定义出状态表⽰：
第⼀种：以 i 位置为结尾，巴拉巴拉
dp[i] 表⽰：到达 i 位置时的最⼩花费。（注意：到达 i 位置的时候， i 位置的钱不需要算上）

2. 状态转移⽅程：

根据最近的⼀步，分情况讨论：
▪ 先到达 i - 1 的位置，然后⽀付 cost[i - 1] ，接下来⾛⼀步⾛到 i 位置： dp[i - 1] + csot[i - 1] ；
▪ 先到达 i - 2 的位置，然后⽀付 cost[i - 2] ，接下来⾛⼀步⾛到 i 位置： dp[i - 2] + csot[i - 2] 。

3. 初始化：

从我们的递推公式可以看出，我们需要先初始化 i = 0 ，以及 i = 1 位置的值。容易得到 dp[0] = dp[1] = 0 ，因为不需要任何花费，就可以直接站在第 0 层和第 1 层上。

4. 填表顺序：

根据「状态转移⽅程」可得，遍历的顺序是「从左往右」。

5. 返回值：

根据「状态表⽰以及题⽬要求」，需要返回 dp[n] 位置的值。

代码呈现：

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) 
    {
        int n = cost.size();
        // 初始化⼀个 dp表
        vector<int> dp(n + 1, 0);
        // 初始化
        dp[0] = dp[1] = 0;
        // 填表
        for (int i = 2; i < n + 1; i++)
            // 根据状态转移⽅程得
            dp[i] = min(cost[i - 1] + dp[i - 1], cost[i - 2] + dp[i - 2]);
        // 返回结果
        return dp[n];
    }
};

2.4 第四题

题目描述：91. 解码方法 - 力扣（LeetCode）

题目描述：

算法思路：

1. 状态表⽰：

根据以往的经验，对于⼤多数线性 dp ，我们经验上都是「以某个位置结束或者开始」做⽂章，这
⾥我们继续尝试「⽤ i 位置为结尾」结合「题⽬要求」来定义状态表⽰。dp[i] 表⽰：字符串中 [0，i] 区间上，⼀共有多少种编码⽅法。

2. 状态转移⽅程：

定义好状态表⽰，我们就可以分析 i 位置的 dp 值，如何由「前⾯」或者「后⾯」的信息推导出
来。关于 i 位置的编码状况，我们可以分为下⾯两种情况：

让 i 位置上的数单独解码成⼀个字⺟；
让 i 位置上的数与 i - 1 位置上的数结合，解码成⼀个字⺟。

下⾯我们就上⾯的两种解码情况，继续分析：

◦ 让 i 位置上的数单独解码成⼀个字⺟，就存在「解码成功」和「解码失败」两种情况：

解码成功：当 i 位置上的数在 [1, 9] 之间的时候，说明 i 位置上的数是可以单独解码的，那么此时 [0, i] 区间上的解码⽅法应该等于 [0, i - 1] 区间上的解码⽅法。因为 [0, i - 1] 区间上的所有解码结果，后⾯填上⼀个 i 位置解码后的字⺟就可以了。此时 dp[i] = dp[i - 1] ；
解码失败：当 i 位置上的数是 0 的时候，说明 i 位置上的数是不能单独解码的，那么此时 [0, i] 区间上不存在解码⽅法。因为 i 位置如果单独参与解码，但是解码失败了，那么前⾯做的努⼒就全部⽩费了。此时 dp[i] = 0 。

◦ 让 i 位置上的数与 i - 1 位置上的数结合在⼀起，解码成⼀个字⺟，也存在「解码成功」和「解码失败」两种情况：

解码成功：当结合的数在 [10, 26] 之间的时候，说明 [i - 1, i] 两个位置是可以解码成功的，那么此时 [0, i] 区间上的解码⽅法应该等于 [0, i - 2 ] 区间上的解码⽅法，原因同上。此时 dp[i] = dp[i - 2] ；
解码失败：当结合的数在 [0, 9] 和 [27 , 99] 之间的时候，说明两个位置结合后解码失败（这⾥⼀定要注意 00 01 02 03 04 ...... 这⼏种情况），那么此时 [0, i] 区间上的解码⽅法就不存在了，原因依旧同上。此时 dp[i] = 0 。

综上所述： dp[i] 最终的结果应该是上⾯四种情况下，解码成功的两种的累加和（因为我们关⼼
的是解码⽅法，既然解码失败，就不⽤加⼊到最终结果中去），因此可以得到状态转移⽅程（ dp[i] 默认初始化为 0 ）：

当 s[i] 上的数在 [1, 9] 区间上时： dp[i] += dp[i - 1] ；
当 s[i - 1] 与 s[i] 上的数结合后，在 [10, 26] 之间的时候： dp[i] +=dp[i - 2] ；

如果上述两个判断都不成⽴，说明没有解码⽅法， dp[i] 就是默认值 0 。

3. 初始化：

⽅法⼀（直接初始化）：
由于可能要⽤到 i - 1 以及 i - 2 位置上的 dp 值，因此要先初始化「前两个位置」。

初始化 dp[0] ：

当 s[0] == '0' 时，没有编码⽅法，结果 dp[0] = 0 ；
当 s[0] != '0' 时，能编码成功， dp[0] = 1

初始化 dp[1] ：

当 s[1] 在 [1，9] 之间时，能单独编码，此时 dp[1] += dp[0] （原因同上，dp[1] 默认为 0 ）
当 s[0] 与 s[1] 结合后的数在 [10, 26] 之间时，说明在前两个字符中，⼜有⼀种编码⽅式，此时 dp[1] += 1

⽅法⼆（添加辅助位置初始化）：
可以在最前⾯加上⼀个辅助结点，帮助我们初始化。使⽤这种技巧要注意两个点：

辅助结点⾥⾯的值要保证后续填表是正确的；
下标的映射关系

4. 填表顺序：

毫⽆疑问是「从左往右」

5. 返回值：

应该返回 dp[n - 1] 的值，表⽰在 [0, n - 1] 区间上的编码⽅法。

代码呈现：


// 方法一：
// class Solution {
// public:
//     int numDecodings(string s)
//     {
//         int n = s.size();
//         vector<int> dp(n); // 创建⼀个 dp表
//         // 初始化前两个位置
//         dp[0] = s[0] != '0';
//         if (n == 1)
//             return dp[0]; // 处理边界情况
//         if (s[1] <= '9' && s[1] >= '1')
//             dp[1] += dp[0];
//         int t = (s[0] - '0') * 10 + s[1] - '0';
//         if (t >= 10 && t <= 26)
//             dp[1] += 1;
//         // 填表
//         for (int i = 2; i < n; i++)
//         {
//             // 如果单独编码
//             if (s[i] <= '9' && s[i] >= '1')
//                 dp[i] += dp[i - 1];
//             // 如果和前⾯的⼀个数联合起来编码
//             int t = (s[i - 1] - '0') * 10 + s[i] - '0';
//             if (t >= 10 && t <= 26)
//                 dp[i] += dp[i - 2];
//         }
//         // 返回结果
//         return dp[n - 1];
//     }
// };

// 方法二：
class Solution {
public:
    int numDecodings(string s) 
    {
        // 优化
        int n = s.size();
        vector<int> dp(n + 1);
        dp[0] = 1; // 保证后续填表是正确的
        dp[1] = s[0] != '0';
        // 填表
        for (int i = 2; i <= n; i++) 
        {
            // 处理单独编码
            if (s[i - 1] != '0')
                dp[i] += dp[i - 1];
            // 如果和前⾯的⼀个数联合起来编码
            int t = (s[i - 2] - '0') * 10 + s[i - 1] - '0';
            if (t >= 10 && t <= 26)
                dp[i] += dp[i - 2];
        }
        return dp[n];
    }
};