day50 | 123.买卖股票的最佳时机III、188.买卖股票的最佳时机IV

目录:

解题及思路学习

123.买卖股票的最佳时机III

https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iii/

给定一个数组,它的第 **i 个元素是一支给定的股票在第 i **天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。

**注意:**你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。

示例 1:

输入:prices = [3,3,5,0,0,3,1,4]
输出:6

思考:因为最多能完成两笔交易,所以可以用一个容器(栈或者队列)将每次买卖的利润存起来。先保存前两次买卖能赚的利润。后面只有当利润比其中一个大的时候,就弹出小的,并保存该利润。

随想录:关键在于至多买卖两次,这意味着可以买卖一次,可以买卖两次,也可以不买卖。

接来下我用动态规划五部曲详细分析一下:

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

    一天一共就有五个状态,

    1. 没有操作 (其实我们也可以不设置这个状态)
    2. 第一次持有股票
    3. 第一次不持有股票
    4. 第二次持有股票
    5. 第二次不持有股票

    dp[i][j]中 i表示第i天,j为 [0 - 4] 五个状态,dp[i][j]表示第i天状态j所剩最大现金。

    需要注意:dp[i][1],表示的是第i天,买入股票的状态,并不是说一定要第i天买入股票,这是很多同学容易陷入的误区

    例如 dp[i][1] ,并不是说 第i天一定买入股票,有可能 第 i-1天 就买入了,那么 dp[i][1] 延续买入股票的这个状态。

  2. 确定递推公式

    达到dp[i][1]状态,有两个具体操作:

    • 操作一:第i天买入股票了,那么dp[i][1] = dp[i-1][0] - prices[i]
    • 操作二:第i天没有操作,而是沿用前一天买入的状态,即:dp[i][1] = dp[i - 1][1]

    那么dp[i][1]究竟选 dp[i-1][0] - prices[i],还是dp[i - 1][1]呢?

    一定是选最大的,所以 dp[i][1] = max(dp[i-1][0] - prices[i], dp[i - 1][1]);

    同理dp[i][2]也有两个操作:

    • 操作一:第i天卖出股票了,那么dp[i][2] = dp[i - 1][1] + prices[i]
    • 操作二:第i天没有操作,沿用前一天卖出股票的状态,即:dp[i][2] = dp[i - 1][2]

    所以dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])

    同理可推出剩下状态部分:

    dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);

    dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);

  3. dp数组如何初始化

    第0天没有操作,这个最容易想到,就是0,即:dp[0][0] = 0;

    第0天做第一次买入的操作,dp[0][1] = -prices[0];

    第0天做第一次卖出的操作,这个初始值应该是多少呢?

    此时还没有买入,怎么就卖出呢? 其实大家可以理解当天买入,当天卖出,所以dp[0][2] = 0;

    第0天第二次买入操作,初始值应该是多少呢?应该不少同学疑惑,第一次还没买入呢,怎么初始化第二次买入呢?

    第二次买入依赖于第一次卖出的状态,其实相当于第0天第一次买入了,第一次卖出了,然后再买入一次(第二次买入),那么现在手头上没有现金,只要买入,现金就做相应的减少。

    所以第二次买入操作,初始化为:dp[0][3] = -prices[0];

    同理第二次卖出初始化dp[0][4] = 0;

  4. 确定遍历顺序

    从递归公式其实已经可以看出,一定是从前向后遍历,因为dp[i],依靠dp[i - 1]的数值。

  5. 举例推导dp数组

    以输入[1,2,3,4,5]为例

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tPzZqIG7-1689143254107)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/9bee3bde-0597-4b91-9e54-e6f608979bc9/Untitled.png)]

// 版本一
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() == 0) return 0;
        vector<vector<int>> dp(prices.size(), vector<int>(5, 0));
        dp[0][1] = -prices[0];
        dp[0][3] = -prices[0];
        for (int i = 1; i < prices.size(); i++) {
            dp[i][0] = dp[i - 1][0];
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
            dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
            dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
            dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
        }
        return dp[prices.size() - 1][4];
    }
};
  • 时间复杂度:O(n)
  • 空间复杂度:O(n × 5)

空间优化的写法:

// 版本二
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() == 0) return 0;
        vector<int> dp(5, 0);
        dp[1] = -prices[0];
        dp[3] = -prices[0];
        for (int i = 1; i < prices.size(); i++) {
            dp[1] = max(dp[1], dp[0] - prices[i]);
            dp[2] = max(dp[2], dp[1] + prices[i]);
            dp[3] = max(dp[3], dp[2] - prices[i]);
            dp[4] = max(dp[4], dp[3] + prices[i]);
        }
        return dp[4];
    }
};
  • 时间复杂度:O(n)
  • 空间复杂度:O(1)

188.买卖股票的最佳时机IV

https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iv/

给定一个整数数组 prices ,它的第 **i 个元素 prices[i] 是一支给定的股票在第 i **天的价格,和一个整型 k 。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。也就是说,你最多可以买 k 次,卖 k 次。

**注意:**你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。

示例 1:

输入:k = 2, prices = [2,4,1]
输出:2

思考:感觉这个贪心算法的思路挺好的,求每天的正利润。如果按照dp的思路,对于k次买卖,总共就有2k种状态。对于每一个内部的可以再组成一个循环。

随想录:

动规五部曲,分析如下:

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

    使用二维数组 dp[i][j] :第i天的状态为j,所剩下的最大现金是dp[i][j]

    j的状态表示为:

    • 0 表示不操作
    • 1 第一次买入
    • 2 第一次卖出
    • 3 第二次买入
    • 4 第二次卖出

    大家应该发现规律了吧 ,除了0以外,偶数就是卖出,奇数就是买入

    题目要求是至多有K笔交易,那么j的范围就定义为 2 * k + 1 就可以了。

  2. 确定递推公式

    还要强调一下:dp[i][1],表示的是第i天,买入股票的状态,并不是说一定要第i天买入股票,这是很多同学容易陷入的误区

    达到dp[i][1]状态,有两个具体操作:

    • 操作一:第i天买入股票了,那么dp[i][1] = dp[i - 1][0] - prices[i]
    • 操作二:第i天没有操作,而是沿用前一天买入的状态,即:dp[i][1] = dp[i - 1][1]

    选最大的,所以 dp[i][1] = max(dp[i - 1][0] - prices[i], dp[i - 1][1]);

    同理dp[i][2]也有两个操作:

    • 操作一:第i天卖出股票了,那么dp[i][2] = dp[i - 1][1] + prices[i]
    • 操作二:第i天没有操作,沿用前一天卖出股票的状态,即:dp[i][2] = dp[i - 1][2]

    所以dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])

  3. dp数组如何初始化

    第0天没有操作,这个最容易想到,就是0,即:dp[0][0] = 0;

    第0天做第一次买入的操作,dp[0][1] = -prices[0];

    第0天做第一次卖出的操作,这个初始值应该是多少呢?

    此时还没有买入,怎么就卖出呢? 其实大家可以理解当天买入,当天卖出,所以dp[0][2] = 0;

    第0天第二次买入操作,初始值应该是多少呢?应该不少同学疑惑,第一次还没买入呢,怎么初始化第二次买入呢?

    第二次买入依赖于第一次卖出的状态,其实相当于第0天第一次买入了,第一次卖出了,然后在买入一次(第二次买入),那么现在手头上没有现金,只要买入,现金就做相应的减少。

    所以第二次买入操作,初始化为:dp[0][3] = -prices[0];

    第二次卖出初始化dp[0][4] = 0;

    所以同理可以推出dp[0][j]当j为奇数的时候都初始化为 -prices[0]

  4. 确定遍历顺序

    从递归公式其实已经可以看出,一定是从前向后遍历,因为dp[i],依靠dp[i - 1]的数值。

  5. 举例推导dp数组

    以输入[1,2,3,4,5],k=2为例。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VxniD81u-1689143254111)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/7adc1ffd-4d76-44a2-b89e-ca4a3f107b19/Untitled.png)]

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {

        if (prices.size() == 0) return 0;
        vector<vector<int>> dp(prices.size(), vector<int>(2 * k + 1, 0));
        for (int j = 1; j < 2 * k; j += 2) {
            dp[0][j] = -prices[0];
        }
        for (int i = 1;i < prices.size(); i++) {
            for (int j = 0; j < 2 * k - 1; j += 2) {
                dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] - prices[i]);
                dp[i][j + 2] = max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i]);
            }
        }
        return dp[prices.size() - 1][2 * k];
    }
};
  • 时间复杂度: O(n * k),其中 n 为 prices 的长度
  • 空间复杂度: O(n * k)

主要是讲股票问题三种的代码给抽象出来。用k代替次数。

知识点记录

知识点

动态规划-股票问题。

股票问题是一个系列,每一天的股票可能有多个状态。套路都差不多。

个人反思

之前的模板没记住。

你可能感兴趣的:(C++,LeetCode,刷题,leetcode,算法,数据结构,动态规划,c++)