【动态规划】-【基础题目01】-509斐波那契数，70爬楼梯

benwen 本文写动态规划的第一类基础题目，需要注意的是：

递归公式的推导，五步曲！！！扩展的m步上楼梯

目录

509. 斐波那契数

70. 爬楼梯

746. 使用最小花费爬楼

---

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：

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

思路：

我们用五步曲进行分析：

（1）dp数组下标的含义：显然下标 i 代表第 i 个数，F(i)代表第 i 个数的值；

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

（3）初始化：数列从0和1开始，那么第0个为0，第1个为1，题意也给出来了，后面就是dp[i]=dp[i-1]+dp[i-2]；

（4）遍历顺序：从0开始，从前到后，从小到大，

代码：

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

同时需要注意，上面我们维护了整个序列，那么时间复杂度O(n)，空间复杂度O(n)。但其实我们只需要每次记录前面两个数字就够了，于是变成下面：

class Solution {
public:
    int fib(int n) {
        if(n<=1)
           return n;
        int t1=0,t2=1;
        int t=t1+t2;
        for(int i=2;i<=n;i++){
            t=t1+t2;
            t1=t2;
            t2=t;
        }
        return t;     
    }
};

此时空间复杂度变为O(1)。

当然此题目还可以使用递归来做，但空间复杂度为O(n)，时间复杂度O(2^n)，指数级，因为是树状。

---

70. 爬楼梯

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

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

注意：给定 n 是一个正整数。

示例 1：

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

示例 2：

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

思路：

五步法：

（1）dp数组下标含义：i表示楼梯级数，dp[i]表示当前级数为 i 的楼梯有多少种上法；

（2）递推公式：由于每次只能上1或者2级，那么dp[i]=dp[i-1]+dp[i-2]，同斐波那契；

（3）初始化：dp[1]=1，dp[2]=2，对于dp[0]，第0级台阶有一种上法就是不动，而不是0，故dp[0]=1；

（4）遍历顺序：从小到大；同时遍历应该从3开始，到n结束；

代码：

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 1) 
            return n; 
        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];
    }
};

同样可以用相同的方法进行简化。

---

扩展：

这道题目还可以继续深化，如果一步一个台阶，两个台阶，三个台阶，直到 m个台阶，有多少种方法爬到n阶楼顶。

这个其实也不难想，拿刚刚那个来说：一次只能上1 2级，那么对于当前 i 级，可能最后一步是1，或者2，那么只有两种情况，所以就是dp[i]=dp[i-1]+dp[i-2]；

那么对于最后一次台阶有m种可能的上法，那么就是假设最后一次上了1级，+dp[i-1]，最后一次上了2级，+dp[i-2]，最后一次上了3级，+dp[i-3]，最后一次上了m级，+dp[i-m]，所以当可以上m级台阶时，dp[i]=dp[i-1]+dp[i-2]+dp[i-3]+……+dp[i-m]。

需要详细考虑这个递推公式到底怎么来的！！

代码如下：

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 1) 
            return n; 
        vector<int> dp(n + 1);
        dp[0] = 1;
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) { 
            for(int j=1;j<=m;j++)
                if(i-j>=0) //注意，初始化了dp[0]，这里是>=0
                    dp[i] += dp[i - j];
        }
        return dp[n];
    }
};

---

746. 使用最小花费爬楼梯

数组的每个下标作为一个阶梯，第 i 个阶梯对应着一个非负数的体力花费值 cost[i]（下标从 0 开始）。

每当你爬上一个阶梯你都要花费对应的体力值，一旦支付了相应的体力值，你就可以选择向上爬一个阶梯或者爬两个阶梯。

请你找出达到楼层顶部的最低花费。在开始时，你可以选择从下标为 0 或 1 的元素作为初始阶梯。

输入：cost = [10, 15, 20] 输出：15 解释：最低花费是从 cost[1] 开始，然后走两步即可到阶梯顶，一共花费 15 。  示例 2：

输入：cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1] 输出：6 解释：最低花费方式是从 cost[0] 开始，逐个经过那些 1 ，跳过 cost[3] ，一共花费6。

思路：

动态规划五步法：

（1）数组及下标含义：dp[i]表示需要上到第 i 阶要耗费的最小体力；

（2）递推公式：由于一次只能上1 2级台阶，那么dp[i]=min( dp[i-1]+cost[i-1], dp[i-2]+cost[i-2]）；

（3）初始化：题目所知，得到dp[1]=dp[0]=0，然后循环的时候从i=2开始。

（4）递归顺序：从小到大；

代码：

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int n=cost.size();
        if (n <= 1) 
            return 0; 
        vector<int> dp(n + 1);
        dp[0] = 0;
        dp[1] = 0;
        for (int i = 2; i <= n; i++)  // 注意i是从3开始
            dp[i] = min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2]);
        return dp[n];
    }
};