代码随想录算法训练营第三十八天| 动态规划理论基础 509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯

代码随想录算法训练营第三十八天| 动态规划理论基础 509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯

LeetCode 509 斐波那契数

题目链接: 509.斐波那契数

动规五部曲：

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

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

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

• 确定递推公式

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

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

• dp数组如何初始化

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

• 确定遍历顺序

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

• 举例推导dp数组

按照这个递推公式dp[i] = dp[i - 1] + dp[i - 2]，我们来推导一下，当N为10的时候，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 < 2) return n;
        return fib(n - 1) + fib(n - 2);
    }
};

LeetCode 70 爬楼梯

题目链接: 70.爬楼梯

思路：

动规五部曲：

定义一个一维数组来记录不同楼层的状态

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

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

• 确定递推公式

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

• dp数组如何初始化

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

那么i为0，dp[i]应该是多少呢。

应该认为跑到第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，然后从i = 3开始递推，这样才符合dp[i]的定义。

• 确定遍历顺序

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

• 举例推导dp数组

整体代码：

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 1) return n; // 因为下面直接对dp[2]操作了，防止空指针
        vector<int> dp(n + 1);
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) { // 注意i是从3开始的
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
};

LeetCode 746 使用最小花费爬楼梯

题目链接: 746.使用最小花费爬楼梯

思路：

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

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

dp[i]的定义：到达第i台阶所花费的最少体力为dp[i]。

• 确定递推公式

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

dp[i - 1] 跳到 dp[i] 需要花费 dp[i - 1] + cost[i - 1]。

dp[i - 2] 跳到 dp[i] 需要花费 dp[i - 2] + cost[i - 2]。

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

• dp数组如何初始化

所以初始化 dp[0] = 0，dp[1] = 0;

• 确定遍历顺序

本题的遍历顺序其实比较简单，而且dp[i]由dp[i-1]dp[i-2]推出，所以是从前到后遍历cost数组就可以了。

• 举例推导dp数组

整体代码：

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