《录鼎记》——动态规划part1

今日任务：

    理论基础

• 509. 斐波那契数

• 70. 爬楼梯

• 746. 使用最小花费爬楼梯

一、理论基础

动态规划的要点是每一个状态都是由上一个状态推导出来的，这同时也区分于贪心。

动态规划好的一点在哪呢，他有大致的步骤：动态规划五部曲。

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

二、斐波那契数

力扣题目链接 (opens new window)

我们就就着东归五部曲来做：

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

dp[i]的含义是：第i个斐波那契数是dp[i]

2、确定递推公式

斐波那契数列的状态转移方程是dp[i]=dp[i-1]+dp[i-2];

3、dp数组如何初始化，由于状态方程中的数值是基于前两个数值，所以第一个和第二个元素要单独初始化，dp[0]=0,dp[1]=1;

4、确定遍历顺序，由于依赖前面的两个数值，所以一定是从前向后遍历。

5、举例推导dp数组

从前向后分别是：0，1，1，2，3，5，8，13，21，34，55.……

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

        }
        return dp[n];


    }
};

但其实也没必要维护那么多数值，只要动态改变前两个数值即可。

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


    }
};

但这题如果用递归就两行

class Solution {
public:
    int fib(int n) {
        if(n<2) return n;
        return fib(n-1) +fib(n-2);

    }
};

三、爬楼梯

力扣题目链接 (opens new window)

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

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

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

这道题没给递推公式，但是从题目中可以显而易见的看出来：

dp[n]=dp[n-1]+dp[n-2]

为什么呢，我们到达一个点的方法只有两种，一种是从它的上一个台阶，一种是从它的上两个台阶。

所以这题和斐波那契数列的唯一区别是dp[0]没有意义。

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

    }
};

这是优化空间后的写法，也可以去维护整个数组来写。

四、使用最小花费爬楼梯

力扣题目链接 (opens new window)

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

请你计算并返回达到楼梯顶部的最低花费。

这里的dp[i]就有那么一点讲究：

由于要找最小值，dp[i]=min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]

这里我们的dp[i]是由之前的元素产生的，所以我们的遍历顺序依然还是从前到后遍历。

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

            dp0=dp1;
            dp1 =dpi;

        }
        return dp1;

    }
};

这里还卡的蛮久的，因为没搞清楚应不应该到最后一项。