第九章动态规划part01

最新推荐文章于 2024-09-27 11:17:47 发布

C1aySec

最新推荐文章于 2024-09-27 11:17:47 发布

阅读量928

点赞数 22

分类专栏：代码随想录文章标签：动态规划算法 leetcode 数据结构 c++

本文链接：https://blog.csdn.net/a781333978/article/details/140647643

版权

代码随想录专栏收录该内容

43 篇文章 0 订阅

订阅专栏

斐波那契数

题目描述

斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1

给定 n ，请计算 F(n) 。

示例 1：

输入：n = 2
输出：1
解释：F(2) = F(1) + F(0) = 1 + 0 = 1

示例 2：

输入：n = 3
输出：2
解释：F(3) = F(2) + F(1) = 1 + 1 = 2

示例 3：

输入：n = 4
输出：3
解释：F(4) = F(3) + F(2) = 2 + 1 = 3

解题思路

确定dp数组以及下标的含义
- dp数组用于存储斐波那契数列的值，dp[i]表示第i个斐波那契数。因此，dp数组的大小为N + 1，其中N是输入的整数。
确定递推公式
- 根据题意可以直接得到递推公式为：dp[i]=dp[i−1]+dp[i−2]

dp数组初始化

根据题意可以对dp数组进行初始化：

dp[0] = 0; // 第0个斐波那契数
dp[1] = 1; // 第1个斐波那契数

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

举例推导dp数组

当N为10的时候，根据上述递推公式，可以得出dp数组为：0 1 1 2 3 5 8 13 21 34 55，如果最终代码返回的值和手动推导的不一致，可以手动打印一下dp数组，然后再分析是哪块出了问题：

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

dp数组打印情况如下，和手动推导的一致，说明没有问题：

代码实现

测试地址：https://leetcode.cn/problems/fibonacci-number/

class Solution {
public:
    int fib(int n) {
        // 如果 n 小于等于 1，直接返回 n
        if (n <= 1) {
            return n;
        }
  
        // 创建一个大小为 n+1 的动态数组 dp 来存储斐波那契数列
        vector<int> dp(n + 1);
  
        // 初始化斐波那契数列的前两个数
        dp[0] = 0; // 第 0 个斐波那契数是 0
        dp[1] = 1; // 第 1 个斐波那契数是 1
  
        // 从第 2 个数开始，计算到第 n 个数
        for (int i = 2; i <= n; i++) {
            // 每个数是前两个数的和
            dp[i] = dp[i - 1] + dp[i - 2];
        }
  
        // 返回第 n 个斐波那契数
        return dp[n];
    }
};

因为我们不需要维护一整个斐波那契数列，而是只需要得到第n个数的斐波那契数，因此可以对上述代码进行压缩：

class Solution {
public:
    int fib(int n) {
        // 如果 n 小于等于 1，直接返回 n
        if (n <= 1) {
            return n;
        }
  
        // 使用两个变量来存储斐波那契数列的前两个数
        int dp[2];
        dp[0] = 0; // 第 0 个斐波那契数是 0
        dp[1] = 1; // 第 1 个斐波那契数是 1
  
        // 从第 2 个数开始，计算到第 n 个数
        for (int i = 2; i <= n; i++) {
            // 计算当前的斐波那契数
            int sum = dp[0] + dp[1];
            // 更新前两个斐波那契数
            dp[0] = dp[1];
            dp[1] = sum;
        }
  
        // 返回第 n 个斐波那契数
        return dp[1];
    }
};

爬楼梯

题目描述

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

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

示例 1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶

示例 2：

输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

解题思路

确定dp数组以及下标的含义
- dp[i]：爬到第i层楼梯，共有dp[i]种方法
确定递推公式
- 分析题意可知，爬楼梯一次只能爬1层或者2层，因此爬到第一层只有一种方法，爬到第二层有2种方法，那么如果要爬到第三层，可以先爬到第一层，然后再爬两层到第三层，也可以先爬到第二层，然后再爬一层到第三层，因此爬到第三层的方法实际上依赖于爬到第一层的方法 + 爬到第二层的方法，因此可以得到递推公式：dp[i] = dp[i-1] + dp[i-2]
dp数组初始化
- 根据提示可以得知，n 的值为正整数，因此在初始化的时候没有必要管 dp[0]，直接对dp[1] 和 dp[2] 进行初始化即可。
确定遍历顺序
- 根据递归公式可以得知，dp[i] 依赖于 dp[i-1] 和 dp[i-2]，因此遍历方向是从左往右
举例推导dp数组
- 当 n = 5 的时候，通过手推递推数组的值应该为：[1,2,3,5,8]，如果代码存在问题，可以将dp数组打印下来，看看是否和手推的一致。

代码实现

测试地址：https://leetcode.cn/problems/climbing-stairs/

class Solution {
public:
    int climbStairs(int n) {
        // 如果n小于等于1，直接返回n，因为只有一种方法
        if (n <= 1) return n;
  
        // 创建一个大小为n+1的动态数组dp来存储每阶楼梯的方法数
        vector<int> dp(n + 1);
  
        // 初始化前两阶楼梯的方法数
        dp[1] = 1; // 爬到第1阶只有一种方法
        dp[2] = 2; // 爬到第2阶有两种方法（一步一步或直接两步）
  
        // 从第3阶开始，计算到第n阶的方法数
        for (int i = 3; i <= n; i++) {
            // 第i阶的方法数等于第i-1阶和第i-2阶方法数的和
            dp[i] = dp[i - 1] + dp[i - 2];
        }
  
        // 返回爬到第n阶的方法数
        return dp[n];
    }
};

对上述代码进行空间优化：

class Solution {
public:
    int climbStairs(int n) {
        // 如果n小于等于1，直接返回n，因为只有一种方法
        if (n <= 1) return n;
  
        // 使用一个大小为3的数组dp来存储当前和前两个楼梯的方法数
        int dp[3];
  
        // 初始化前两阶楼梯的方法数
        dp[1] = 1; // 爬到第1阶只有一种方法
        dp[2] = 2; // 爬到第2阶有两种方法（一步一步或直接两步）
  
        // 从第3阶开始，计算到第n阶的方法数
        for (int i = 3; i <= n; i++) {
            // 计算当前阶的方法数，即前两阶方法数的和
            int sum = dp[1] + dp[2];
      
            // 更新前两个楼梯的方法数
            dp[1] = dp[2];
            dp[2] = sum;
        }
  
        // 返回爬到第n阶的方法数
        return dp[2];
    }
};

使用最小花费爬楼梯

题目描述

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

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

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

示例 1：

输入：cost = [10,15,20]
输出：15
解释：你将从下标为 1 的台阶开始。
- 支付 15 ，向上爬两个台阶，到达楼梯顶部。
总花费为 15 。

示例 2：

输入：cost = [1,100,1,1,1,100,1,1,100,1]
输出：6
解释：你将从下标为 0 的台阶开始。
- 支付 1 ，向上爬两个台阶，到达下标为 2 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 4 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 6 的台阶。
- 支付 1 ，向上爬一个台阶，到达下标为 7 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 9 的台阶。
- 支付 1 ，向上爬一个台阶，到达楼梯顶部。
总花费为 6 。

解题思路

确定dp数组以及下标的含义
- dp[i]表示要到达第i层所需要花费的最小花费
确定递推公式
- 根据题意可知，可以从第0层和第一层开始，每次向上可以爬一层或者两层楼梯，因此爬到第二层的最小花费依赖于从第0层开始爬2层的花费加上从第1层开始爬1层的花费的最小值，因此可以得到递推公式：dp[i] = min(dp[i-2]+cost[i-2],dp[i-1]+cost[i-1])
dp数组初始化
- 因为到达第0层和第一层是不需要花费的，因此初始化为：dp[0] = 0, dp[1] = 0
确定遍历顺序
- 根据递推式可以发现，dp[i] 依赖于 dp[i-1]和dp[i-2]，因此遍历顺序为从左往右
举例推导dp数组
- 拿示例2：cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1] ，来模拟一下dp数组的状态变化，如下：

代码实现

测试地址：https://leetcode.cn/problems/min-cost-climbing-stairs/

class Solution {
public:
    int minCostClimbingStairs(vector<int> &cost) {
        // 创建一个大小为cost.size() + 1的动态数组dp来存储到达每一阶的最小花费
        vector<int> dp(cost.size() + 1);
  
        // 初始化前两阶楼梯的最小花费
        dp[0] = 0; // 到达第0阶的最小花费为0
        dp[1] = 0; // 到达第1阶的最小花费为0
  
        // 从第2阶开始，计算到达每一阶的最小花费
        for (int i = 2; i <= cost.size(); i++) {
            // 到达第i阶的最小花费是以下两种情况的最小值：
            // 1. 从前一阶（i-1）跳上来，花费为dp[i-1] + cost[i-1]
            // 2. 从前两阶（i-2）跳上来，花费为dp[i-2] + cost[i-2]
            dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
        }
  
        // 返回到达楼梯顶部的最小花费
        return dp[cost.size()];
    }
};

优化空间后的代码如下：

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        // 初始化前两阶楼梯的最小花费
        int dp0 = 0; // 到达第0阶的最小花费为0
        int dp1 = 0; // 到达第1阶的最小花费为0
  
        // 从第2阶开始，计算到达每一阶的最小花费
        for (int i = 2; i <= cost.size(); i++) {
            // 计算到达第i阶的最小花费
            // 选择从前一阶（i-1）跳上来或从前两阶（i-2）跳上来，取最小值
            int dpi = min(dp1 + cost[i - 1], dp0 + cost[i - 2]);
      
            // 更新前两阶的最小花费
            dp0 = dp1; // 更新dp0为前一阶的最小花费
            dp1 = dpi; // 更新dp1为当前阶的最小花费
        }
  
        // 返回到达楼梯顶部的最小花费
        return dp1;
    }
};