动态规划专题一斐波那契数问题-CSDN博客

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        //创建dp表（我们要返回n位置，多创建一个位置）
        int n = cost.size();
        vector<int> dp(n+1);

        //初始化（走到0和走到1，是不需要花费的）
        dp[0] = 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];

    }
};

题二第N个泰波那锲数

1137. 第 N 个泰波那契数 - 力扣（LeetCode）

1、算法解析

你自己根据我第一题的过程，自己照着求解一般，然后写出代码。

1、确定状态

确定状态是在干什么？
就是确定状态dp数组中的值代表什么含义
dp表里某个位置值的状态就是题目的解

2、状态转移方程

dp[i] = dp[i-1] + dp[i-2] + ap[i-3];题目都直接给了

3、初始化

保证填表的时候越界
根据状态表示方程进行填表
状态方程是dp[i] = dp[i-1] + dp[i-2] + ap[i-3];
因此当i小于3的时候，越界
因此，初始化状态表，dp[0] = 0;dp[1] = ap[2] = 1;

4、填表顺序

从左往右填表，因为第n个位置的值，需要前面三个值已经计算好。

5、返回值

结果是第n个位置的值
所以，返回值就是dp[n]（因此需要多创建一个位置的空间）

2、代码

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

        if(n == 0) return 0;
        if(n == 1|| n == 2) return 1;

        //1、创建dp表
        vector<int> dp(n + 1);

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

        //3、填表
        for(int i = 3; i<=n; i++ )
            dp[i] = dp[i-1] + dp[i-2] + dp[i-3];
        
        //4、确定返回值
            return dp[n];        


    }
};

3、空间优化版本

//空间优化版本
class Solution {
public:
    int tribonacci(int n) {

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

题三三步问题

面试题 08.01. 三步问题 - 力扣（LeetCode）

1、算法解析

1、确定状态：

定义 dp[i] 数组中的值到底表示什么意思？
很简单，根据题目，就是到达该台阶一共有多少种走法。
我们的目标是求解 dp[n]，即上到第 n 阶台阶的方式数量。

2、状态转移方程：

考虑小孩每次可以走 1 阶、2 阶或 3 阶：

因此，状态转移方程为：
dp[i] = dp[i-1] + dp[i-2] + dp[i-3]

3、初始化：

dp[0] = 1：上到第 0 阶只有一种方式，就是不走任何台阶。
dp[1] = 1：上到第 1 阶只有一种方式，就是从地面直接走一阶。
dp[2] = 2：上到第 2 阶有两种方式，可以走两次一阶或者一次两阶。
为什么初始化这三个位置？因为他们需要前面三个位置的值，如果不初始化，会越界。

4、填表顺序：

从 dp[3] 开始一直填充到 dp[n]。

5、返回值：

返回 dp[n]，因此要多创建一个位置的空间，同时由于结果可能很大，要对 dp[n] 模 1000000007 取余。

2、代码

class Solution {
public:
    int waysToStep(int n) {
        if(n == 1) return 1;
        if(n == 2) return 2;

        // 1、创建dp表
        vector<int> dp(n + 1);
        
        // 2、初始化
        dp[0] = 1;
        dp[1] = 1;
        dp[2] = 2;

        // 3、填表
        for(int i = 3; i<n+1; ++i)
            dp[i] = ((dp[i-1] + dp[i-2]) % 1000000007 + dp[i-3]) % 1000000007;

        // 4、确定返回值
        return dp[n];
        
    }
};

题四解码方法

91. 解码方法 - 力扣（LeetCode）

1、算法解析

1、确定状态：

定义 dp[i] 数组中的值到底表示什么意思：dp[i]的值，就是以i为结尾的编码串的最多解码方式

2、状态转移方程：

因此，状态转移方程为：
dp[i] = dp[i-1] + dp[i-2]

3、初始化：

为什么初始化这几个位置？因为他们需要前面三个位置的值，如果不初始化，会越界。

4、填表顺序：

从 dp[3] 开始一直填充到 dp[n]。

5、返回值：

返回 dp[n]

2、代码

class Solution {
public:
    int numDecodings(string s) {
    //1、创建dp表
    int n = s.size();
    vector<int> dp(n);

    //只有一位
    dp[0] = s[0] == '0' ? 0 : 1;
    if(n == 1 ) return dp[0];

    //2、初始化
    //根据判断条件进行初始化
    if(s[0] != '0' && s[1] != '0') dp[1]++;
    int m = (s[0] - '0')*10 + (s[1] - '0');//组合编码
    if(m>=10 && m <= 26)
        dp[1] ++;

    //3、填表
    for(int i = 2; i<n; ++i)
    {
        //i位置单独编码
        if( s[i] != '0') dp[i] += dp[i-1];
        //i和i-1位置组合编码
        int x = (s[i-1] - '0')*10 + (s[i] - '0');
        if(x >= 10 && x <= 26) dp[i] += dp[i-2];
    }

    //4、返回值
    return dp[n-1];

    }
};