【算法】动态规划---斐波那契数列模型

时光不染。回忆不淡

已于 2024-07-30 20:33:56 修改

阅读量596

点赞数 22

分类专栏：算法题文章标签：算法动态规划

于 2024-07-30 20:28:11 首次发布

本文链接：https://blog.csdn.net/m0_74105656/article/details/140804731

版权

算法题专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一.第 N 个泰波那契数

题目链接: 1137. 第N个泰波那契数
题目描述:
泰波那契序列 Tn 定义如下：
T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2
给你整数 n，请返回第 n 个泰波那契数 Tn 的值。

示例 1：
输入：n = 4
输出：4
解释：
T_3 = 0 + 1 + 1 = 2
T_4 = 1 + 1 + 2 = 4

示例 2：
输入：n = 25
输出：1389537

解法:(动态规划)
1. 状态表示:
  这道题可以直接根据题意, 来定义状态表示 : dp[i] 表示第 i 个泰波那契数.
2. 状态转移方程:
  直接可以从题目中获得: dp[i] = dp[i-1] + dp[i-2] +dp[i-3].
3. 初始化:
  由状态转移方程可知, 我们必须要知道前三个dp才能计算后面的值. 根据题目可知:
  dp[0] = 0 , dp[1] = 1, dp[2] =1;
4. 填表顺序:
  从左向右.
5. 返回值:
  返回dp[n].
代码示例(Java):

class Solution {
    public int tribonacci(int n) {
        //1.创建dp表
        int[] dp = new int[n+1];
        if(n==0){
            return 0;
        }
        if(n==1||n==2){
            return 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];
    }
}

在这里插入图片描述

二. 三步问题.

题目链接: 面试题 08.01. 三步问题
题目描述:
三步问题。有个小孩正在上楼梯，楼梯有n阶台阶，小孩一次可以上1阶、2阶或3阶。实现一种方法，计算小孩有多少种上楼梯的方式。结果可能很大，你需要对结果模1000000007。

示例1:
输入：n = 3
输出：4
说明: 有四种走法

示例2:
输入：n = 5
输出：13

解法:(动态规划)
1. 状态表示:
  这道题可以根据「经验 + 题目要求」直接定义出状态表示：
  dp[i] 表示：到达 i 位置时，一共有多少种方法。
2. 状态转移方程:
  以 i 位置状态的最近的一步，来分情况讨论：
  - 如果 dp[i] 表示小孩上第 i 阶楼梯的所有方式，那么它应该等于所有上一步的方式之和：
    - i. 上⼀步上⼀级台阶， dp[i] += dp[i - 1] ；
    - ii. 上⼀步上两级台阶， dp[i] += dp[i - 2] ；
    - iii. 上⼀步上三级台阶， 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 的时候是没有办法进行推导的.
  因此我们需要在填表之前，将 1, 2, 3 位置的值初始化。根据题意， dp[1] = 1, dp[2] = 2, dp[3] = 4 。
4. 填表顺序:
  从左向右.
5. 返回值:
  返回dp[n].
代码示例(Java):

class Solution {
    public int waysToStep(int n) {
        //1.创建dp表
        int[] dp = new int[n+1];
        if(n<=2){
            return n;
        }
        if(n==3){
            return 4;
        }
        //2. 初始化
        dp[1] = 1;
        dp[2] = 2;
        dp[3] = 4;
        //3.填表
        for(int i = 4;i<=n; i++){
            dp[i] = ((dp[i-1]+dp[i-2])%1000000007+dp[i-3])%1000000007;
        }
        //4. 返回结果
        return dp[n];
    }
}

在这里插入图片描述

三.使用最小花费爬楼梯

题目链接: 746. 使用最小花费爬楼梯
题目描述:
给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。
你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。
请你计算并返回达到楼梯顶部的最低花费。

示例 1：
输入：cost = [10,15,20]
输出：15
解释：你将从下标为 1 的台阶开始。
支付 15 ，向上爬两个台阶，到达楼梯顶部。
总花费为 15 。

示例 2：
输入：cost = [1,100,1,1,1,100,1,1,100,1]
输出：6
解释：你将从下标为 0 的台阶开始。
支付 1 ，向上爬两个台阶，到达下标为 2 的台阶。
支付 1 ，向上爬两个台阶，到达下标为 4 的台阶。
支付 1 ，向上爬两个台阶，到达下标为 6 的台阶。
支付 1 ，向上爬一个台阶，到达下标为 7 的台阶。
支付 1 ，向上爬两个台阶，到达下标为 9 的台阶。
支付 1 ，向上爬一个台阶，到达楼梯顶部。
总花费为 6 。

解法:(动态规划)
1. 状态表示:
  这道题可以根据「经验 + 题目要求」直接定义出状态表示：
  dp[i] 表示：到达 i 位置时的最小花费。（注意：到达 i 位置的时候， i 位置的钱不需要
  算上）
  在这道题中，数组内的每一个下标 [0, n - 1] 表示的都是楼层，而顶楼的位置其实是在 n 的
  位置！！!
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].
代码示例(Java):

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        //1.创建dp表
        int n = cost.length;
        int[] dp = new int[n+1];
        //2.填表
        for(int i = 2;i<=n;i++){
            dp[i] = Math.min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);
        }
        //3.返回结果
        return dp[n];
         
    }
}

在这里插入图片描述

四.解码方法

题目链接: 91.解码方法
题目描述:
一条包含字母 A-Z 的消息通过以下映射进行了编码：
“1” -> ‘A’
“2” -> ‘B’
…
“25” -> ‘Y’
“26” -> ‘Z’
然而，在解码已编码的消息时，你意识到有许多不同的方式来解码，因为有些编码被包含在其它编码当中（“2” 和 “5” 与 “25”）。
例如，“11106” 可以映射为：
“AAJF” ，将消息分组为 (1, 1, 10, 6)
“KJF” ，将消息分组为 (11, 10, 6)
消息不能分组为 (1, 11, 06) ，因为 “06” 不是一个合法编码（只有 “6” 是合法的）。
注意，可能存在无法解码的字符串。
给你一个只含数字的非空字符串 s ，请计算并返回解码方法的总数。如果没有合法的方式解码整个字符串，返回 0。
题目数据保证答案肯定是一个 32 位的整数。

示例 1：
输入：s = “12”
输出：2
解释：它可以解码为 “AB”（1 2）或者 “L”（12）。

示例 2：
输入：s = “226”
输出：3
解释：它可以解码为 “BZ” (2 26), “VF” (22 6), 或者 “BBF” (2 2 6) 。

示例 3：
输入：s = “06”
输出：0
解释：“06” 无法映射到 “F” ，因为存在前导零（“6” 和 “06” 并不等价）。

解法:(动态规划)
1. 状态表示:
  这道题可以根据「经验 + 题目要求」直接定义出状态表示：
  dp[i] 表示：字符串中 [0，i] 区间上，一共有多少种编码方法
2. 状态转移方程:
  定义好状态表示，我们就可以分析 i 位置的 dp 值，如何由「前面」或者「后面」的信息推导出来。
  关于 i 位置的编码状况，我们可以分为下面两种情况：
  - i. 让 i 位置上的数单独解码成⼀个字母；
  - ii. 让 i 位置上的数与 i - 1 位置上的数结合，解码成一个字母。
    下面我们就上面的两种解码情况，继续分析：
  - 1.让 i 位置上的数单独解码成⼀个字母，就存在「解码成功」和「解码失败」两种情况：
    - i. 解码成功：当 i 位置上的数在 [1, 9] 之间的时候，说明 i 位置上的数是可以单独解码的，那么此时 [0, i] 区间上的解码方法应该等于 [0, i - 1] 区间上的解码方法。因为 [0, i - 1] 区间上的所有解码结果，后面填上一个 i 位置解码后的字母就可以了。此时 dp[i] = dp[i - 1] ；
    - ii. 解码失败：当 i 位置上的数是 0 的时候，说明 i 位置上的数是不能单独解码的，那么此时 [0, i] 区间上不存在解码方法。因为 i 位置如果单独参与解码，但是解码失败了，那么前面做的努力就全部白费了。此时 dp[i] = 0 。
  - 2.让 i 位置上的数与 i - 1 位置上的数结合在一起，解码成一个字母，也存在「解码成功」和「解码失败」两种情况：
    - i. 解码成功：当结合的数在 [10, 26] 之间的时候，说明 [i - 1, i] 两个位置是可以
      解码成功的，那么此时 [0, i] 区间上的解码⽅法应该等于 [0, i - 2 ] 区间上的解码
      ⽅法，原因同上。此时 dp[i] = dp[i - 2] ；
    - ii. 解码失败：当结合的数在 [0, 9] 和 [27 , 99] 之间的时候，说明两个位置结合后解码失败（这里一定要注意 00 01 02 03 04 … 这几种情况），那么此时 [0, i] 区间上的解码方法就不存在了，原因依旧同上。此时 dp[i] = 0 。
  综上所述： dp[i] 最终的结果应该是上⾯四种情况下，解码成功的两种的累加和（因为我们关心的是解码方法，既然解码失败，就不用加入到最终结果中去），因此可以得到状态转移方程（ dp[i] 默认初始化为 0 ）：
  - i. 当 s[i] 上的数在 [1, 9] 区间上时： dp[i] += dp[i - 1] ；
  - ii. 当 s[i - 1] 与 s[i] 上的数结合后，在 [10, 26] 之间的时候： dp[i] += dp[i - 2] ；
  如果上述两个判断都不成立，说明没有解码方法， dp[i] 就是默认值 0 。
3. 初始化:
  - 方法一（直接初始化）：
    由于可能要用到 i - 1 以及 i - 2 位置上的 dp 值，因此要先初始化「前两个位置」。
    - 初始化 dp[0] ：
      - i. 当 s[0] == ‘0’ 时，没有编码⽅法，结果 dp[0] = 0 ；
      - ii. 当 s[0] != ‘0’ 时，能编码成功， dp[0] = 1
    - 初始化 dp[1] ：
      - i. 当 s[1] 在 [1，9] 之间时，能单独编码，此时 dp[1] += dp[0] （原因同上，
        dp[1] 默认为 0 ）
      - ii. 当 s[0] 与 s[1] 结合后的数在 [10, 26] 之间时，说明在前两个字符中，又有一种编码方式，此时 dp[1] += 1
  - 方法二（添加辅助位置初始化）：
    可以在最前面加上一个辅助结点，帮助我们初始化。使用这种技巧要注意两个点：
    - i. 辅助结点里面的值要保证后续填表是正确的；
    - ii. 下标的映射关系
4. 填表顺序:
  从左向右.
5. 返回值:
  返回dp[n].
代码示例(Java):

class Solution {
    public int numDecodings(String s) {
        //1.创建dp表
        int n = s.length();
        char[] ss = s.toCharArray();
        int[] dp = new int[n];
        //2.初始化
        if(ss[0]=='0') dp[0] = 0;
        else dp[0] = 1;
        if(n==1){
            return dp[0];
        }
        if(ss[1]!='0'&&ss[0]!='0') dp[1] +=1;
        int x = (ss[0]-'0')*10+(ss[1]-'0');
        if(x>=10&&x<=26) dp[1]+=1;
        //3. 填表
        for(int i=2;i<n;i++){
            if(ss[i]!='0') dp[i] = dp[i-1];
            int y = (ss[i-1]-'0')*10+(ss[i]-'0');
            if(y>=10&&y<=26) dp[i] = dp[i] +dp[i-2];
        }
        //4. 返回结果
        return dp[n-1];
    }
}

在这里插入图片描述

五.总结

动态规划类型的题目的做题步骤:
1. 状态表示–>这个往往是根据经验+题目要求来进行分析表示的.
2. 状态转移方程—>这个往往是根据要到达这个状态的前一个或前几个状态来进行推理的
3. 初始化–>这个往往根据状态转移方程就可以知道要初始化哪几个状态值, 在根据题目对应的题意进行初始化
4. 填表顺序:往往是从左到右或从右往左.
5. 返回值: 根据题目要求确定返回值