代码随想录38——动态规划：动态规划理论基础、509斐波那契数列、70爬楼梯、746使用最小花费爬楼梯

0.动态规划理论基础

参考：代码随想录，动态规划理论基础

0.1.什么是动态规划

动态规划，英文：Dynamic Programming，简称DP，如果某一问题有很多重叠子问题，使用动态规划是最有效的。

所以动态规划中每一个状态一定是由上一个状态推导出来的，这一点就区分于贪心，贪心没有状态推导，而是从局部直接选最优的，

0.2.动态规划解题步骤

状态转移公式（递推公式）是很重要，但动规不仅仅只有递推公式。

对于动态规划问题，我将拆解为如下五步曲，这五步都搞清楚了，才能说把动态规划真的掌握了！

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

一些同学可能想为什么要先确定递推公式，然后在考虑初始化呢？

因为一些情况是递推公式决定了dp数组要如何初始化！

1.509斐波那契数列

参考：代码随想录，509斐波那契数列；力扣题目链接

1.1.题目

1.2.解答

动规五部曲：

这里我们要用一个一维dp数组来保存递归的结果

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

dp[i]的定义为：第i个数的斐波那契数值是dp[i]

2.确定递推公式

为什么这是一道非常简单的入门题目呢？

因为题目已经把递推公式直接给我们了：状态转移方程 dp[i] = dp[i - 1] + dp[i - 2];

3.dp数组如何初始化

题目中把如何初始化也直接给我们了，如下：

dp[0] = 0;
dp[1] = 1;
1
2

4.确定遍历顺序

从递归公式dp[i] = dp[i - 1] + dp[i - 2];中可以看出，dp[i]是依赖 dp[i - 1] 和 dp[i - 2]，那么遍历的顺序一定是从前到后遍历的

5.举例推导dp数组

按照这个递推公式dp[i] = dp[i - 1] + dp[i - 2]，我们来推导一下，当N为10的时候，dp数组应该是如下的数列：

0 1 1 2 3 5 8 13 21 34 55
1

如果代码写出来，发现结果不对，就把dp数组打印出来看看和我们推导的数列是不是一致的。

最后给出代码，非常简单：

int fib(int n)
{
    // 0,1 的情况，直接返回结果
    if(n < 2)
        return n;
    vector<int> dp(n+1);  // 注意长度是n+1
    dp[0] = 0;  // dp初始化
    dp[1] = 1;
    // 从前向后遍历
    for(int i = 2; i <= n; i++)
    {
        dp[i] = dp[i-1] + dp[i-2];  // 递推公式
    }

    return dp[n];
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.70爬楼梯

参考：代码随想录，70爬楼梯；力扣题目链接

2.1.题目

2.2.解答

举几个例子，就可以发现其规律：

• 爬到第一层楼梯有1种方法，爬到二层楼梯有2种方法。

• 那么第一层楼梯再跨两步就到第三层 ，第二层楼梯再跨一步就到第三层。所以到第三层楼梯的状态可以由第二层楼梯 和 到第一层楼梯状态推导出来，那么就可以想到动态规划了。

动规五部曲：

1.定义一个一维数组来记录不同楼层的状态，即确定dp数组以及下标的含义

dp[i]： 爬到第i层楼梯，有dp[i]种方法

2.确定递推公式

从dp[i]的定义可以看出，dp[i] 可以有两个方法推出来。

• 首先是dp[i - 1]，上i-1层楼梯，有dp[i - 1]种方法，那么再一步跳一个台阶就是dp[i]了。

• 还有就是dp[i - 2]，上i-2层楼梯，有dp[i - 2]种方法，那么再一步跳两个台阶就是dp[i]了。

那么dp[i]就是 dp[i - 1]与dp[i - 2]之和！所以dp[i] = dp[i - 1] + dp[i - 2] 。

3.dp数组如何初始化

在回顾一下dp[i]的定义：爬到第i层楼梯，有dp[i]中方法。

那么i为0，dp[i]应该是多少呢，这个可以有很多解释，但都基本是直接奔着答案去解释的。

例如强行安慰自己爬到第0层，也有一种方法，什么都不做也就是一种方法即：dp[0] = 1，相当于直接站在楼顶。

但总有点牵强的成分。

那还这么理解呢：我就认为跑到第0层，方法就是0啊，一步只能走一个台阶或者两个台阶，然而楼层是0，直接站楼顶上了，就是不用方法，dp[0]就应该是0.

其实这么争论下去没有意义，大部分解释说dp[0]应该为1的理由其实是因为dp[0]=1的话在递推的过程中i从2开始遍历本题就能过，然后就往结果上靠去解释dp[0] = 1。

从dp数组定义的角度上来说，dp[0] = 0 也能说得通。

需要注意的是：题目中说了n是一个正整数，题目根本就没说n有为0的情况。

所以本题其实就不应该讨论dp[0]的初始化！

我相信dp[1] = 1，dp[2] = 2，这个初始化大家应该都没有争议的。

所以我的原则是：不考虑dp[0]如果初始化，只初始化dp[1] = 1，dp[2] = 2，然后从i = 3开始递推，这样才符合dp[i]的定义。

4.确定遍历顺序

从递推公式dp[i] = dp[i - 1] + dp[i - 2];中可以看出，遍历顺序一定是从前向后遍历的

5.举例推导dp数组

举例当n为5的时候，dp table（dp数组）应该是这样的：

给出代码如下，其实可以发现和斐波那契数列是一样的，只不过这里我们要根据具体的题目来推导出dp数组的递推公式和初始化值。

int climbStairs(int n)
{
    // 1层楼，就是1步；2层楼就是2步
    if(n < 3)
        return n;

    vector<int> dp(n+1);
    dp[1] = 1;  // dp数组初始化
    dp[2] = 2;
    // 从前向后遍历
    for(int i = 3; i <=n; i++)
    {
        dp[i] = dp[i-1] + dp[i-2];  // 递推公式
    }
    
    return dp[n];
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.746使用最小花费爬楼梯

参考：代码随想录，746使用最小花费爬楼梯；力扣题目链接

3.1.题目

3.2.解答

注意：

• 题目中说的楼梯顶是指代跳出数组，也就是数组索引为cost.size()的位置，此时刚好在最后一个楼梯的下一个位置，这才叫楼梯顶。所以如果一次只能跳一步或者两步的话，最后的位置可以选择从倒数第二个楼梯cost.size()-2跳两步到楼梯顶或者倒数第一个楼梯cost.size()-1跳一步到楼梯顶。

• 注意题目描述：每当你爬上一个阶梯你都要花费对应的体力值，一旦支付了相应的体力值，你就可以选择向上爬一个阶梯或者爬两个阶梯。代码随想录中写的最后一步没有花费，其实很容易误导人，实际上由于楼梯顶是出了数组的，所以数组中的每一个楼梯都需要往后跳，也就是其实每一个楼梯都是有花费的，最后两个楼梯也是有花费的。

动归五部曲：

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

使用动态规划，就要有一个数组来记录状态，本题只需要一个一维数组dp[i]就可以了。

dp[i]的定义：到达第i个台阶所花费的最少体力为dp[i]。（注意这里认为是第一步一定是要花费）

2.确定递推公式

可以有两个途径得到dp[i]，一个是dp[i-1] 一个是dp[i-2]。

那么究竟是选dp[i-1]还是dp[i-2]呢？

一定是选最小的，所以dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];

注意这里为什么是加cost[i]，而不是cost[i-1],cost[i-2]之类的，因为题目中说了：每当你爬上一个阶梯你都要花费对应的体力值

3.dp数组如何初始化

那么看一下递归公式，dp[i]由dp[i-1]，dp[i-2]推出，那么只初始化dp[0]和dp[1]就够了，其他的最终都是dp[0]、dp[1]推出。

所以初始化代码为：

vector<int> dp(cost.size());
dp[0] = cost[0];
dp[1] = cost[1];
1
2
3

4.确定遍历顺序

因为是模拟台阶，而且dp[i]由dp[i-1]dp[i-2]推出，所以是从前到后遍历cost数组就可以了。

5.举例推导dp数组

拿示例2：cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1] ，来模拟一下dp数组的状态变化，如下：
最后给出代码如下：

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()-2], dp[cost.size()-1]);
}
1
2
3
4
5
6
7
8
9
10
11
12
13