Day31 力扣动态规划 : 理论基础 ｜ 509. 斐波那契数 ｜70. 爬楼梯｜746. 使用最小花费爬楼梯

理论基础

无论大家之前对动态规划学到什么程度，一定要先看 我讲的 动态规划理论基础。

如果没做过动态规划的题目，看我讲的理论基础，会有感觉 是不是简单题想复杂了？

其实并没有，我讲的理论基础内容，在动规章节所有题目都有运用，所以很重要！

如果做过动态规划题目的录友，看我的理论基础 就会感同身受了。

https://programmercarl.com/%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html
视频：https://www.bilibili.com/video/BV13Q4y197Wg

什么是动态规划

英文：Dynamic Programming，简称DP，如果某一问题有很多重叠子问题，使用动态规划是最有效的。

所以动态规划中每一个状态一定是由上一个状态推导出来的，这一点就区分于贪心，贪心没有状态推导，而是从局部直接选最优的，

解题步骤

状态转移公式（递推公式）是很重要，但动规不仅仅只有递推公式。

对于动态规划问题，我将拆解为如下五步曲，这五步都搞清楚了，才能说把动态规划真的掌握了！

• 确定dp数组（dp table）以及下标的含义
• 确定递推公式
• dp数组如何初始化
• 确定遍历顺序
• 举例推导dp数组

一些同学可能想为什么要先确定递推公式，然后在考虑初始化呢？

因为一些情况是递推公式决定了dp数组要如何初始化！

如何debug

找问题的最好方式就是把dp数组打印出来，看看究竟是不是按照自己思路推导的！

做动规的题目，写代码之前一定要把状态转移在dp数组的上具体情况模拟一遍，心中有数，确定最后推出的是想要的结果。

没有通过就去思考：

• 这道题目我举例推导状态转移公式了么？
• 我打印dp数组的日志了么？
• 打印出来了dp数组和我想的一样么？

509. 斐波那契数

很简单的动规入门题，但简单题使用来掌握方法论的，还是要有动规五部曲来分析。

https://programmercarl.com/0509.%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E6%95%B0.html
视频：https://www.bilibili.com/video/BV1f5411K7mo

第一印象

好熟悉的题目，我记得递归。

题虽然不难，但是要用dp的思路去做题，直接看题解学习一下思路吧。

看完题解的思路

1. dp数组（dp table），下标的含义
   dp[] 数组就是斐波那契数列，第i个就是数列里第i个数
2. 递推公式
   题目中给出了 F(n) = F(n - 1) + F(n - 2)
3. 初始化
   题目也给了，F(0) = 0，F(1) = 1
4. 遍历顺序
   从左到右
5. 举例推导dp数组
   打印dp数组，举例确实是对的

实现中的困难

实现不难 我没考虑这个情况

//对初始条件的处理
        if (n <= 1) return n;

也可以压缩中间的代码。

//dp 数组
        int[] dp = new int[2];
        //初始化
        dp[0] = 0;
        dp[1] = 1;
        
        for (int i = 1; i <= n - 1; i++) {
            int sum = dp[0] + dp[1];
            dp[0] = dp[1];
            dp[1] = sum;
        }

这里for循环的终止条件，举个例子画画图就算出来了，臆想的话我做不出来。

感悟

因为题目给了初始化和递推公式才简单。

代码

正常版本

class Solution {
    public int fib(int n) {
        //对初始条件的处理
        if (n <= 1) return n;
        //dp 数组
        int[] dp = new int[n + 1];
        //初始化
        dp[0] = 0;
        dp[1] = 1;
        
        for (int i = 2; i < dp.length; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }

        return dp[n];
    }
}

压缩代码的版本

class Solution {
    public int fib(int n) {
        //对初始条件的处理
        if (n <= 1) return n;
        //dp 数组
        int[] dp = new int[2];
        //初始化
        dp[0] = 0;
        dp[1] = 1;
        
        for (int i = 1; i <= n - 1; i++) {
            int sum = dp[0] + dp[1];
            dp[0] = dp[1];
            dp[1] = sum;
        }

        return dp[1];
    }
}

70. 爬楼梯

本题大家先自己想一想， 之后会发现，和 斐波那契数 有点关系。

https://programmercarl.com/0070.%E7%88%AC%E6%A5%BC%E6%A2%AF.html
视频：https://www.bilibili.com/video/BV17h411h7UH

第一印象

我按五部曲想一想

dp数组，就是模拟每一步上楼梯，val就是上1或者2

初始化，可能第一步1 或者第一步2？

递推公式，……

好了，看题解吧。我怎么觉得这道题像回溯的排列问题呢

看完题解的思路

我想的是错的

1. dp数组： i 阶楼梯有dp[i] 上楼的方法
2. 递推公式：这道题不是去寻思排列那种东西，直接就举例子，一节楼梯1种，2节楼梯2种，3节楼梯的话，要么是从1节开始再上2节，要么是从2节开始在上1节。都是1节和两节的和。4节楼梯也是，从2节/3节 走2/1步才能上来。 5节楼梯要么从3节上，要么从4节上。所以n节楼梯，就是n-1 节和n-2节上来的，那么就是 dp[n] = dp[n-1] + dp[n-2] 其实就是斐波那契数列
3. 初始化，初始化dp[1] dp[2] 为什不管0呢？ 看第一条dp数组的意义
4. 确定便利顺序
   从左往右
5. 打印试试： ok

实现中的困难

没有

感悟

我觉得有一种数学归纳法的感觉，去看整体，是推倒的关系，而不是看怎么走能走到n阶并统计路线个数。

代码

class Solution {
    public int climbStairs(int n) {
        if (n <= 2) return n;
        //从下标为1开始，代表1阶楼梯，下标为0的不管了
        int[] dp = new int[n + 1];
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i < dp.length; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
}

746. 使用最小花费爬楼梯

这道题目力扣改了题目描述了，现在的题目描述清晰很多，相当于明确说 第一步是不用花费的。

更改题目描述之后，相当于是 文章中 「拓展」的解法

https://programmercarl.com/0746.%E4%BD%BF%E7%94%A8%E6%9C%80%E5%B0%8F%E8%8A%B1%E8%B4%B9%E7%88%AC%E6%A5%BC%E6%A2%AF.html
视频讲解：https://www.bilibili.com/video/BV16G411c7yZ

第一印象

理解体干就有些难，他也没说什么是台阶的数量。但是从例子可以看出，比如数组大小是3，台阶0就是地面，台阶1是第一个台阶，台阶2是第二个台阶，其次还有一个台阶是重点。因为台阶2向上爬消耗 cost[2] 的体力值。如果是向上爬2层，那就该有cost[3]了，所以只能是一层，名为终点吧。

我自己试试哈

dp数组： 第i个楼梯最小消耗 dp[i] 体力，注意楼顶应该是dp[n] ，所以数组大小要是n + 1.

递归公式： 爬第n个的最低消费，是n-1的最低消费 + n-1 的体力 或者 n-2的最低消费 + n-2的体力，他们小的那个作为爬到n的最低消费。

dp[n] = min (dp[n-1] + cost[n-1], dp[n-2] + cost[n-2]) 合理的

初始化： dp[0] dp[1] 都是0，dp[2] 就开始是dp[n] = min (dp[n-1] + cost[n-1], dp[n-2] + cost[n-2]) 推倒出来的了

遍历顺序： 从左到右

打印试试： ojbk

实现中的困难

没有苦难

感悟

我学会了！

代码

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        if (cost.length == 0) return 0;
        if (cost.length == 1) return cost[1];

        //多一个楼顶，
        int[] dp = new int[cost.length + 1];
        dp[0] = 0;
        dp[1] = 0;

        for (int i = 2; i < dp.length; i++) {
            dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
        }
        return dp[dp.length - 1];

    }
}