＜动态规划＞斐波那契数列模型

无聊看看天T^T

已于 2024-05-29 16:35:56 修改

阅读量112

点赞数 1

分类专栏：优选算法专栏文章标签： c++ c语言 qt

于 2024-04-21 00:28:22 首次发布

本文链接：https://blog.csdn.net/m0_73975164/article/details/138016303

版权

优选算法专栏专栏收录该内容

2 篇文章 0 订阅

订阅专栏

本文详细介绍了动态规划在四个经典问题中的应用，包括计算第N个泰波那契数、解决三步问题、最小花费爬楼梯和解码方法的解码方案总数。通过状态表示、状态转移方程、初始化、填表顺序和返回值的讨论，展示了如何设计和优化算法以求解这些问题。

摘要由CSDN通过智能技术生成

前言

处理动态规划内容需要考虑五个方面：

状态表示：即dp表内某位置的值所表示的含义（dp表是一个一或二维数组，填满dp表后，表中的某一个位置的值可能就是我们要的结果）
状态转移方程：即想好dp[i]等于什么，用之前或之后的状态推导出dp[i]的值
初始化：即保证填表时不会越界
填表顺序：即当前调表时所需要的状态已经计算过了
返回值：即返回dp[n]

1、第N个泰波那契数

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

状态表示：dp[i]表示第i个泰波那契数是多少
状态转移方程：dp[i] = dp[i-1] + dp[i-2] + dp[i-3]
初始化：dp[0] = 0 dp[1] = dp[2] = 0
填表顺序：从左向右
返回值：dp[n]

class Solution {
public:
    int tribonacci(int n) {

    if(n == 0) return 0;//边界处理
    if(n == 1 || n == 2) return 1;//边界处理

     vector<int> dp(n+1);//开辟dp表

     dp[0] = 0,dp[1] = dp[2] = 1;//初始化的dp表

     for(int i = 3;i<=n;i++)
        dp[i] = dp[i-1]+dp[i-2]+dp[i-3];//状态转移方程

    return dp[n];//题目要求返回第n个数
    }
};

时间复杂度：O（n）
空间复杂度：O（n）

空间优化：滚动数组（没使用一次滚动数组都会使空间复杂度下降一个大的层次，O（n^2）-> O（n）、O（n）->O（1））

class Solution {
public:
    int tribonacci(int n) {
    //1、创建并填满dp表
    //2、初始化
    //3、填表
    //4、返回值
    //处理边界情况
    if(n == 0) return 0;
    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、三步问题

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

状态表示：dp[ i ]表示到达i位置时，一共有多少种方法
状态转移方程：dp[i] = dp[i-1] + dp[i-2] + dp[i-3]

初始化：dp[1] = 1、dp[2] = 2、dp[3] = 4（i=1时dp[i-3] = dp [-2]错误）
填表顺序：从左向右
返回值：dp[n]

class Solution {
public:
    int waysToStep(int n) {

        const int MOD = 1e9 + 7;//1 * 10^9 + 7，MOD常表示要取模的数

        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];
    }
};

时间复杂度：O（n）
空间复杂度：O（n）

3、最小花费爬楼梯

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

状态表示：dp[i]表示达到i位置的最小花费
状态转移方程：dp[i] = min(dp[i-1] + cost[i-1],dp[i-2] + const[i-2])

初始化：dp[0] = dp[1] = 0（防止越界）
填表顺序：从左向右
返回值：dp[n]

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
    
    int n = cost.size();
    vector<int> dp(n+1);
    dp[0] = dp[1] = 0;

    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];
    }
};

时间复杂度：O（n）
空间复杂度：O（n）

4、解码方法

题目地址：91. 解码方法 - 力扣（LeetCode）

状态表示：dp[i]表示到i位置时，解码方法的总数
状态转移方程：dp[i] = dp[i-1] + dp[i-2]

初始化：dp[0] = 1 / 0、dp[1] = 0 / 1 / 2

填表顺序：从左向右
返回值：dp[n-1]

class Solution {
public:
    int numDecodings(string s) {
        int n = s.size();

        vector<int> dp(n);

        //初始化dp[0]
        dp[0] = s[0] != '0';//如果s[0]属于[1,9],则dp[0]编码成功,dp[0] = 1

        if(n == 1)//如果s只有一个字符可以解码，则直接返回dp[0]
        {
            return dp[0];
        }
      
        //初始化dp[1]
        if(s[0] != '0' && s[1] != '0')//如果s[0]和s[1]位置上的字符都属于[1,9],则dp[1]之前单独解码成功++dp[1]
        {
            dp[1] += 1;
        }

        int t = (s[0]-'0') * 10 + (s[1] -'0');
        
        if(t >= 10 && t<= 26)//s[0]和s[1]位置上的字符组合后的范围属于[10,26],则dp[1]之前组合解码成功++dp[1]
        {
            dp[1] += 1;
        }

        //填表
        for(int i = 2;i < n;i++)
        {
            if(s[i] != '0')//s[i]位置上的字符属于[1,9],则dp[i]位置上的字符单独解码成功，此时到dp[i]位置的解码方案总数等于到dp[i-1]时的解码方案总数
            {
                dp[i] += dp[i - 1];
            }
            
            int t = (s[i-1]-'0') * 10 + (s[i] -'0');

            if(t >= 10 && t<= 26)//s[i-1]和s[i]位置上的字符组合后属于[10,26],则dp[i]位置上的字符单独解码成功，此时到dp[i]位置的解码方案总数等于到dp[i-2]时的解码方案总数
            {
                dp[i] += dp[i-2];
            }
        }

        return dp[n - 1];//s中有n个字符，但是dp表中存放到第n个字符时的解码方案总数为dp[n-1]
    }
};