【Day38】代码随想录之动态规划part1——动态规划理论基础、斐波那契数、爬楼梯

今天开始动态规划的章节，差不多最后一章了，加油！！！

今日任务：

• 动态规划理论讲解
• 509.斐波那契数
• 70.爬楼梯
• 746.使用最小花费爬楼梯

动态规划理论基础

1、动规问题：

动态规划可解决的题目类型：

动态规划，英文：Dynamic Programming，简称DP，如果某一问题有很多重叠子问题，那么使用动态规划是最有效的。所以动态规划中每一个状态一定是由上一个状态推导出来的，这一点有区别与贪心，贪心没有状态推导，而是从局部中直接选取最优的。

动规是由前一个状态推导出来的，而贪心是局部中直接选取最优的，对于刷题来说足够了。

2、动态规划五部曲（非常重要）

状态转移公式很重要，但是动态规划中不仅仅只有递推公式。对于动态规划，可以拆分为五部曲：
（1）确定dp数组以及下标的含义；
（2）确定递推公式；
（3）考虑dp数组如何初始化；
（4）确定遍历顺序；
（5）举例推导dp数组

3、动态规划应该如何debug?

（1）找问题的最好方式就是把dp数组打印出来，看看究竟是不是按照自己思路推导的；
（2）在做动规的题目，写代码之前一定要把状态转移在dp数组上具体情况模拟一遍，心中有数，确定最后退出来的是想要的结果；
（3）如果没通过就打印dp数组，在遇到问题之前应该首先思考下面3个问题：

• 这道题目距离推导状态转移方程了吗？
• 打印出dp数组了吗？
• 打印出来的dp数组和自己想的一样吗

题目一：509.斐波那契数

Leetcode题目：【509.斐波那契数】
参考：【代码随想录之斐波那契数】

按照动态规划五部曲来分析：
（1）确定dp[i]的含义，dp[i]表示是第i个斐波那契数；
（2）递推公式：dp[i] = dp[i-1] + dp[i-2];
（3）dp数组如何初始化：dp[0] = 0，dp[1] = 1;
（4）遍历顺序：从前往后；
（5）打印dp数组

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

题目二：70.爬楼梯

Leetcode题目：【70.爬楼梯】
参考：【代码随想录之爬楼梯】

此题爬楼梯看起来优点负责，其实只需要分解：因为题目中告诉我们有两种爬楼梯的方式：可以1步也可以2步，那么可以这样确定dp[i]：
（1）假设dp[i-1]表示上了i-1层楼梯，那再上一层楼梯就是dp[i]了；
（2）假设dp[i-2]表示上了i-2层楼梯，那么再一步跳两个台阶就可以了。
那么dp[i] = dp[i-1] + dp[i-2]。
因此可以按照递归五部曲考虑：
（1）确定dp数组以及下标的含义：dp[i]：表示爬到第i层，有dp[i]种方法；
（2）确定递推公式：从dp[i]的定义上，dp[i]可以看出，有两个方向，dp[i-1] 和dp[i-2]；
（3）dp数组初始化：
dp[0]=1，dp[1] = 1, dp[2] = 2，递推可以考虑从i=3开始
（4）确定遍历顺序：从前往后遍历
（5）举例推导dp数组：
n = 5;
dp[0] = 1, dp[1] = 1, dp[2] = 2, dp[3] = 3, dp[4] = 5, dp[5] = 8;

正确代码（与斐波那契数列很像）：

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

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

Leetcode题目：【746.使用最小花费爬楼梯】
参考：【代码随想录之使用最小花费爬楼梯】

按照动态规划五部曲：
（1）确定dp数组以及下标的含义：dp[i]表示到达第i个台阶的最小花费；
（2）确定递推公式：
对于dp[i]有两种方法：
dp[i] = dp[i-1] + cost[i-1];
dp[i] = dp[i-2] + cost[i-2];
dp[i] = min{dp[i-1] + cost[i-1]， dp[i-2] + cost[i-2]}
（3）dp数组的初始化：
dp[0] = 0, dp[1] = 0；
（4）确定遍历顺序：从左到右
（5）dp数组距离说明：

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