DAY38：动态规划理论基础+入门509、70、746

理论基础

动态规划：一个问题有很多重叠子问题，每一个状态由i上一个状态推导出来。

基本流程

• 确定dp数组已经下标的含义
• 确定递推公式
• 初始化dp数组
• 确定遍历顺序
• 距离推导dp数组

写代码之前一定要把状态转移在dp数组上的具体情况模拟一遍，心中有数才能写出正确的代码。

Leetcode: 509 斐波那契数

作为动态规划专题的入门，完整写一遍流程。

1、确顶下标和含义：第i个数的斐波那契数值是dp[i]

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

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

4、确定遍历顺序，从前向后遍历

5、推导一下

class Solution {
public:
    int fib(int n) {
        if(n <= 1) 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] + dp[0];

    }
};
//时间复杂度O(N)，空间复杂度O(N)

Leetcode: 70 爬楼梯

如果第i个台阶，到第i-1的时候只需要上一个，到i-2的时候上2个台阶，那样状态函数还是斐波拉契数列，第i-2状态的时候的走法加上第i-1个状态的时候的走法。

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];
    }
};

Leetcode: 746 使用最小花费爬楼梯

一个很好的方法就是往前推导，如果是最后一步了，那往前肯定选的是最小cost的dp。dp的更新就是每次选择最小的损失

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

    }
};