代码随想录算法训练营第38天|509. 斐波那契数 、70. 爬楼梯 、 746. 使用最小花费爬楼梯

1.斐波那契数

509. 斐波那契数

斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1

给定 n ，请计算 F(n) 。

示例 1：

输入：n = 2
输出：1
解释：F(2) = F(1) + F(0) = 1 + 0 = 1

示例 2：

输入：n = 3
输出：2
解释：F(3) = F(2) + F(1) = 1 + 1 = 2

示例 3：

输入：n = 4
输出：3
解释：F(4) = F(3) + F(2) = 2 + 1 = 3

提示：

• 0 <= n <= 30

code：

用模拟的思想做的，非dp

/**
 * @param {number} n
 * @return {number}
 */
var fib = function(n) {
    if(n === 0) return 0;
    if(n === 1) return 1;
    let num1 = 0, num2 = 1;
    let cur;
    for(let i = 2; i <= n; i++){
        cur = num1 + num2;
        num1 = num2;
        num2 = cur;
    }
    return cur;  
};

用动态规划来做

1. 确定dp数组（dp table）以及下标的含义

   dp[i]表示第i个斐波那契数

2. 确定递推公式

   题目 中有 dp[i] = dp[i - 1] + dp[i - 2]

3. dp数组如何初始化

   题目中有 dp[0] = 0 , dp[1] = 1

4. 确定遍历顺序

   是从后向前还是从前向后，是一层还是两层，如果是两层，哪层在外面

5. 打印推导dp数组（debug用的）

70. 爬楼梯

70. 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例 1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶

示例 2：

输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

提示：

• 1 <= n <= 45

code：

在前面知识的基础上，我大概能了解到迈上第n阶的方法其实是有前面的迈上n-1和迈上n-2阶的种数有关的，但是如果没有关键点的想，很容易想岔去。

下面的代码是我第一个自己思考的代码，是错误的，一开始想的是想的是比如想要到第4阶，有可能是dp[1] + dp[3], dp[2]+ dp[2], dp[3] + dp[1]；但是如果这样想的话，所有种类中是会有重复值的。所以我也想到了要去重，但是去重的规律并没有找对；

/**
 * @param {number} n
 * @return {number}
 */
var climbStairs = function(n) {
    //dp[i]表示爬到i阶楼梯，有dp[i]种方法
    let dp = [0, 1, 2];
    //初始化dp[]
    //状态转移方程
    for(let i = 3; i <= n; i++){
        let cn = 0;
        for(let k = 1; k < i; k++){
            cn += (dp[k] * dp[i - k]);
        }
        //去除重复值
        cn = cn - 2 * i + 5;
        dp.push(cn);
    }
    return dp[n];
};

看了卡哥的视频解说，反复想了一下理解了，其实思路是可以有很多种的，但是如果想用动态规划的思路来写，关键点在于状态转移，如果从0阶开始向上迈，那么状态转移方程其实很不好把握，容易像我之前一样想岔了，会想：先走几阶有几种方法，后走几阶有几种方法，很容易把自己绕进去。

但是如果想要专注于状态转移，应该从台阶上往下看，而且必须注意状态转移的条件（即每次只能爬1或2个台阶），那么对于一个人来说，他走到n层台阶的上一个状态只可能有两种：

1. 上一个状态是走到了n-1个台阶，他是迈了一步才走到n台阶的
2. 上一个状态是走到了n-2个台阶，他是迈了两步才走到n台阶的

可以想到，这样递归出来的种类数其实是很干净的，不会存在重复值，因为不同于我第一次的想法，我第一次想的是（**step1:**从0-k有几种方法； **step2:**从k-n有几种方法），而动态规划中，强制了我的step2只能有一种方法。举个例子:

易得dp[1] = 1, dp[2]= 2

如果我想求dp[4]

先看看我原本的想法：可能性有先走一步，再走三步；先走二步，再走两步；先走三步，再走一步

那么这个dp[4]=dp[1]*dp[3]+ dp[2]*dp[2]+dp[3]*dp[1]，但是这样的递归推导是不干净的，因为里面存在了很多的重复值

再看看动态规划的思想：如果我想根据step1+step2的思路来思考的话，首先强制step2的方法只能有一种，即当走过step1方法到达中间的某个台阶后，我只能通过一种方法来到达台阶n。

虽然step只能有一种方法，但是step可以有两种情况：即先走 2步，然后走2步到n；或者先走3步，然后走1步到n；

由此可得到：dp[4] = d[2] * 1 + d[3] * 1;

所以我才得出了dp的关键在于：到达这个状态的上一个状态是怎么样的，因为上一个状态总是通过一次操作（一次状态转移）达到这个状态，这样递归下来的数据才是干净的。

/**
 * @param {number} n
 * @return {number}
 */
var climbStairs = function(n) {
    //dp[i]表示爬到i阶楼梯，有dp[i]种方法
    let dp = [0, 1, 2];
    //状态转移方程
    for(let i = 3; i <= n; i++){
        dp.push(dp[i - 1] + dp[i - 2]);//可以不用维护数组，直接用变量来写，写法上一题斐波那契数写法一致，不写了这里
    }
    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 。

提示：

• 2 <= cost.length <= 1000
• 0 <= cost[i] <= 999

Code:

这道题的难点在于搞清楚ct[i]到底指的是什么？i能不能取到cost.length

/**
 * @param {number[]} cost
 * @return {number}
 */

//ct[i]指的是到达i（此时i是楼顶）的最小消费
var minCostClimbingStairs = function(cost) {
    //ct[i]达到i台阶的需要最小消费
    if(cost.length==1) return cost[0];
    if(cost.length==2) return Math.min(cost[0],cost[1]);
    let ct1 = Math.min(cost[0],cost[1]);
    let ct = [0, 0];
    for(let i = 2; i <= cost.length; i++){
        let cur = Math.min(ct[i - 1]+cost[i - 1], ct[i-2]+cost[i-2]);
        ct.push(cur);
    }
    return ct[ct.length - 1];
};