LeetCode|股票问题|121. 买卖股票的最佳时机、122. 买卖股票的最佳时机 II、123. 买卖股票的最佳时机 III、188. 买卖股票的最佳时机 IV
目录
一、121. 买卖股票的最佳时机
1.题目描述
2.解题思路
3.代码实现
二、122. 买卖股票的最佳时机 II
1.题目描述
2.解题思路
3.代码实现
三、123. 买卖股票的最佳时机 III
1.题目描述
2.解题思路
3.代码实现
四、188. 买卖股票的最佳时机 IV
1.题目描述
2.解题思路
3.代码实现
一、121. 买卖股票的最佳时机
1.题目描述
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
示例 1：
输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
示例 2：
输入：prices = [7,6,4,3,1] 输出：0 解释：在这种情况下, 没有交易完成, 所以最大利润为 0。
2.解题思路
- 明确一点：本题的这支股票，只能买入一次，和卖出一次
- 每天有两个状态，持有这支股票和不持有这支股票。因此我们需要一个二维数组，“第二维”用来表示这两种状态：这里用0来表示持有这支股票，1来表示不持有股票的状态
- 那么现在，可以明确dp数组含义了：dp[i][0]代表第i天持有这支股票所得最大现金，dp[i][1]表示第i天不持有这支股票的最大现金
- 递推公式：dp[i][0] 表示第i天持有这支股票，分别由以下两种状态
- 第i - 1天就持有了这支股票，因此此时dp[i][0] = dp[i - 1][0]
- 第i - 1天没有买，第i天刚买的，因此此时dp[i][0] = - price[i]
- 这时，取两者的最大值
- 递推公式：dp[i][1] 表示第i天不持有这支股票，分别由以下两种状态
- 第i - 1天就不持有了这支股票，因此此时dp[i][1] = dp[i - 1][1]
- 第i - 1天持有，第i天刚卖出的，因此此时dp[i][1] = dp[i - 1][0] + price[i]
- 这时，还是取两者的最大值
3.代码实现
class Solution {
public:
int maxProfit(vector& prices) {
int len = prices.size();
if(len == 0) return 0 ;
vector> dp(len,vector(2));
//初始化
dp[0][0] = -prices[0];
dp[0][1] = 0;
for(int i = 1;i 二、122. 买卖股票的最佳时机 II
1.题目描述
给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。
在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。
返回 你能获得的 最大 利润 。
示例 1：
输入：prices = [7,1,5,3,6,4]
输出：7
解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。
总利润为 4 + 3 = 7 。
示例 2：
输入：prices = [1,2,3,4,5] 输出：4 解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。 总利润为 4 。
示例 3：
输入：prices = [7,6,4,3,1] 输出：0 解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0 。
2.解题思路
本题和上面那题的区别就是，这支股票可以买卖多次。代码上大同小异，在dp[i][0]时的判断需要更改一下，因为上一题股票只能买一次，如果买的话，那时候的现金一定是0。而本题是可以买卖多次，如果买的话，此时口袋里的现金是dp[i-1][1]。
3.代码实现
class Solution {
public:
int maxProfit(vector& prices) {
int len = prices.size();
if(len == 0) return 0;
vector> dp(len,vector(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],dp[i-1][1] - prices[i]);
dp[i][1] = max(dp[i-1][1],dp[i-1][0] + prices[i]);
}
return dp[len-1][1];
}
}; 三、123. 买卖股票的最佳时机 III
1.题目描述
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
输入：prices = [3,3,5,0,0,3,1,4] 输出：6 解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。 随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。
示例 2：
输入：prices = [1,2,3,4,5] 输出：4 解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。 注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。 因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3：
输入：prices = [7,6,4,3,1] 输出：0 解释：在这个情况下, 没有交易完成, 所以最大利润为 0。
示例 4：
输入：prices = [1] 输出：0
2.解题思路
本题虽然LeetCode上显示是困难题，但是其实相比于上两题，就是多了几种状态。
3.代码实现
class Solution {
public:
int maxProfit(vector& prices) {
//思路很重要，这里最多可以完成两笔交易
//因此每天对应着5种状态
//0.什么也不操作
//1.第一次持有
//2.第一次不持有
//3.第二次持有
//4.第二次不持有
int len = prices.size();
if(len == 0) return 0;
vector> dp(len,vector(5));
//初始化
dp[0][0] = 0;
dp[0][1] = -prices[0];
dp[0][2] = 0;
dp[0][3] = -prices[0];
dp[0][4] = 0;
for(int i = 1;i < len;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[len-1][4],dp[len-1][2]);
}
}; 四、188. 买卖股票的最佳时机 IV
1.题目描述
给你一个整数数组 prices 和一个整数 k ，其中 prices[i] 是某支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。也就是说，你最多可以买 k 次，卖 k 次。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1：
输入：k = 2, prices = [2,4,1] 输出：2 解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 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 。
2.解题思路
- 这题也是困难题，但本质也就是多了很多种状态：第一次买入，第一次卖出，第二次买入，第二次卖出，第三次买入，第三次卖出.......
- 在上一题因为最多只有两次交易，直接四个四个递推公式敲出来就行
- 但是本题，最多有k次交易，就要借助for循环来递推这2*k种状态了
3.代码实现
class Solution {
public:
int maxProfit(int k, vector& prices) {
//明确dp数组含义：第二维向量表示第j次买入卖出，所能获取的最大利润
int len = prices.size();
if(len == 0) return 0;
vector> dp(len,vector(2*k+1));
//初始化:第0天，j为奇数的时候都买入，都是-prices[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] - prices[i],dp[i-1][j+1]);
dp[i][j+2] = max(dp[i-1][j+2],dp[i-1][j+1] + prices[i]);
}
}
return dp[len-1][2*k];
}
};