【动态规划】C++解决斐波那契模型题目（三步问题、爬楼梯、解码方法...）

1. 前言 - 介绍动态规划算法

动态规划（Dynamic Programming，简称DP） 是一种解决复杂问题的算法设计技术，通常用于解决具有重叠子问题和最优子结构性质的问题。它将问题分解成较小的子问题，通过解决这些子问题并保存其结果，最终构建出原问题的解。

重叠子问题（Overlapping Subproblems）：问题可以被分解为相同的子问题，并且这些子问题在求解过程中会被多次重复计算。
最优子结构（Optimal Substructure）：问题的最优解可以由其子问题的最优解来构造。

1.5 例题

我们通过下面的例题对动态规划算法进行理解：

第N个泰波那契数

动态规划算法一般分为以下几个步骤：

定义状态表示：确定问题的状态，即 dp表中值所表示的含义。

如何找？
- 根据 题目要求 + 做题经验
  - 本题要求第n个泰波纳契的值，我们就令dp $i$ 为第i个泰波纳契的值

确定状态转移方程：即 求dp $i$ 的公式
- 根据题目所给的信息，我们知道dp $i$ = dp $i-1$ + dp $i-2$ + dp $i-3$ ;
初始化： 初始化边界状态，保证填表的时候不发生越界等问题。
- 由于我们需要用到i-1 到 i-3的下标，这里初始化前三个数
- dp $0$ = 0, dp $1$ = dp $2$ = 1;
填表的顺序： 根据状态转移方程，会有不同的填表顺序。
- 对于本题来说，只需要从左向右填表。
返回值： 根据题目要求与dp表的状态表示，写返回值。
- 题目要第n个泰波纳契值，而dp $i$ 表示第i个，所以返回dp $n$ ;

根据上面的思路可以直接创建一个dp表并进行初始化与填表，代码都在思路中，对于本题，可以直接进行空间优化。

由于每次只需要记录三个值，可以直接使用变量代替dp表，滚动数组的思想，每次统计值后向右移动：

代码

cpp 复制代码

int tribonacci(int n) {
    // 空间优化：变量代替数组
    // 处理边界问题
    if(n == 0)  return 0;
    else if(n == 1 || n == 2)   return 1;

    int a = 0, b = 1, c = 1, d = 0;

    for(int i = 3; i <= n; ++i) // 根据性质
    {
        d = a + b + c;
        a = b, b = c, c = d; // 数组向后滑动
    }

    return d;
}

动态规划算法的优点在于它可以避免重复计算，提高算法效率。然而，动态规划并不适用于所有问题，它要求问题具有重叠子问题和最优子结构性质，有时候贪心更适合解一定的题目。

2. 算法题

有了上面例题的经验，我们对动态规划有了一定的了解，下面进行正式的解题（斐波那契模型）：

2.1 三步问题

思路

解法：动态规划 + 设置dp数组
根据之前的经验，我们分步进行题目解析：

代码

根据上面的思路进行代码的编写：

cpp 复制代码

int waysToStep(int n) {
   vector<int> dp(n + 1);
    // 处理边界问题
    if(n == 1 || n == 2) return n;
    else if(n == 3) return 4;

    dp[1] = 1, dp[2] = 2, dp[3] = 4;
    const int MOD = 1e9 + 7;
    // 总结规律：
    // dp[i] = dp[i-1] + dp[i-2] + dp[i-3]
    for(int i = 4; i <= n; ++i)
    {
        dp[i] = ((dp[i-1] + dp[i-2]) % MOD + dp[i-3]) % MOD;
    }

    return dp[n];
}

2.2 使用最小花费爬楼梯

思路

代码

解法一：该解法为上图的思路代码

cpp 复制代码

int minCostClimbingStairs(vector<int>& cost) {
    int n = cost.size();
    // dp[i]: 到达第i阶楼梯 所花费的最小数目
    vector<int> dp(n + 1); // 默认为0
    for(int i = 2; i <= n; ++i)
    {
        dp[i] = min(dp[i-1], dp[i-2]) + cost[i];
    }
    
    return dp[n];
}

解法二：该解法的状态表示在代码注释中

cpp 复制代码

int minCostClimbingStairs(vector<int>& cost) {
    int n = cost.size();
    vector<int> dp(n); // 默认为0
    // dp[i]: 从第i阶开始到达楼顶的最小花费
    dp[n-1] = cost[n-1]; dp[n-2] = cost[n-2];
    for(int i = n - 3; i >= 0; --i)
    {
        dp[i] = cost[i] + min(dp[i+1], dp[i+2]);
    }

    return min(dp[0], dp[1]);
}

2.3 解码方法

思路

首先找到状态表示，列出状态转移方程

对于初始化，需要注意：

当正确开辟虚拟空间并初始化后，剩下就仅需填表即可（此时较为繁琐的初始化步骤就一并放到了填表操作）：

代码

cpp 复制代码

class Solution {
public:
    int numDecodings(string s) {

        // 优化：利用虚拟空间

        int n = s.size();
        vector<int> dp(n + 1); // 状态方程
        // 1. 初始化状态方程元素
        dp[0] = 1;
        dp[1] = s[1-1] != '0';
        
        // 2. 填表
        for(int i = 2; i <= n; ++i)
        {
            if(s[i - 1] != '0') dp[i] += dp[i-1];
            int tmp = (s[i-2] - '0') * 10 + (s[i - 1] - '0');
            if(tmp >= 10 && tmp <= 26) dp[i] += dp[i-2];
        }

        // 返回值
        return dp[n];
    }
};