Day49｜动态规划part10：188.买卖股票的最佳时机IV、121. 买卖股票的最佳时机、122.买卖股票的最佳时机II
188. 买卖股票的最佳时机IV
leetcode链接：188 题「买卖股票的最佳时机 IVopen in new window」
视频链接：动态规划来决定最佳时机，至多可以买卖K次！| LeetCode：188.买卖股票最佳时机4
给你一个整数数组 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 。
接下来的解法来自labuladong的算法 ，从最难的188题入手，限制最多。用状态机的形式进行状态转移。
对于每天的股票，有三种选择：买，卖，不买也不卖。我们用 buy, sell, rest 表示这三种选择。但每次这三种状态不是随便选的:
- 因为
sell必须在buy之后（对于交易次数设置为无限次时，只能先卖掉手里的再买） buy必须在sell之后（手里有股票了才能卖）。- 那么
rest操作还应该分两种状态，一种是buy之后的rest（持有了股票），一种是sell之后的rest（没有持有股票）。 - 交易次数
k的限制，就是说你buy还只能在k > 0的前提下操作
- 确定dp数组的含义及下标
我们的dp数组应该是几维的？这个问题的「状态」有三个，第一个是天数，第二个是允许交易的最大次数，第三个是当前的持有状态（即之前说的 rest 的状态，我们不妨用 1 表示持有，0 表示没有持有）。然后我们用一个三维数组就可以装下这几种状态的全部组合：
dp[i][k][0 or 1]
0 <= i <= n - 1, 1 <= k <= K
n 为天数，大 K 为交易数的上限，0 和 1 代表是否持有股票。
此问题共 n × K × 2 种状态，全部穷举就能搞定。
for 0 <= i < n:
for 1 <= k <= K:
for s in {0, 1}:
dp[i][k][s] = max(buy, sell, rest)
比如说 dp[3][2][1] 的含义就是：今天是第三天，我现在手上持有着股票，至今最多进行 2 次交易。再比如 dp[2][3][0] 的含义：今天是第二天，我现在手上没有持有股票，至今最多进行 3 次交易。
我们想求的最终答案就是：dp[n - 1][k][0] ，因为最后一天卖出肯定比不卖出赚的多，因此求的不是dp[n-1][k][1] 。
- 确定递推公式
我们可以画出如下的状态转移图：
因此我们可以分两种状态：dp[i][k][0]和dp[i][k][1] 。
dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
max( 今天选择 rest, 今天选择 sell )
解释：今天我没有持有股票，有两种可能，我从这两种可能中求最大利润：
1、我昨天就没有持有，且截至昨天最大交易次数限制为 k；然后我今天选择 rest，所以我今天还是没有持有，最大交易次数限制依然为 k。
2、我昨天持有股票，且截至昨天最大交易次数限制为 k；但是今天我 sell 了，所以我今天没有持有股票了，最大交易次数限制依然为 k。
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
max( 今天选择 rest, 今天选择 buy )
解释：今天我持有着股票，最大交易次数限制为 k，那么对于昨天来说，有两种可能，我从这两种可能中求最大利润：
1、我昨天就持有着股票，且截至昨天最大交易次数限制为 k；然后今天选择 rest，所以我今天还持有着股票，最大交易次数限制依然为 k。
2、我昨天本没有持有，且截至昨天最大交易次数限制为 k - 1；但今天我选择 buy，所以今天我就持有股票了，最大交易次数限制为 k。
- 状态
k的定义并不是「已进行的交易次数」，而是「最大交易次数的上限限制」。 - 在
sell的时候给k减小 1 和在buy的时候给k减小 1 是并不是等效，因为交易是从buy开始，如果buy的选择不改变交易次数k的话，会出现交易次数超出限制的的错误。也就是说买的时候k - 1卖的时候不减。
这是一个反向的过程，是推图的入边而不是出边。
- 确定dp初始化
dp[-1][...][0] = 0
解释：因为 i 是从 0 开始的，所以 i = -1 意味着还没有开始，这时候的利润当然是 0。
dp[-1][...][1] = -infinity
解释：还没开始的时候，是不可能持有股票的。
因为我们的算法要求一个最大值，所以初始值设为一个最小值，方便取最大值。
dp[...][0][0] = 0
解释：因为 k 是从 1 开始的，所以 k = 0 意味着根本不允许交易，这时候利润当然是 0。
dp[...][0][1] = -infinity
解释：不允许交易的情况下，是不可能持有股票的。
因为我们的算法要求一个最大值，所以初始值设为一个最小值，方便取最大值。
至于-1 怎么编程表示出来呢，负无穷怎么表示呢？这都是细节问题，有很多方法实现。
- 确定遍历顺序
因此天数是从小到大的，因此遍历顺序肯定是从前往后。
- 循环打印dp数组
这样我们就确定了买卖股票问题的框架，其他的题目都是这题的特殊情况。
121. 买卖股票的最佳时机
这题就是上面说的只交易一次，就是k = 1的情况。
leetcode链接：力扣题目链接
视频链接：：动态规划之 LeetCode：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。
暴力解法
首先就是暴力解法，两个for循环，寻找最大的间距（这里注意左边的一定要比右边小）
class Solution {
public:
int maxProfit(vector<int>& prices) {
int maxValue = 0;
for(int i = 0; i < prices.size(); i++){
for(int j = i + 1; j < prices.size(); j++){
maxValue = max(prices[j] - prices[i],maxValue);
}
}
return maxValue;
}
};
- 时间复杂度：O(n^2)
- 空间复杂度：O(1)
最后直接超时了，直接看动态规划解法。
贪心解法
这题是可以贪心做的，直觉就是取最小的买入，然后result = max(result, prices[i] - low); // 直接取最大区间利润保证利润为正：
class Solution {
public:
int maxProfit(vector<int>& prices) {
int low = INT_MAX;
int result = 0;
for (int i = 0; i < prices.size(); i++) {
low = min(low, prices[i]); // 取最左最小价格
result = max(result, prices[i] - low); // 直接取最大区间利润
}
return result;
}
};
- 时间复杂度：O(n)
- 空间复杂度：O(1)
动态规划
- 确定DP数组下标及其含义
因为这题k = 1，因此可以把k那一维简化变为二维数组：
故dp[i][0]/dp[i][1]表示今天是第i天，我手上是否持有股票，的最大利润
- 确定dp的递推公式
之前是：
dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
现在去掉了k的维：
dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
dp[i][1] = max(dp[i-1][1], -prices[i])
这里为什么是-price[i] ?
-prices[i]只出现在k = 1的情况。因为如果只有一次交易的话，那每天的dp[i][1]状态（第i天手持股票）只会是因为我在当天购买了股票，使得我目前的资本为-prices[I]，所以是负数。每天的dp[i][1]状态不会依赖于dp[i-1][0]， 也就是当k =1的时候dp[i][1] 不等于dp[i-1][0] - prices[I]。
- dp数组的初始化
之前是：dp[-1][...][0] = dp[...][0][0] = 0
dp[-1][...][1] = dp[...][0][1] = -infinity
去掉了k维后：
dp[0][0] = 0;
dp[0][1] = -infinity
- 遍历顺序
因为跨度是时间，从前往后。
- 打印dp数组
最终代码：
class Solution {
public:
int maxProfit(vector<int>& prices) {
vector<vector<int>> dp (prices.size(),vector<int>(2));
dp[0][0] = 0;
dp[0][1] = -prices[0];
for(int i = 1; i < prices.size(); i++){
dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]);
dp[i][1] = max(dp[i-1][1], -prices[i]);
}
return dp[prices.size() - 1][0];
}
};
还可以不使用dp数组，直接使用2个变量节省空间：
// 空间复杂度优化版本
int maxProfit_k_1(vector<int>& prices) {
int n = prices.size();
// base case: dp[-1][0] = 0, dp[-1][1] = -infinity
int dp_i_0 = 0, dp_i_1 = INT_MIN;
for (int i = 0; i < n; i++) {
// dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
dp_i_0 = max(dp_i_0, dp_i_1 + prices[i]);
// dp[i][1] = max(dp[i-1][1], -prices[i])
dp_i_1 = max(dp_i_1, -prices[i]);
}
return dp_i_0;
}
这个解法了解就行了，先解决一般的解法再说。
122.买卖股票的最佳时机II
这题相比k是无限制的。
leetcode链接：「买卖股票的最佳时机 IIopen in new window」
视频链接：动态规划来决定最佳时机，至多可以买卖K次！| LeetCode：188.买卖股票最佳时机4
给你一个整数数组 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 。
贪心解法
这题在贪心部分就已经做过了，贪心思想就是当天比前一天大就卖出，最终代码：
class Solution {
public:
int maxProfit(vector<int>& prices) {
int result = 0;
for(int i = 1; i < prices.size(); i++){
if(prices[i] - prices[i - 1] > 0){
result += prices[i] - prices[i - 1];
}
}
return result;
}
};
动态规划
- 确定dp数组下标及其含义
这题相当于k为正无穷的情况。如果 k 为正无穷，那么就可以认为 k 和 k - 1 是一样的。因为也就不需要记录k这个状态了， 因此故dp[i][0]/dp[i][1] 表示今天是第i天，我手上是否持有股票，的最大利润
- 确定dp递推公式
之前是：
dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
又因为k可以看作和k - 1一样，可以看成：
dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
= max(dp[i-1][k][1], dp[i-1][k][0] - prices[i])
现在去掉了k的维：
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])
这里就不是-price[i]了，因为k - 1不等于0。
- dp数组的初始化：
之前是：
dp[0][0] = 0;
dp[0][1] = -infinity
在代码中表现为；
dp[0][0] = 0;
dp[0][1] = -prices[0];
- 遍历顺序
从前往后
- 打印dp数组
最终代码 ：
class Solution {
public:
int maxProfit(vector<int>& prices) {
vector<vector<int>> dp (prices.size(),vector<int>(2));
dp[0][0] = 0;
dp[0][1] = -prices[0];
for(int i = 1; i < prices.size(); 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]);//原来是-prices[i]
}
return dp[prices.size() - 1][0];
}
};
这里就改了第9行的递推公式。
空间简化版：
class Solution {
public:
int maxProfit(vector<int>& prices) {
int n = prices.size();
// base case: dp[-1][0] = 0, dp[-1][1] = -infinity
int dp_i_0 = 0, dp_i_1 = INT_MIN;
for (int i = 0; i < n; i++) {
// dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
dp_i_0 = max(dp_i_0, dp_i_1 + prices[i]);
// dp[i][1] = max(dp[i-1][1], dp[i-1][0]-prices[i])
dp_i_1 = max(dp_i_1, dp_i_0-prices[i]);
}
return dp_i_0;
}
};
总结
- 买卖股票问题，有的能用贪心解决效率更高，但动态规划是统一方法，必须掌握，贪心不一定能想到
- 买卖股票问题有很多变种，记住最复杂的：dp[i][k][0]，三位数组，其他的都是在上面做加减法。