买卖股票最佳时机专题

最新推荐文章于 2024-06-12 18:28:23 发布
最新推荐文章于 2024-06-12 18:28:23 发布
阅读量63 收藏
点赞数
文章标签： c++ 算法 数据结构 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liutao_1/article/details/131842061
版权

1.仅一次买卖

121. 买卖股票的最佳时机

需要定义一个二维数组dp来保存状态，每一层需要两个元素来保存状态。dp[i] [0] 保存不持有股票状态， dp[i] [1] 表示持有股票状态

动规五部曲

1.确认dp数组下标含义

dp[i] [0] 表示第i天持有股票所得最多现金, dp[i] [1]表示第i天不持有股票所得最多现金

​

2.递推公式

1):第i天持有股票(dp[i] [0])

​ a:在第i-1天也持有股票：dp[i] [0] = dp[i-1] [0]

​ b:在第i天开始持有股票：dp[i] [0] = dp[i-1] [1]-prices[i]

​ dp[i] [0] = max(dp[i - 1] [0], dp[i-1] [1]-prices[i])

2):第i天不持有股票(dp[i] [1])

​ a:在第i-1天没有持有股票：dp[i] [1] = dp[i-1] [1]

​ b:在第i天没有持有股票: dp[i] [1] = dp[i-1] [0] + prices[i]

​ dp[i] [1] = max(dp[i - 1] [1], prices[i] + dp[i - 1] [0])

3.初始化

​ dp[0] [0] = -prices[0], dp[0] [1] = 0

4.从前到后
5.打印

代码

/***
 * @Description:一次买卖股票
 * @Author: LeoTao
 * @Date: 2023-07-13 09:42:08
 * @LastEditTime: 2023-07-13 10:12:48
 */

#include <iostream>
#include <vector>
using namespace std;

class Solution {
   public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() == 0) {
            return 0;
        }
        vector<vector<int>> dp(2, vector<int>(2));
        dp[0][0] = -prices[0];
        dp[0][1] = 0;

        for (int i = 1; i < prices.size(); i++) {
            dp[i % 2][0] = max(dp[(i - 1) % 2][0], -prices[i]);
            dp[i % 2][1] =
                max(dp[(i - 1) % 2][1], prices[i] + dp[(i - 1) % 2][0]);
        }
        return dp[(prices.size() - 1) % 2][1];
    }
};

总结

​ 本题最重要的是分两种状态，需要二维dp数组来保存状态。每种状态都有两种推导方式，取其中的最大值。

2.多次买卖

122. 买卖股票的最佳时机 II

多次买卖和一次买卖的区别只有一个：

推导dp[i] [0]在第i天持有股票状态的时候，可能在前面几天会有剩余的利润。在第i天开始持有股票：dp[i] [0] = dp[i-1] [1]-prices[i]

一次买卖时，第i天持有的时候前几天的利润一定是0，只有这一个区别，其他相同

在遍历的时候，只需要将dp[i] [0] 的状态推导做出调整即可。

代码：

#include <iostream>
#include <vector>
using namespace std;

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        /*
            1.dp[i][0] 表示第i天持有股票所得最多现金, dp[i][1]表示第i天不持有股票所得最多现金 
            
            2.递推 1):第i天持有股票(dp[i][0])
                    a:在第i-1天也持有股票：dp[i][0] = dp[i-1][0]
                    b:在第i天开始持有股票：dp[i][0] = dp[i-1][1]-prices[i]
                    dp[i][0] = max(dp[i - 1][0], dp[i-1][1]-prices[i])

                2):第i天不持有股票(dp[i][1])
                    a:在第i-1天没有持有股票：dp[i][1] = dp[i-1][1]
                    b:在第i天没有持有股票: dp[i][1] = dp[i-1][0] + prices[i]
                    dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0])

            3.初始化
                dp[0][0] = -proces[0], dp[0][1] = 0
            4.从前到后
            5.打印
        */
        int len = prices.size();
        vector<vector<int>> dp(len, vector<int>(2, 0));
        dp[0][0] -= prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; i++) {
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]); // 注意这里是和121. 买卖股票的最佳时机唯一不同的地方。
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
        }
        return dp[len - 1][1];
    }
};

3.限制交易次数（最多完成两笔交易）

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

最多两笔交易的时候，一天就会有五种状态，分状态去讨论。

动规五部曲

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

一天一共就有五个状态，

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

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

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.初始化

第0天没有买入：dp[0] [0] = 0

第0天做第一次买入：dp[0] [1] = - price[0]

第0天做第一次卖出：看作当天买入卖出：dp[0] [2] = 0;

第0天做第二次买入： dp[0] [3] = -price[0]

第0天做第二次卖出： dp[0] [4] = 0

4.遍历顺序：从前到后
5.打印dp数组

代码

#include <iostream>
#include <vector>
using namespace std;
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size() == 0){
            return 0;
        }
        
        vector<vector<int>> dp(prices.size(), vector<int>(5));//每一层有五种状态
        dp[0][0] = dp[0][2] = dp[0][4] = 0;
        dp[0][1] = 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 max(dp[prices.size()-1][2] ,dp[prices.size()-1][4]);//可能一次交易就能得到最大利润
    }
};

总结

由于最多完成两笔交易，一天最多只有5个状态，所以我们可以通过枚举状态来实现求最大利润。

最后要注意，最多两笔交易可能是只有一笔交易，可能一笔都没有，可能是两笔，不能直接返回卖完两次的利润。

4.限制交易次数（最多完成k笔交易）

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

完成k笔交易，就不能一个一个枚举了。在上一道题目我们可以得知，除0之外，偶数是卖出，奇数是买入。那么可以将这k笔交易抽象出奇偶分别，通过循环对每次状态赋值或转换。由上一道题可以推导，k笔交易需要2 * k + 1个范围来记录状态。

动规五部曲

1.确认dp数组下标含义

二维数组 dp[i] [j] ：第i天的状态为j，所剩下的最大现金是dp[i] [j]

j的值

0：不做操作

奇数：买入

偶数：卖出

2.递推公式
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]);//不持有状态
}
3.初始化

只需要将奇数状态设置为-prices[0]

for(int j = 1; j < 2 * k + 1; j += 2){
	dp[0][j] = -prices[0];
}
4.遍历顺序

从前到后

5.打印dp数组

代码

/***
 * @Description:最多k次交易
 * @Author: LeoTao
 * @Date: 2023-07-13 15:24:37
 * @LastEditTime: 2023-07-13 15:24:48
 */
#include <iostream>
#include <vector>
using namespace std;

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        if(prices.size() == 0){
            return 0;
        }

        int times = 2 * k + 1;

        vector<vector<int>> dp(prices.size(), vector<int>(times, 0));
        for(int i = 1; i < times; i += 2){
            dp[0][i] = -prices[0];
        }

        for(int i = 1; i < prices.size(); i++){
            for(int j = 0; j < times - 2; 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];
    }
};

总结：

将k笔交易的状态抽象成奇偶状态，偶数卖出，奇数买入。最后遍历的时候，要注意遍历的边界条件，因为包含了j+2这个状态，上面的范围要相应的减去2.

5.包含冷冻期

卖出股票之后无法在第二天买入，不持有的时候又多了一种状态，再加上冷冻期一个状态。

动规五部曲

1.确认dp数组下标含义

dp[i] [j]，第i天状态为j，所剩的最多现金为dp[i] [j]。

具体可以分为四个状态：

  • 状态一：持有股票状态（今天买入股票，或者是之前就买入了股票然后没有操作，一直持有）
  • 不持有股票状态，这里就有两种卖出股票状态
    • 状态二：保持卖出股票的状态（两天前就卖出了股票，度过一天冷冻期。或者是前一天就是卖出股票状态，一直没操作）
    • 状态三：今天卖出股票
  • 状态四：今天为冷冻期状态，但冷冻期状态不可持续，只有一天！

用四个维度来保存对应的四个状态

2.递推公式

状态一：dp[i] [0]持有股票状态

  • 前一天就持有股票，dp[i] [0] = dp[i-1] [0]
  • 在第i天买入股票
    • 前一天是冷冻期(状态四)：dp[i] [0] = dp[i - 1] - prices[i]
    • 前一天是保持卖出的状态（状态二）： dp[i] [0] = dp[i-1] [1] -prices[i]
dp[i] [0] = max(dp[i - 1] [0], dp[i - 1] [3] - prices[i], dp[i - 1] [1] - prices[i]);

状态二：dp[i] [1] 保持卖出股票状态

  • 前一天就是不持有股票状态：dp[i] [1] = dp[i-1] [1]
  • 前一天是冷冻期：dp[i] [1] = dp[i-1] [3]
dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);

状态三：dp[i] [2] 达到今天就卖出股票状态

dp[i][2] = dp[i-1][0] + prices[i]

状态四：dp[i] [3] 冷冻期

冷冻期和前一天卖出股票的状态保持一致

dp[i][3] = dp[i-1][2]
3.初始化

dp[0] [0] = -prices[0];

4.遍历顺序

从前到后

5.打印dp数组

代码

#include <iostream>
#include <vector>
using namespace std;

class Solution {
   public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() == 0) {
            return 0;
        }
        vector<vector<int>> dp(prices.size(), vector<int>(4, 0));
        dp[0][0] = -prices[0];

        for (int i = 1; i < prices.size(); i++) {
            dp[i][0] =
                max(dp[i - 1][0], max(dp[i - 1][3], dp[i - 1][1]) - prices[i]);
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
            dp[i][2] = dp[i - 1][0] + prices[i];
            dp[i][3] = dp[i - 1][2];
        }

        return max(dp[prices.size() - 1][3],
                   max(dp[prices.size() - 1][1], dp[prices.size() - 1][2]));
    }
};

总结

包含冷冻期之后，状态变得复杂，这里将当天买入和之前持有两种持有状态分开讨论

6.包含手续费

类似于多次买卖，只需要在卖出时支付手续费

#include <iostream>
#include <vector>
using namespace std;

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(2, 0));
        dp[0][0] -= prices[0]; // 持股票
        for (int i = 1; i < n; i++) {
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);
        }
        return max(dp[n - 1][0], dp[n - 1][1]);
    }
};
LeoTao7
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法训练Day49 | Leetcode121. 买卖股票的最佳时机（只能买卖一次）；LeetCode122. 买卖股票的最佳时机II（可以买卖多次）
weixin_47284299的博客
11-09 1153
算法训练Day49 | Leetcode121. 买卖股票的最佳时机（只能买卖一次）；LeetCode122. 买卖股票的最佳时机II（可以买卖多次）
买卖股票的最佳时机三
01-20
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。 注意: 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 ...
动态规划-买卖股票的最佳时机 专题
m0_62571154的博客
01-25 129
动态规划-买卖股票的最佳时机 专题
C++力扣题目 121--买卖股票的最佳时机 122-- 买卖股票的最佳时机II 123--买卖股票的最佳时机III 188--买卖股票的最佳时机IV
weixin_47675625的博客
02-21 867
如果dp[1]取dp[0] - prices[i]，今天买入股票，那么dp[2] = max(dp[2], dp[1] + prices[i]);由递推公式 dp[i][0] = max(dp[i - 1][0], -prices[i]);同样dp[i][1]取最大的，dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);一定是选最大的，所以 dp[i][1] = max(dp[i-1][0] - prices[i], dp[i - 1][1]);
LeetCode-DP专题-买卖股票的最佳时机
小晒y的博客
03-03 81
题目描述： 给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。 链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock 示例 示例 1： 输入：[7,1,5,3,6,4] 输出：
股票专题:121. 买卖股票的最佳时机；122. 买卖股票的最佳时机 II；123. 买卖股票的最佳时机 III；309. 最佳买卖股票时机含冷冻期：
m0_63789329的博客
06-06 537
所以：dp[i][0] = max(dp[i - 1][0] + prices[i]， dp[i - 1][1])所以：dp[i][0] = max(dp[i - 1][0] + prices[i]， dp[i - 1][1])所以：dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] -prices[i])所以：dp[i][0] = max(dp[i - 1][0],-prices[i])第i-1天就不持有股票，那么就保持现状， 即：dp[i - 1][1]
力扣动态规划专题（四）劫舍问题与股票问题 打家劫舍Ⅰ Ⅱ Ⅲ 买卖股票最佳时机Ⅰ Ⅱ Ⅲ IV 步骤及C++实现
UUUUU22的博客
06-20 284
劫舍与股票问题 198.打家劫舍、213.打家劫舍II、337.打家劫舍III、121. 买卖股票的最佳时机（只能买卖一次）、122.买卖股票的最佳时机II（可以买卖多次）、123.买卖股票的最佳时机III（最多买卖两次）、188.买卖股票的最佳时机IV（最多买卖k次）、309.最佳买卖股票时机含冷冻期（买卖多次，卖出一天有冷冻期）、714.买卖股票的最佳时机含手续费（买卖多次，每次有手续费）
力扣专题——122. 买卖股票的最佳时机 II
qq_42479987的博客
11-08 645
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 示例 1: 输入: [7,1,5,3,6,4] 输出: 7 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。 随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6
【字节专题】leetcode 122. 买卖股票的最佳时机 II
Elon Zero的博客
10-08 112
122. 买卖股票的最佳时机 II 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 示例 1: 输入: [7,1,5,3,6,4] 输出: 7 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股...
力扣刷题记录-买卖股票专题
weixin_46120706的博客
09-12 226
买卖股票专题
基于java计算买卖股票的最佳时机
08-25
主要介绍了基于java计算买卖股票的最佳时机,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
LeetCode122买卖股票的最佳时机II
01-07
你可以尽可能地完成更多的交易（多次买卖一支股票）。 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 示例 1: 输入: [7,1,5,3,6,4] 输出: 7 解释: 在第 2 天（股票价格 = 1）的时候买入，...
Leetcode122. 买卖股票的最佳时机 II（C语言）
01-07
买卖股票的最佳时机 II（C语言） 算法-贪心思想：算法与数据结构参考 题目： 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。计算你所能获取的最大利润。可尽可能地完成更多的交易（多次买卖一支股票...
买卖股票最佳时机1-4加注释
12-22
1: 主要思想:dp(最大和子数组) class Solution(object): def maxProfit(self, prices): """ :type prices: List[int] :rtype: int """ lenth = len(prices) if lenth == 1 or lenth == 0: ...
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 980
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 133
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 657
LeetCode 算法：轮转数组c++
手搓顺序表（C语言）
最新发布
m0_62646213的博客
06-12 1093
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
买卖股票最佳时机java
11-09
卖股票的最佳时机是指在股票价格变化的情况下，通过买入和卖出股票获得最大利润的时间点。在Java中，可以通过贪心算法来解决这个问题。具体来说，我们可以遍历整个股票价格数组，同时维护一个变量minPrice来记录我们...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值