训练营第三十八天 | 309.最佳买卖股票时机含冷冻期动态规划系列七总结714.买卖股票的最佳时机含手续费股票问题总结篇!

2024-06-15 21:12
文章标签 动态 规划 股票 问题 总结 最佳 系列 训练营 最佳时机 买卖 时机 309 冷冻 714 手续费 第三十八

本文主要是介绍训练营第三十八天 | 309.最佳买卖股票时机含冷冻期动态规划系列七总结714.买卖股票的最佳时机含手续费股票问题总结篇!，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

309.最佳买卖股票时机含冷冻期

力扣题目链接(opens new window)

给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

  • 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
  • 卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

示例:

  • 输入: [1,2,3,0,2]
  • 输出: 3
  • 解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]

思路

相对于动态规划：122.买卖股票的最佳时机II (opens new window)，本题加上了一个冷冻期。所以在上一题的基础上多加一个冷冻期的状态即可。

class Solution {
public:int maxProfit(vector<int>& prices) {int len = prices.size();vector<int> buy(len, INT_MIN);vector<int> sell(len, 0);vector<int> frozen(len, 0);buy[0] = -prices[0]; // 初始买入状态的收益sell[0] = 0;         // 初始卖出状态的收益frozen[0] = 0;        // 初始冷冻期的收益for (int i = 1; i < len; i++) {buy[i] = max(buy[i - 1], frozen[i - 1] - prices[i]); // 买入状态sell[i] = max(sell[i - 1], buy[i - 1] + prices[i]); // 卖出状态frozen[i] = max(frozen[i - 1], sell[i - 1]);          // 冷冻期状态}return max(sell[len - 1], frozen[len - 1]); // 最后的最大收益应从卖出和冷冻期中选}
};

动规五部曲：

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

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

其实本题很多同学搞的比较懵，是因为出现冷冻期之后，状态其实是比较复杂度，例如今天买入股票、今天卖出股票、今天是冷冻期，都是不能操作股票的。

具体可以区分出如下四个状态：

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

​

j的状态为：

  • 0：状态一
  • 1：状态二
  • 2：状态三
  • 3：状态四
  1. 确定递推公式

达到买入股票状态（状态一）即：dp[i][0]，有两个具体操作：

  • 操作一：前一天就是持有股票状态（状态一），dp[i][0] = dp[i - 1][0]
  • 操作二：今天买入了，有两种情况
    • 前一天是冷冻期（状态四），dp[i - 1][3] - prices[i]
    • 前一天是保持卖出股票的状态（状态二），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] = 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];

综上分析，递推代码如下：

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];
  1. dp数组如何初始化

这里主要讨论一下第0天如何初始化。

如果是持有股票状态（状态一）那么：dp[0][0] = -prices[0]，一定是当天买入股票。

保持卖出股票状态（状态二），这里其实从 「状态二」的定义来说 ，很难明确应该初始多少，这种情况我们就看递推公式需要我们给他初始成什么数值。

如果i为1，第1天买入股票，那么递归公式中需要计算 dp[i - 1][1] - prices[i] ，即 dp[0][1] - prices[1]，那么大家感受一下 dp[0][1] （即第0天的状态二）应该初始成多少，只能初始为0。想一想如果初始为其他数值，是我们第1天买入股票后 手里还剩的现金数量是不是就不对了。

今天卖出了股票（状态三），同上分析，dp[0][2]初始化为0，dp[0][3]也初始为0。

  1. 确定遍历顺序

从递归公式上可以看出，dp[i] 依赖于 dp[i-1]，所以是从前向后遍历。

最后结果是取 状态二，状态三，和状态四的最大值，不少同学会把状态四忘了，状态四是冷冻期，最后一天如果是冷冻期也可能是最大值。

class Solution {
public:int maxProfit(vector<int>& prices) {int n = prices.size();if (n == 0) return 0;vector<vector<int>> dp(n, vector<int>(4, 0));dp[0][0] -= prices[0]; // 持股票for (int i = 1; i < n; i++) {dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][3] - prices[i], 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[n - 1][3], max(dp[n - 1][1], dp[n - 1][2]));}
};

动态规划系列七总结

动态规划：买卖股票的最佳时机II (opens new window)中股票可以买卖多次了！

这也是和121. 买卖股票的最佳时机 (opens new window)的唯一区别（注意只有一只股票，所以再次购买前要出售掉之前的股票）

重点在于递推公式的不同。

dp数组的含义：

  • dp[i][0] 表示第i天持有股票所得现金。
  • dp[i][1] 表示第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]);

本题和121. 买卖股票的最佳时机 (opens new window)的代码几乎一样，唯一的区别在：

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

动态规划：买卖股票的最佳时机IV (opens new window)最多可以完成 k 笔交易。

相对于上一道动态规划：123.买卖股票的最佳时机III (opens new window)，本题需要通过前两次的交易，来类比前k次的交易

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

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

j的状态表示为：

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

除了0以外，偶数就是卖出，奇数就是买入。

  1. 确定递推公式

dp[i][1]，表示的是第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]);
}

动态规划：123.买卖股票的最佳时机III (opens new window)最大的区别就是这里要类比j为奇数是买，偶数是卖的状态。

  1. dp数组如何初始化

dp[0][j]当j为奇数的时候都初始化为 -prices[0]

代码如下：

for (int j = 1; j < 2 * k; j += 2) {dp[0][j] = -prices[0];
}

在初始化的地方同样要类比j为奇数是买、偶数是卖的状态。

  1. 确定遍历顺序

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

最后一次卖出，一定是利润最大的，dp[prices.size() - 1][2 * k]即红色部分就是最后求解。

动态规划：最佳买卖股票时机含冷冻期 (opens new window)尽可能地完成更多的交易（多次买卖一支股票），但有冷冻期，冷冻期为1天

相对于动态规划：122.买卖股票的最佳时机II (opens new window)，本题加上了一个冷冻期

本题则需要第三个状态：不持有股票（冷冻期）的最多现金。

714.买卖股票的最佳时机含手续费

力扣题目链接(opens new window)

给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；非负整数 fee 代表了交易股票的手续费用。

你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。

返回获得利润的最大值。

注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

示例 1:

  • 输入: prices = [1, 3, 2, 8, 4, 9], fee = 2
  • 输出: 8

解释: 能够达到的最大利润:

  • 在此处买入 prices[0] = 1
  • 在此处卖出 prices[3] = 8
  • 在此处买入 prices[4] = 4
  • 在此处卖出 prices[5] = 9
  • 总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8.

注意:

  • 0 < prices.length <= 50000.
  • 0 < prices[i] < 50000.
  • 0 <= fee < 50000.

思路

本题贪心解法：贪心算法：买卖股票的最佳时机含手续费(opens new window)

相对于动态规划：122.买卖股票的最佳时机II (opens new window)，本题只需要在计算卖出操作的时候减去手续费就可以了，代码几乎是一样的。

唯一差别在于递推公式部分.

class Solution {
public:int maxProfit(vector<int>& prices, int fee) {int len = prices.size();vector<int> buy(len, INT_MIN);vector<int> sell(len, 0);buy[0] = -prices[0]; sell[0] = 0;for (int i = 1; i < len; i++) {buy[i] = max(buy[i - 1], sell[i - 1] - prices[i]);sell[i] = max(sell[i - 1], buy[i - 1] + prices[i] - fee);}           return sell[len - 1];}
};

股票问题总结篇!

股票问题总结

  • 动态规划：121.买卖股票的最佳时机(opens new window)
  • 动态规划：122.买卖股票的最佳时机II(opens new window)
  • 动态规划：123.买卖股票的最佳时机III(opens new window)
  • 动态规划：188.买卖股票的最佳时机IV(opens new window)
  • 动态规划：309.最佳买卖股票时机含冷冻期(opens new window)
  • 动态规划：714.买卖股票的最佳时机含手续费(opens new window)

#卖股票的最佳时机

动态规划：121.买卖股票的最佳时机 (opens new window)，股票只能买卖一次，问最大利润。

// 版本一
class Solution {
public:int maxProfit(vector<int>& prices) {int len = prices.size();if (len == 0) return 0;vector<vector<int>> dp(len, vector<int>(2));dp[0][0] -= prices[0];dp[0][1] = 0;for (int i = 1; i < len; i++) {dp[i][0] = max(dp[i - 1][0], -prices[i]);dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);}return dp[len - 1][1];}
};

#买卖股票的最佳时机II

动态规划：122.买卖股票的最佳时机II (opens new window)可以多次买卖股票，问最大收益。

class Solution {
public:int maxProfit(vector<int>& prices) {int len = prices.size();vector<int> buy(len, INT_MIN);vector<int> sell(len, 0);buy[0] = -prices[0];sell[0] = 0;for(int i = 1; i < len; i++) {buy[i] = max(buy[i - 1], sell[i - 1] - prices[i]);sell[i] = max(sell[i - 1], buy[i - 1] + prices[i]);}return sell[len - 1];}
};

#买卖股票的最佳时机III

动态规划：123.买卖股票的最佳时机III (opens new window)最多买卖两次，问最大收益。

// 版本二
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];}
};

#买卖股票的最佳时机IV

动态规划：188.买卖股票的最佳时机IV (opens new window)最多买卖k笔交易，问最大收益。

class Solution {
public:int maxProfit(int k, vector<int>& prices) {       vector<int> buy(k, INT_MIN);vector<int> sell(k, 0);    for(int price : prices) {buy[0] = max(buy[0], -price);sell[0] = max(sell[0], buy[0] + price);   for (int i = 1; i < k; i++) {buy[i] = max(buy[i], sell[i - 1] - price);sell[i] = max(sell[i], buy[i] + price);}}return sell[k - 1];}
};

#最佳买卖股票时机含冷冻期

动态规划：309.最佳买卖股票时机含冷冻期 (opens new window)可以多次买卖但每次卖出有冷冻期1天。

相对于动态规划：122.买卖股票的最佳时机II (opens new window)，本题加上了一个冷冻期。

class Solution {
public:int maxProfit(vector<int>& prices) {int len = prices.size();vector<int> buy(len, INT_MIN);vector<int> sell(len, 0);vector<int> frozen(len, 0);buy[0] = -prices[0]; // 初始买入状态的收益sell[0] = 0;         // 初始卖出状态的收益frozen[0] = 0;        // 初始冷冻期的收益for (int i = 1; i < len; i++) {buy[i] = max(buy[i - 1], frozen[i - 1] - prices[i]); // 买入状态sell[i] = max(sell[i - 1], buy[i - 1] + prices[i]); // 卖出状态frozen[i] = max(frozen[i - 1], sell[i - 1]);          // 冷冻期状态}return max(sell[len - 1], frozen[len - 1]); // 最后的最大收益应从卖出和冷冻期中选}
};

#买卖股票的最佳时机含手续费

动态规划：714.买卖股票的最佳时机含手续费 (opens new window)可以多次买卖，但每次有手续费。

相对于动态规划：122.买卖股票的最佳时机II (opens new window)，本题只需要在计算卖出操作的时候减去手续费就可以了，代码几乎是一样的。

class Solution {
public:int maxProfit(vector<int>& prices, int fee) {int len = prices.size();vector<int> buy(len, INT_MIN);vector<int> sell(len, 0);buy[0] = -prices[0]; sell[0] = 0;for (int i = 1; i < len; i++) {buy[i] = max(buy[i - 1], sell[i - 1] - prices[i]);sell[i] = max(sell[i - 1], buy[i - 1] + prices[i] - fee);}           return sell[len - 1];}
};

这篇关于训练营第三十八天 | 309.最佳买卖股票时机含冷冻期动态规划系列七总结714.买卖股票的最佳时机含手续费股票问题总结篇!的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1064591。

相关文章

HarmonyOS学习(七)——UI（五）常用布局总结

HarmonyOS学习(七)——UI（五）常用布局总结

自适应布局 1.1、线性布局（LinearLayout） 通过线性容器Row和Column实现线性布局。Column容器内的子组件按照垂直方向排列，Row组件中的子组件按照水平方向排列。 属性说明space通过space参数设置主轴上子组件的间距，达到各子组件在排列上的等间距效果alignItems设置子组件在交叉轴上的对齐方式，且在各类尺寸屏幕上表现一致，其中交叉轴为垂直时，取值为Vert
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
学习hash总结

学习hash总结

2014/1/29/   最近刚开始学hash，名字很陌生，但是hash的思想却很熟悉，以前早就做过此类的题，但是不知道这就是hash思想而已，说白了hash就是一个映射，往往灵活利用数组的下标来实现算法，hash的作用：1、判重；2、统计次数；
阅读更多...
好题——hdu2522（小数问题：求1/n的第一个循环节）

好题——hdu2522（小数问题：求1/n的第一个循环节）

好喜欢这题，第一次做小数问题，一开始真心没思路，然后参考了网上的一些资料。 知识点***********************************无限不循环小数即无理数，不能写作两整数之比*****************************（一开始没想到，小学没学好） 此题1/n肯定是一个有限循环小数，了解这些后就能做此题了。 按照除法的机制，用一个函数表示出来就可以了，代码如下
阅读更多...
hdu1043（八数码问题，广搜 + hash（实现状态压缩） ）

hdu1043（八数码问题，广搜 + hash（实现状态压缩） ）

利用康拓展开将一个排列映射成一个自然数，然后就变成了普通的广搜题。 #include<iostream>#include<algorithm>#include<string>#include<stack>#include<queue>#include<map>#include<stdio.h>#include<stdlib.h>#include<ctype.h>#inclu
阅读更多...
第10章 中断和动态时钟显示

第10章 中断和动态时钟显示

第10章 中断和动态时钟显示 从本章开始，按照书籍的划分，第10章开始就进入保护模式（Protected Mode）部分了，感觉从这里开始难度突然就增加了。 书中介绍了为什么有中断（Interrupt）的设计，中断的几种方式：外部硬件中断、内部中断和软中断。通过中断做了一个会走的时钟和屏幕上输入字符的程序。 我自己理解中断的一些作用： 为了更好的利用处理器的性能。协同快速和慢速设备一起工作
阅读更多...
动态规划---打家劫舍

动态规划---打家劫舍

题目： 你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。 给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。 思路： 动态规划五部曲： 1.确定dp数组及含义 dp数组是一维数组，dp[i]代表
阅读更多...
购买磨轮平衡机时应该注意什么问题和技巧

购买磨轮平衡机时应该注意什么问题和技巧

在购买磨轮平衡机时，您应该注意以下几个关键点： 平衡精度 平衡精度是衡量平衡机性能的核心指标，直接影响到不平衡量的检测与校准的准确性，从而决定磨轮的振动和噪声水平。高精度的平衡机能显著减少振动和噪声，提高磨削加工的精度。 转速范围 宽广的转速范围意味着平衡机能够处理更多种类的磨轮，适应不同的工作条件和规格要求。 振动监测能力 振动监测能力是评估平衡机性能的重要因素。通过传感器实时监
阅读更多...
科研绘图系列：R语言扩展物种堆积图（Extended Stacked Barplot）

科研绘图系列：R语言扩展物种堆积图（Extended Stacked Barplot）

介绍 R语言的扩展物种堆积图是一种数据可视化工具，它不仅展示了物种的堆积结果，还整合了不同样本分组之间的差异性分析结果。这种图形表示方法能够直观地比较不同物种在各个分组中的显著性差异，为研究者提供了一种有效的数据解读方式。 加载R包 knitr::opts_chunk$set(warning = F, message = F)library(tidyverse)library(phyl
阅读更多...
缓存雪崩问题

缓存雪崩问题

缓存雪崩是缓存中大量key失效后当高并发到来时导致大量请求到数据库，瞬间耗尽数据库资源，导致数据库无法使用。 解决方案： 1、使用锁进行控制 2、对同一类型信息的key设置不同的过期时间 3、缓存预热 1. 什么是缓存雪崩 缓存雪崩是指在短时间内，大量缓存数据同时失效，导致所有请求直接涌向数据库，瞬间增加数据库的负载压力，可能导致数据库性能下降甚至崩溃。这种情况往往发生在缓存中大量 k
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2