day38 |509. 斐波那契数、70. 爬楼梯、746. 使用最小花费爬楼梯

目录：

解题及思路学习

基础知识：

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

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

对于动态规划问题，可拆解为如下五步曲：

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

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

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

然后再写代码，如果代码没通过就打印dp数组，看看是不是和自己预先推导的哪里不一样。

如果打印出来和自己预先模拟推导是一样的，那么就是自己的递归公式、初始化或者遍历顺序有问题了。

如果和自己预先模拟推导的不一样，那么就是代码实现细节有问题。

这样才是一个完整的思考过程，而不是一旦代码出问题，就毫无头绪的东改改西改改，最后过不了，或者说是稀里糊涂的过了。

509. 斐波那契数

https://leetcode.cn/problems/fibonacci-number/

斐波那契数 （通常用 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

思考：有点像以前递归的那种感觉。

虽然能过，但是耗时比较长。

class Solution {
public:
    int fib(int n) {
        if (n == 0) return 0;
        if (n == 1) return 1;
        return fib(n-1) + fib(n-2);
    }
};

• 时间复杂度：O(2^n)
• 空间复杂度：O(n)，算上了编程语言中实现递归的系统栈所占空间(递归时间复杂度 = 递归的次数 * 每次递归中的操作次数)

随想录：

动规五部曲：

这里我们要用一个一维dp数组来保存递归的结果

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

   dp[i]的定义为：第i个数的斐波那契数值是dp[i]

2. 确定递推公式

   状态转移方程 dp[i] = dp[i - 1] + dp[i - 2];

3. dp数组如何初始化

dp[0] = 0; dp[1] = 1;

4. 确定遍历顺序

从递归公式dp[i] = dp[i - 1] + dp[i - 2];中可以看出，dp[i]是依赖 dp[i - 1] 和 dp[i - 2]，那么遍历的顺序一定是从前到后遍历的

5. 举例推导dp数组

推导一下，当N为10的时候，dp数组应该是如下的数列：0 1 1 2 3 5 8 13 21 34 55

如果代码写出来，发现结果不对，就把dp数组打印出来看看和我们推导的数列是不是一致的。

class Solution {
public:
    int fib(int n) {
        if (n < 2) return n;
        vector<int> dp(n+1);
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
};

• 时间复杂度：O(n)
• 空间复杂度：O(n)

自己动手打印中间值的测试代码：

#include<iostream>
#include<vector>
#include<string>

using namespace std;

class Solution {
public:
    int fib(int n) {
        if (n < 2) return n;
        vector<int> dp(n + 1);
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
            cout << dp[i] << " ";
        }
        cout << endl;
        return dp[n];
    }
};

int main()
{   
    int n;
    cin >> n;
    Solution s;
    int result = s.fib(n);
    cout << "n:" << n << " result:" << result;

    //system("pause");
    return 0;
}

当然可以发现，我们只需要维护两个数值就可以了，不需要记录整个序列。

class Solution {
public:
    int fib(int n) {
        if (n < 2) return n;
        int dp[2];
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            int sum = dp[0] + dp[1];
            dp[0] = dp[1];
            dp[1] = sum;
        }
        return dp[1];
    }
};

• 时间复杂度：O(n)
• 空间复杂度：O(1)

70. 爬楼梯

https://leetcode.cn/problems/climbing-stairs/

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

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

示例 1：

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

思考：由于后一步楼梯的状态是有上一步状态推导出来的 ，所以可以使用动态规划算法。

1、dp[i] 数组代表第i步时候楼梯的阶数。

2、递归公式： dp[i] = dp[i-1] + dp[i-2] + … + dp[0].

3、初始化：

感觉想错了。想不明白，直接看解析。

随想录：1阶一种方法，2阶有两种方法。3阶有三种方法。当大于等于3阶的时候，每个阶梯的方法数只跟前两个阶梯的方法数有关。例如：三阶可以有一阶跨两步，也可以有两阶跨一步。所以：

1、dp[i] 表示到达i阶有dp[i]种方法。

2、递推公式： dp[i] = dp[i-1] + dp[i-2]

3、初始化：dp[1] = 1; dp[2] = 2;

4、确定遍历顺序。从递归公式dp[i] = dp[i - 1] + dp[i - 2];中可以看出，dp[i]是依赖 dp[i - 1] 和 dp[i - 2]，那么遍历的顺序一定是从前到后遍历的

5、举例推导：推导一下，当N为10的时候，dp数组应该是如下的数列：0 1 1 2 3 5 8 13 21 34 55

// 版本一
class Solution {
public:
    int climbStairs(int n) {
        if (n <= 1) return n; // 因为下面直接对dp[2]操作了，防止空指针
        vector<int> dp(n + 1);
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) { // 注意i是从3开始的
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
};

• 时间复杂度：$O(n)$
• 空间复杂度：$O(n)$

优化空间复杂度：

// 版本二
class Solution {
public:
    int climbStairs(int n) {
        if (n <= 1) return n;
        int dp[3];
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) {
            int sum = dp[1] + dp[2];
            dp[1] = dp[2];
            dp[2] = sum;
        }
        return dp[2];
    }
};

• 时间复杂度：$O(n)$
• 空间复杂度：$O(1)$

后面将讲解的很多动规的题目其实都是当前状态依赖前两个，或者前三个状态，都可以做空间上的优化，但我个人认为面试中能写出版本一就够了哈，清晰明了，如果面试官要求进一步优化空间的话，我们再去优化。

746. 使用最小花费爬楼梯

https://programmercarl.com/0746.使用最小花费爬楼梯.html

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

请你计算并返回达到楼梯顶部的最低花费。

示例 1：

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

思考：按照动态规划的思路去想。由于可以选择爬一个或者两个台阶，所以第i个台阶的最低费用为前两个台阶的费用+到前两个台阶的费用 的最小值。

1、dp[i] 表示 到第i个台阶的最低费用dp[i]。

2、递推公式： dp[i] = min( dp[i-1] + cost[i-1], dp[i-2] + cost[i-2])。

3、初始化：dp[0] = 0, dp[1] = 0. （由于可以选择从0或者1 阶梯开始，所以，刚开始费用为0）

4、从前往后遍历

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int n = cost.size();
        if (n <= 2) return min(cost[0], cost[1]);
        vector<int> dp(n + 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];
    }
};

• 时间复杂度：$O(n)$
• 空间复杂度：$O(n)$

优化空间：

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int n = cost.size();
        int dp[2];
        dp[0] = 0;
        dp[1] = 0;
        for (int i = 2; i <= n; i++) {
            int min_cost = min(dp[0] + cost[i-2], dp[1] + cost[i-1]);
            dp[0] = dp[1];
            dp[1] = min_cost;
        }
        return dp[1];
    }
};

• 时间复杂度：$O(n)$
• 空间复杂度：$O(1)$

经过前两道题的铺垫，最后一道题自己AC。

知识点记录

知识点

动态规划五部曲：

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

个人反思

1、当看到前后状态有关联的时候，就可以考虑使用动态规划方法了。

2、做动态规划题目，按照五部曲来做题，思路会比较清晰。