代码随想录算法训练营第二十八天 | 动态规划理论基础、509. 斐波那契数、70. 爬楼梯、746. 使用最小花费爬楼梯

代码随想录算法训练营第二十八天任务

• 动态规划理论基础
• [509. 斐波那契数](#509. 斐波那契数)
• [70. 爬楼梯](#70. 爬楼梯)
• [746. 使用最小花费爬楼梯](#746. 使用最小花费爬楼梯)

动态规划理论基础

动态规划（Dynamic Programming，DP）每一个状态是由上一个状态推导出来的。

如果某一个问题有很多重叠子问题，使用动态规划是最有效的。

动态规划解题五步曲：

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

这5步缺一不可，心法在这里代码随想录-动态规划理论基础

509. 斐波那契数

题目链接：509. 斐波那契数

分析：

1. 确定dp数组以及下标的含义
   dpi:第i项斐波那契数
2. 确定递推公式
   dpi = dpi-1 + dpi-2
3. dp数组如何初始化
   dp0 = 0, dp1 = 1, i > 1, dpi = ...
4. 确定遍历顺序
   0->n
5. 举例推导dp数组
   dp2 = dp1 + dp0 = 1 + 0 = 1
   dp3 = dp2 + dp1 = 1 + 1 = 2
   dp4 = dp3 + dp2 = 2 + 1 = 3

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ⁿ)

空间复杂度：O(n)

另解：

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. 爬楼梯

题目链接：70. 爬楼梯

分析：

1. 确定dp数组以及下标的含义
   dpi：到达 第 i 阶有 dpi 种方法
2. 确定递推公式
   dpi = dpi-1 + dpi-2
3. dp数组如何初始化
   dp1 = 1, dp2 = 2
4. 确定遍历顺序
   0-->n
5. 举例推导dp数组
   dp3 = dp2 + dp1 = 3
   dp4 = dp3 + dp2 = 5
   n = 4时，
   1. 1 阶 + 1 阶 + 1 阶 + 1 阶
   2. 1 阶 + 2 阶 + 1 阶
   3. 2 阶 + 1 阶 + 1 阶
   4. 1 阶 + 1 阶 + 2 阶
   5. 2 阶 + 2 阶

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

时间复杂度：O(n)

空间复杂度：O(1) 固定大小的数组

746. 使用最小花费爬楼梯

题目链接：746. 使用最小花费爬楼梯

分析：

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

   dpi：到达 第 i 个台阶需要支付的最低费用为dpi

2. 确定递推公式

   dpi = min(dpi-1 + costi-1, dpi-2 + costi-2)

3. dp数组如何初始化

   dp0 = 0, dp1 = 0 可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯，说明到达 第 0 或者 1的台阶的费用为0

4. 确定遍历顺序

   0-->n

5. 举例推导dp数组

   eg: cost = 10,15,20

   dp2 = min(dp1 + cost1, dp0 + cost0) = 10

   dp3 = min(dp2 + cost2, dp1 + cost1) = min(30, 15) = 15

   eg: cost = cost = 1,100,1,1,1,100,1,1,100,1

   dp2 = min(dp1 + cost1, dp0 + cost0) = 1

   dp3 = min(dp2 + cost2, dp1 + cost1) = min(2, 100) = 2

   dp4 = min(dp3 + cost3, dp2 + cost2) = min(3, 2) = 2

   dp5 = min(dp4 + cost4, dp3 + cost3) = min(2+1, 2+1) = 3

   dp6 = min(dp5 + cost5, dp4 + cost4) = min(3+100, 2+1) = 3

   dp7 = min(dp6 + cost6, dp5 + cost5) = min(3+1, 3+100) = 4

   dp8 = min(dp7 + cost7, dp6 + cost6) = min(4+1, 3+1) = 4

   dp9 = min(dp8 + cost8, dp7 + cost7) = min(4+100, 4+1) = 5

   dp10 = min(dp9 + cost9, dp8 + cost8) = min(5+1, 4+100) = 6

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

时间复杂度：O(n)

空间复杂度：O(1) 固定大小的数组

五步曲太好用了！！！

复习支线开启💪