随想录一刷Day38——动态规划

Day38_动态规划

1. 动态规划理论基础

动态规划五步曲：

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

2. 斐波那契数

509. 斐波那契数
思路：

dp[i] = dp[i - 1] + dp[i - 2];

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

3. 爬楼梯

70. 爬楼梯
思路：

1. dp[i]表示到达第i层的方法数。
2. dp[i] = dp[i - 1] + dp[i - 2]
3. 初始化dp[1] = 1， dp[2] = 2
4. 要知道前两层的方法数，加起来等于第三层的方法数，所以要先知道前两层的方法数，故数据处理从前往后

方法一：
时间复杂度： $O(n)$
空间复杂度： $O(n)$

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

方法二：
时间复杂度： $O(n)$
空间复杂度： $O(1)$

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 2) return n;
        int dp_pre1 = 1, dp_pre2 = 2;
        int dp_now = 0;
        for (int i = 3; i <= n; ++i) {
            dp_now = dp_pre1 + dp_pre2;
            dp_pre1 = dp_pre2;
            dp_pre2 = dp_now;
        }
        return dp_now;
    }
};

4. 使用最小花费爬楼梯

746. 使用最小花费爬楼梯
思路：

1. dp[i]代表爬到第i层所花费的最小费用
2. dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])
   3.初始化，可以从第0层或第1层出发，故dp[0] = 0, dp[1] = 0
3. 由于每层的最小花费要用到前两层的最小花费，所以要从前往后处理

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