Day 54
01. 买卖股票的最佳时机 III(NO. 123)
<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
提示:
1 <= prices.length <= 105
0 <= prices[i] <= 105
<2> 笔记
相比于之前的 I 版本和 II 版本,本题的情况就多了起来,因为可以买卖一次 或者 两次。
但其实其 状态 还是不变的,即 在某种情况下通过买卖股票获得的金钱的最大值。
与前面的买入或者卖出状态不同,本题有四种状态:第一次买入、第一次卖出、第二次买入 和 第二次卖出。
这样就可以将买卖的次数限制在 两次 了;其实有了上面的思路,递推公式的推导是很简单的,只是要注意,上面说的状态指的不是在 这一天 转变为了该状态,而是说在这一天 处于 该状态,即可能是保持前一天的状态。
现在来声明一个 dp
数组,行数为prices.length
,列 0 1 2 3
分别代表一下的情况
第一次买入的情况:
- 是今天买入的:
-prices[i]
- 是昨天买入的:
dp[i - 1][0]
第一次卖出的情况
- 是今天卖出的,第一次卖出只能在第一次买入的情况下推导,即:
dp[i - 1][0] + prices[i]
- 是昨天卖出的:
dp[i - 1][1]
第二次买入的情况
- 同样,第二次买入是建立在第一次卖出的情况的:
dp[i - 1][1] - prices[i]
- 是昨天买入的:
dp[i - 1][2]
第二次卖出的情况
- 建立在第二次买入的基础上:
dp[i - 1][2] + prices[i]
- 是昨天卖出的:
dp[i - 1][3]
以上的四种情况,对每个分支求一个最大值,就是今天的这个状态的最优解。
现在来考虑初始化,对于第一天买入还是好考虑的,即初始化为 -prices[0]
,第一天卖出即为 0
,同样,第二天卖出也为 0
现在要考虑的就是第二天买入,对于第一天来说,第二次买入是不存在的情况,在第二天的时候这个列才是有意义的,但它能被初始化为 0
吗 ?看一下第二次买入的公式,如果说第二次卖出被初始化为 0
,那从第二天开始得到的结果就是错误的,第二天原本应该是 -prices[1]
,但此时变成了 0
。
所以对于这种情况,应该初始化为 Integer.MIN_VALUE
来避免它不会干扰后续的计算。
其实按照这种考虑来说,第一天卖出和第二次卖出也应该初始化这个值,但是因为这两个都是卖出的情况,所得的结果都是大于等于 0
的,所以初始化成 0
不会对其产生影响。
<3> 代码
class Solution {
public int maxProfit(int[] prices) {
int[][] dp = new int[prices.length][4];
dp[0][0] = -prices[0]; // 第一次持有股票
dp[0][2] = Integer.MIN_VALUE; // 第二次持有股票
for (int i = 1; i < prices.length; i++) {
dp[i][0] = Math.max(-prices[i], dp[i - 1][0]); // 第一次持有股票
dp[i][1] = Math.max(dp[i - 1][0] + prices[i], dp[i - 1][1]) ; // 第一次卖出股票
dp[i][2] = Math.max(dp[i - 1][1] - prices[i], dp[i - 1][2]); // 第二次买入股票
dp[i][3] = Math.max(dp[i - 1][2] + prices[i], dp[i - 1][3]); // 第二次卖出股票
}
return Math.max(dp[prices.length - 1][1], dp[prices.length - 1][3]);
}
}
02. 买卖股票的最佳时机 IV(No. 188)
<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 。
提示:
1 <= k <= 100
1 <= prices.length <= 1000
0 <= prices[i] <= 1000
<2> 笔记
做本题之前一定要完成上一题,这样对本题的思路很有帮助。
本题在上一题的基础上,将买卖次数从 2 次拓展到了 k 次;延续上一题的思路,那无非就是每天记录 k
种状态嘛?
思路确实就是这样,但本题难的是初始化和循环控制。
上题中提到,对于第一天来说,除了第一次买入其他都是没有意义的,所以其他直接初始化为 Integer.MIN_VALUE
,本题同样(但这样初始化是会出现错误的,后面再提),那对于第二天来说,只有第二次买入和第二次卖出是有意义的,其他仍然需要保持初始值;这就让我想到了滚动数组,可以避免对每行重复的初始化。
所以对于第二天来说,有意义的就是下标为 0 1 2 3 的值,对于第三天则是 0 1 2 3 4 5 这些值,所以对于第 k 天就是 0 到 2k - 1 这个范围内的下标。
对于第下标为 j 的值,是依赖于昨天的下标为 j 的值和昨天的下标为 j – 1 的值。比如,对于买入的情况:
dp[j] = Math.max(dp[j - 1] - prices[i], dp[j]);
,依赖的就是昨天的第 j 次买入,或者昨天的第 j - 1 次卖出,因为每天只能持有一股股票。
对于卖出的情况也很容易写出来:dp[j] = Math.max(dp[j - 1] + prices[i], dp[j]);
。
然后因为 0 - 1
没有意义,所以下标为 0
的要单独列出,所以就非常自然的写出了如下的代码
for (int i = 1; i < prices.length; i++) {
for (int j = 0; j < 2 * i && j < dp.length; j++) { // 同时要保证 j 不越界
if (j == 0) {
dp[0] = Math.max(-prices[i], dp[0]); // 第一次买入的情况
} else if (j % 2 == 0) {
temp1 = dp[j];
dp[j] = Math.max(dp[j - 1] - prices[i], dp[j]); // 第 j 次买入的情况
} else {
temp2 = dp[j];
dp[j] = Math.max(dp[j - 1] + prices[i], dp[j]);
res = Math.max(dp[j], res);
}
}
}
但是这样有个很明显的错误,比如说在第二天,首先更新的是下标为 0
的部分,然后更新下标为 1
的部分,然而,在更新下标为 1
的部分的时候,用到了前面更新的值,导致了错误。那如何解决呢?
因为每次更新都是顺序的,在更新完 1
后面更新的一定是 2
,2
后面的一定是 3
,所以在每次更新之前 将本次的初始值记录下来,这样就能保证依赖的准确性。
声明两个变量 temp1
和 temp2
来分别存储,买入和卖出状态的初始值
for (int j = 0; j < 2 * i && j < dp.length; j++) {
if (j == 0) {
dp[0] = Math.max(-prices[i], dp[0]); // 第一次买入的情况
} else if (j % 2 == 0) {
temp1 = dp[j];
dp[j] = Math.max(temp2 - prices[i], dp[j]); // 第 j 次买入的情况
} else {
temp2 = dp[j];
dp[j] = Math.max(temp1 + prices[i], dp[j]);
res = Math.max(dp[j], res);
}
}
这样就能实现存储,但需要注意的是,每一层开始都要进行初始化,否则利用的实际上是上一层最后的值:
temp1 = dp[0];
因为第一次使用的是下标为 0
的部分,所以 temp2
的值是不需要初始化的,这样就完成了递推公式的推导。
再来看初始化,直接初始化为 Integer.MIN_VALUE
是有可能引发越界的,上一题因为只初始化了第一天所以不会产生影响,而本题就不同了。所以要找一个比所有卖出状态下 dp
数组的值还要小的一个值来初始化数组。
而恰好题目中提到了,prices[i] <= 1000
,那这个值就是 -1000
,因为在循环过程中只能持有一张股票,所以数组的值再小也不可能小于 1000
。
这样初始化也就解决了,给出代码。
<3> 代码
class Solution {
public int maxProfit(int k, int[] prices) {
int[] dp = new int[2 * k];
dp[0] = -prices[0];
int res = 0;
for (int i = 1; i < dp.length; i++) {
dp[i] = -1000;
}
int temp1 = 0;
int temp2 = 0;
for (int i = 1; i < prices.length; i++) {
temp1 = dp[0];
for (int j = 0; j < 2 * i && j < dp.length; j++) {
if (j == 0) {
dp[0] = Math.max(-prices[i], dp[0]); // 第一次买入的情况
} else if (j % 2 == 0) {
temp1 = dp[j];
dp[j] = Math.max(temp2 - prices[i], dp[j]); // 第 j 次买入的情况
} else {
temp2 = dp[j];
dp[j] = Math.max(temp1 + prices[i], dp[j]);
res = Math.max(dp[j], res);
}
}
}
return res;
}
}