目录
LeetCode188.买卖股票的最佳时机IV
给你一个整数数组
prices和一个整数k，其中prices[i]是某支给定的股票在第i天的价格。设计一个算法来计算你所能获取的最大利润。你最多可以完成
k笔交易。也就是说，你最多可以买k次，卖k次。注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
思路：这道题和之前讲的买卖股票的最佳时机III很像，如果前面这道题仔细做了，那么这道题也简单。
需要注意得是这里是可以买卖k次，也就是不止买卖2次了。
没关系，照样可以做。只能买卖两次的时候状态设为了5个状态，那么这里我们就可以设置2*k+1个状态，并且初始化的时候就会发现，奇数的时候是卖出，偶数的时候是买入，当然这个买入卖出不是说当时就得买，也可以是延续之前的状态。
于是在for循环里面，以此将dp数组填满，最后返回最后一天的未持有股票状态即为最大值。
如果不太熟悉的话，可以看看这买卖股票的最佳时机III.
读完后就会发现这道题真的不算难，算不上困难。
int maxProfit(int k, vector<int>& prices) {
//dp[i][j]表示第i天对应的不同状态
//奇数表示持有股票的状态，偶数表示没有持有股票
vector<vector<int>> dp(prices.size(), vector<int>(2 * k + 1, 0));
for(int j = 1; j < 2 * k + 1; j += 2){
dp[0][j] = - prices[0];//对dp数组进行初始化
}
for(int i = 1; i < prices.size(); i ++){
for(int j = 1; j < 2 * k + 1; j ++){
if(j % 2 == 1){
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - 1] - prices[i]);
}else{
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - 1] + prices[i]);
}
}
}
return dp[prices.size() - 1][2 * k];
}时间复杂度：O(n*k)
空间复杂度：O(n*k)
当然，这里可以将空间消耗进行优化，只使用一维滚动数组将状态记录下，不断迭代更新。
int maxProfit(int k, vector<int>& prices) {
vector<int> dp(2 * k + 1, 0);//dp[i]表示所处的状态
for(int i = 0; i < 2 * k + 1; i ++){//这里将所有的奇数下标设置为持有股票，设置为初始值
if(i % 2 == 1){
dp[i] = - prices[0];
}
}
for(int i = 1; i < prices.size(); i ++){
for(int j = 1; j < 2 * k + 1; j ++){
if(j % 2 == 1){
dp[j] = max(dp[j], dp[j - 1] - prices[i]);//奇数下标是持有股票状态
}else if(j % 2 == 0){
dp[j] = max(dp[j], dp[j - 1] + prices[i]);//偶数下标是没有持有股票状态
}
}
}
return dp[2 * k];
}时间复杂度：O(n*k)
空间复杂度：O(k)
LeetCode309.买卖股票的最佳时机含冷冻期
给定一个整数数组
prices，其中第prices[i]表示第i天的股票价格 。设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
- 卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
思路：这里就与前面的题目稍微有点区别了。
增加了一个冷冻期，如何考虑呢，如果说没考虑好，会很绕，也AC不了。
这里我们大体分为三个部分
一是持有股票状态；
二是未持有股票状态；
三是冷冻时期状态。
对于第一部分持有股票状态，可以有三种情况考虑，第一种是保持之前已有的持有股票状态，第二种是前面是未持有股票状态，在这里开始购买股票，第三种是前面是冷冻时期，然后到这里开始购买股票，总共三种情况，都是可以发生在持有股票阶段，于是取三者中的最大值。
对于第二部分未持有股票，可以划分为两个子状态：
一个是保持之前未持有股票的状态，这里就有两种情况了：1是前面本身就是未持有股票的状态，2是前面一天是冷冻时期，到今天的话确实也是未持有股票状态；
另一个就是今天将股票卖了，那么可知前一天必然是拥有股票的，所以在前面一天持有股票的基础上卖出即可
对于第三部分冷冻状态，说明前一天已经将股票卖出，所以今天才会是冷冻时期，所以今天冷冻时期的最大利润就是昨天卖出股票的最大利润。
于是综上，总共划分为4个状态，分别用0到1表示，这样的话其实本题也就明晰起来了。
如果还是没有怎么看懂，可以参照下面的代码看，代码旁边也有注释，或者自己可以手动模拟模拟，实践一下，加深一下理解。
int maxProfit(vector<int>& prices) {
//这里需要多设置一个状态位，是关于冷冻期的
//0表示持有股票状态，1表示不持有股票状态（保持之前的状态）
//2表示不持有股票状态（今天卖出），3表示冷冻期状态
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][1], dp[i - 1][3]) - prices[i]);
//在不持有股票的状态下保持之前的状态，包括两种情况，第一种是保持前面已有的不持有股票的状态，第二种就是前面一天是冷冻期，那么直接取两者最大的即可
dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
//如果说要卖出股票，那么前一天必然是持有股票的，所以是dp[i - 1][0] + prices[i]
dp[i][2] = dp[i - 1][0] + prices[i];
//如果今天是冷冻期，那么说明前面一天就已经将股票卖出了，所以在这一天的最大利润就是dp[i-1][2]
dp[i][3] = dp[i - 1][2];
}
//这里返回的最大值首先肯定是不持有股票状态中的，但是需要注意还有一个冷冻期的状态的最大利润不能不考虑，因为其可能包含最大值
return max(dp[prices.size() - 1][1], max(dp[prices.size() - 1][2], dp[prices.size() - 1][3]));
}时间复杂度：O(n)
空间复杂度：O(n)
同样这里可以进行空间消耗的优化，但是需要注意一下，因为一维滚动数组中的某些值在使用前可能已经更新了，所以在更新数据之前需要记录下可能会在使用前更新覆盖的值，以免出错。
int maxProfit(vector<int>& prices) {
vector<int> dp(4, 0);
dp[0] = - prices[0];
for(int i = 1; i < prices.size(); i ++){
int pre_dp0 = dp[0];//将dp[0]的值记录下，因为后面dp[2]要用，避免在使用之前dp[0]已经更新过了
int pre_dp2 = dp[2];//同理，将dp[2]记录下
dp[0] = max(dp[0], max(dp[1], dp[3]) - prices[i]);
dp[1] = max(dp[1], dp[3]);
dp[2] = pre_dp0 + prices[i];
dp[3] = pre_dp2;
}
return max(dp[1], max(dp[2], dp[3]));
}时间复杂度：O(n)
空间复杂度：O(1)
LeetCode714.买卖股票的最佳时机含手续费
给定一个整数数组
prices，其中prices[i]表示第i天的股票价格 ；整数fee代表了交易股票的手续费用。你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。
返回获得利润的最大值。
注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。
这道题其实动态规划来做很简单，跟讲过的LeetCode122.买卖股票的最佳时机II的唯一区别就在于在卖出股票的时候记得结算一下手续费。但是我这里还是讲一讲贪心的解法，拓展一下思路。
1. 贪心算法
如果没有手续费这个条件，那么就直接只是取正利润即可得到最大利润。
加上了手续费的话就需要考虑什么时候扣除。
一般来说是在卖出股票的时候扣除。根据贪心的思路，取最小值min买入，取最大值卖出，由这道题可以知道，买入的点很好找，只要记录更新最小的价格即可，这就是最小值购入，也不用知道哪天购入的，反正就是在最小价格的时候购入了。
难就难在如何找最大值卖出。
这里我们可以很容易想到，如果prices[i]<min+fee,那么肯定是没有办法获取正利润的，跳过即可，当prices[i]>min+fee时，有机会获取正利润，但是我们要考虑一间事情，需要在i这里卖出吗？
如果卖出，后续如果还有更大的，能够获取更大的利润怎么办，只要多进行一次交易，就需要多付一次手续费，显然这不是贪心的局部最优。
这里我们采取这样一种策略：只要区间里面计算出来还是正利润，那就继续加，但是min设置就有讲究了，为了避免多次扣除手续费，这里min=prices[i]-fee，多减出来的fee在下次还是处于正利润区间的时候，会将手续费抵消掉，这样就保证了加的是纯的正利润，而如果下次不再处于正利润区间，那么就可能开始一个新的买卖交易，min也重新赋值，正利润继续累加，或者不满足获取正利润的条件，直接跳过本次循环。
其实在正利润区间可以将其看为一直持有，但是其实只付了一次手续费，在这个区间里面累加正利润，知道该区间最后一个元素截止，在这个正利润区间里面的利润才算完全统计完，该区间起点为买入的时间,终点为卖出的时间，中间则一直在积累正利润，并且整个交易只付了一次手续费，其它的虽然也进入了取利润的判断中，但是手续费都被抵消了。
于是这样就能得到最终的最大利润。
int maxProfit(vector<int>& prices, int fee) {
int result = 0;//记录最终结果
int min = prices[0];//记录最小值
for(int i = 0; i < prices.size(); i ++){
if(prices[i] < min) min = prices[i];//更新最小值
if(prices[i] < (min + fee)) continue;//这种情况没有办法获取正利润
if(prices[i] > (min + fee)){
result += prices[i] - min - fee;//记录正利润；
min = prices[i] - fee;//这里为什么要减去fee呢
//按道理来说买入卖出了，这里应该将最小值设为prices[i],然后后续持续添加正利润，这个逻辑没问题
//但是不一定碰到了比min+fee大的prices[i],两个一减就是最大的利润，
//比如说[3,6,7,8],fee=2,如果说按照上面的说法来求，那么最后的利润为1;
//但是实际上可以在3购入，在8抛出，最后的最大利润可以为3，
//这也就是说上面的想法是片面的，只有在到达正利润的区间的最后一个数字时，才能获取最大值，也就是说这个时候才能完全将股票卖出，获得最大正利润；
//并且在这个正利润区间里面按照代码方式运行的话是没有多扣手续费的，因为在正利润区间里面代入min就可以知道fee被抵消了，所以加的是纯的正利润
}
}
return result;
}时间复杂度：O(n)
空间复杂度：O(1)
2. 动态规划
刚才说过，动态规划来做这道题是比较简单的，就是前面做过的题LeetCode122.买卖股票的最佳时机II ，区别就在于不要忘记在卖出股票的时候记得将手续费统一减去。
其实也简单，这里我选择了一个滚动的2x2数组来滚动记录。
int maxProfit(vector<int>& prices, int fee) {
//dp[][j]中的j有两个状态，0为不持有股票，1表示持有股票
//这里是将二维的空间简化为了2x2的空间
vector<vector<int>> dp(2, vector<int>(2, 0));
dp[0][1] = - prices[0];
for(int i = 1; i < prices.size(); i ++){
dp[i % 2][0] = max(dp[(i - 1) % 2][0], dp[(i - 1) % 2][1] + prices[i] - fee);//记得这里在卖出股票的时候统一交手续费
dp[i % 2][1] = max(dp[(i - 1) % 2][1], dp[(i - 1) % 2][0] - prices[i]);
}
return max(dp[(prices.size() - 1) % 2][0], dp[(prices.size() - 1) % 2][1]);
}时间复杂度：O(n)
空间复杂度：O(1)
感谢你的阅读，希望我的文章能够给你帮助，如果有帮助，麻烦点赞加收藏，或者点点关注，非常感谢。
如果有什么问题欢迎评论区讨论！
1726
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
