1. 买卖股票的最佳时机Ⅲ

1.1 问题描述

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

设计一个算法计算你能得到的最大利润，最多可以完成两笔交易。

注意：你不能同时参与多笔交易（必须在再次购买前出售掉之前的股票）

【示例】

输入：prices = [3,3,5,0,0,3,1,4]
输出：6
解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。   注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。   因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

输入：prices = [1]
输出：0

来源：力扣（LeetCode）

1.2 动态规划步骤分析

（1）确定状态
- 一天总共五种状态：
```
0：没有操作
1：第一次买入
2：第一次卖出
3：第二次买入
4：第二次卖出
```
- f[i][j]中i表示第i天，j为[0-4]五个状态，f[i][j]表示第i天状态j所剩的最大现金。
（2）转移方程
- f[i][1]有两种状态：
  - 第i天买入股票，则f[i][1] = f[i-1][0] - prices[i];
  - 第i天没有操作，等同于前一天的状态，即f[i][1] = f[i-1][1];
- f[i][2]有两种状态：
  - 第i天卖出股票，则f[i][2] = f[i-1][1] + prices[i];
  - 第i天没有操作，等同于前一天的状态，即f[i][2] = f[i-1][2];
- 依次往下类推
```
//f[i][1]
f[i][1] = max(f[i-1][1],f[i-1][0] - prices[i]);
//f[i][2]
f[i][2] = max(f[i-1][2],f[i-1][1] + prices[i]);
//f[i][3]
f[i][3] = max(f[i-1][3],f[i-1][2] - prices[i]);
//f[i][4]
f[i][4] = max(f[i-1][4],f[i-1][3] + prices[i]);
```
（3）初始化

第0天没有操作:f[0][0] = 0;第0天第一次买入：f[0][1] = -prices[0];第0天第一次卖出：f[0][2] = 0;  //一般卖出就一定是获取利润的，卖出的最差获利为0，故初始化为0第0天第二次买入：f[0][3] = -prices[0]; //第二次买入依赖于第一次卖出，相当于第0天先买入卖出，然后再买入第0天第二次卖出：f[0][4] = 0;  //一般卖出就一定是获取利润的，卖出的最差获利为0，故初始化为0

（4）计算顺序
- f[i] 依赖于f[i-1]，故计算顺序从前往后。
（5）举例

1.3 C++实现

int maxProfit3(vector<int>& prices){if(prices.size() == 0) return 0;vector<vector<int>> f(prices.size(),vector<int>(2));//初始化f[0][1] = f[0][3] = -prices[0];f[0][0] = f[0][2] = f[0][4] = 0;for(int i = 1;i < prices.size();++i){f[i][0] = f[i-1][0];f[i][1] = max(f[i-1][1],f[i-1][0] - prices[i]);f[i][2] = max(f[i-1][2],f[i-1][1] + prices[i]);f[i][3] = max(f[i-1][3],f[i-1][2] - prices[i]);f[i][4] = max(f[i-1][4],f[i-1][3] + prices[i]);}//利润最大的时候一定最后一次卖出所得的利润。所以最终最大利润是f[4][4]return f[prices.size()-1][4];
}

#include <iostream>
#include <vector>
using namespace std;int maxProfit3(vector<int>& prices);int main(){vector<int> prices = {1,2,3,4,5};cout << maxProfit3(prices) << endl;return 0;
}

2. 买卖股票的最佳时机Ⅳ

2.1 问题描述

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

设计一个算法来计算你能获得的最大利润，最多可以完成K笔交易（不能同时参与多笔交易，即再次购买前需要出售掉之前的股票）

【示例】

输入：k = 2, prices = [2,4,1]
输出：2
解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。

输入：k = 2, prices = [3,2,6,5,0,3]
输出：7
解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。

来源：力扣（LeetCode）

1.2 动态规划问题分析

（1）确定状态
- 使用二维数组f[i][j]。第i天的状态为j，所剩下的最大现金是f[i][j]。j的状态表示如下
```
0：没有操作
1：第一次买入
2：第一次卖出
3：第二次买入
4：第二次卖出
......
......
```
- 除了0以外，偶数就是卖出，奇数就是买入。题目要求最多有k笔交易，那么j的定义范围为[0,2*k+1]
```
//初始化二维数组f[i][j]
vector<vector<int>> f(prices.size(),vector<int>(2*k+1,0));
```
（2）转移方程
- f[i][1]有两种状态：
  - 第i天买入股票，则f[i][1] = f[i-1][0] - prices[i];
  - 第i天没有操作，等同于前一天的状态，即f[i][1] = f[i-1][1];
- f[i][2]有两种状态：
  - 第i天卖出股票，则f[i][2] = f[i-1][1] + prices[i];
  - 第i天没有操作，等同于前一天的状态，即f[i][2] = f[i-1][2];
- 依次往下类推
```
for(int j = 0;j < 2*k - 1;j+=2){//奇数为买入 1,3,5,...f[i][j+1] = max(f[i-1][j+1],f[i-1][j] - prices[i]);//偶数为卖出 2,4,6,...f[i][j+2] = max(f[i-1][j+2],f[i-1][j+1] + prices[i]);
}
```

（3）初始化

第0天没有操作:f[0][0] = 0;
第0天第一次买入：f[0][1] = -prices[0];
第0天第一次卖出：f[0][2] = 0;  //一般卖出就一定是获取利润的，卖出的最差获利为0，故初始化为0
第0天第二次买入：f[0][3] = -prices[0]; //第二次买入依赖于第一次卖出，相当于第0天先买入卖出，然后再买入
第0天第二次卖出：f[0][4] = 0;  //一般卖出就一定是获取利润的，卖出的最差获利为0，故初始化为0
...
...

可以推出f[0][j]当j为奇数的时候都初始化为 -prices[0]；偶数时初始化为0。

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

（4）计算顺序
- 从转移方程其实已经可以看出，一定是从前向后遍历，因为f[i]，依靠f[i - 1]的数值。

2.3 C++实现

int maxProfit4(vector<int>& prices,int k){if(prices.size() == 0) return 0;vector<vector<int>> f(prices.size(),vector<int>(2*k+1,0));//初始化数组元素for(int j = 1;j < 2*k ;j+=2){f[0][j] -= prices[0];}for(int i = 1; i < prices.size();++i){for(int j = 0;j < 2*k-1;j+=2){f[i][j+1] = max(f[i-1][j+1],f[i-1][j] - prices[i]);f[i][j+2] = max(f[i-1][j+2],f[i-1][j+1] + prices[i]);}}return f[prices.size()-1][2*k];
}

#include <iostream>
#include <vector>
using namespace std;int maxProfit4(vector<int>& prices,int k);int main(){vector<int> prices = {1,2,3,4,5};cout << maxProfit4(prices,2) << endl;return 0;
}

【参考】代码随想录

买卖股票的最佳时机Ⅲ和Ⅳ相关推荐

【每日一算法】买卖股票的最佳时机
微信改版,加星标不迷路! 每日一算法-买卖股票的最佳时机作者:阿广阅读目录 1 题目 2 解析 1 题目给定一个数组,它的第 i 个元素是一支给定股票第 i 天的价格. 如果你最多只允许完成一笔 ...
《LeetCode力扣练习》第121题买卖股票的最佳时机 Java
<LeetCode力扣练习>第121题买卖股票的最佳时机 Java 一.资源题目: 给定一个数组 prices ,它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价 ...
炒股Java_基于java计算买卖股票的最佳时机
这篇文章主要介绍了基于java计算买卖股票的最佳时机,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下问题: 可以将问题转化为如下图所示,即求多个累计 ...
聊聊买卖股票的最佳时机
前言大家好,我是大赛哥,好久不见,天天想念! 最近梳理高频动态规划问题,股票问题当然是非常经典的动态规划问题,并且整个系列有好几道题,这里我整理了6道股票系列的经典问题分享给大家,咱们今天聊聊买卖股 ...
Leetcode 188.买卖股票的最佳时机IV
买卖股票的最佳时机IV 给定一个数组,它的第 i 个元素是一支给定的股票在第 i 天的价格. 设计一个算法来计算你所能获取的最大利润.你最多可以完成 k 笔交易. 注意: 你不能同时参与多笔交易(你必 ...
买卖股票的最佳时机含手续费
相对于动态规划:122.买卖股票的最佳时机II,本题只需要在计算卖出操作的时候减去手续费就可以了,代码几乎是一样的. 唯一差别在于递推公式部分 dp[i][0] 表示第i天持有股票所省最多现金. dp ...
买卖股票的最佳时机IV
思路这道题目可以说是动态规划:123.买卖股票的最佳时机III的进阶版,这里要求至多有k次交易. 确定dp数组以及下标的含义在动态规划:123.买卖股票的最佳时机III中,我是定义了一个二维dp数 ...
买卖股票的最佳时机III
思路这道题目相对 121.买卖股票的最佳时机和 122.买卖股票的最佳时机II 难了不少. 关键在于至多买卖两次,这意味着可以买卖一次,可以买卖两次,也可以不买卖. 确定dp数组以及下标的含义一 ...
买卖股票的最佳时机II
思路本题和121. 买卖股票的最佳时机的唯一区别本题股票可以买卖多次了(注意只有一只股票,所以再次购买前要出售掉之前的股票) 这里重申一下dp数组的含义: dp[i][0] 表示第i天持有股票所得现 ...
LeetCode - 121. 买卖股票的最佳时机
121. 买卖股票的最佳时机 class Solution {public int maxProfit(int[] prices) {if (prices == null || prices.leng ...

买卖股票的最佳时机Ⅲ和Ⅳ

买卖股票的最佳时机