给定一个整数数组 prices ,它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 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 。
提示:
0 <= k <= 100
0 <= prices.length <= 1000
0 <= prices[i] <= 1000
这里与123. 买卖股票的最佳时机 III对比,进行二次扩展,限制可进行k次交易
即更为一般的规律。
for(int i = 1; i < len; i++){
dp[i][1][1] = Math.max(dp[i - 1][1][1], -prices[i]);
//交易一次,且当前持股,可以上次相同状态转化而来,或者当前第一次买入
dp[i][1][0] = Math.max(dp[i - 1][1][0], dp[i - 1][1][1] + prices[i]);
//交易一次,当前不持股:延续上次状态,或者上次买入现在卖出
dp[i][2][1] = Math.max(dp[i - 1][2][1], dp[i - 1][1][0] - prices[i]);
//交易两次,当前持股:延续上次状态,或者第一次卖出,但有利润累计,这次再次买入
//注意需要参考dp[i - 1][2][1],若为dp[1][2][1],需参考dp[0][2][0],这里设为最小值
//,就是防止被参考到,因为才第二次,不可能交易两次
dp[i][2][0] = Math.max(dp[i - 1][2][0], dp[i - 1][2][1] + prices[i]);
//交易两次,当前不持股:延续上次状态,或者第一次买入,这次卖出
//若为dp[1][2][0],需参考dp[0][2][1],这里设为最小值,同样防止被参考
}
对比一下核心代码即可知道,可以换为一般形式,
dp[i][1][1] = Math.max(dp[i - 1][1][1], -prices[i]);
这个需要换一下形式为,dp[i][2][1] = Math.max(dp[i - 1][2][1], dp[i - 1][1][0] - prices[i]);
由于涉及到j-1或者i-1,扩展一下数组范围,统一+1比较好
若想提前初始化一下,其实无法实现,首先k的取值不确定,k 若小于2,则运行时错误,越界,还是整体初始化比较好
public int maxProfit(int k, int[] prices) {
int len = prices.length;
// 特殊判断
if (k == 0 || len < 2) {
return 0;
}
// 特殊判断,因为交易一次需要 2 天,如果 k >= len / 2,相当于没有限制
// 转换为「力扣」第 122 题,使用贪心算法
if (k >= len / 2) {
return greedy(prices, len);
}
int[][][] dp = new int[len + 1][k + 1][2];
// 初始化:把持股的部分都设置为一个较小的负值
// 注意:如果使用默认值 0,状态转移的过程中会做出错误的决策
for(int i = 0; i <= len; i++){
for(int j = 0; j <= k;j++){
dp[i][j][1] = Integer.MIN_VALUE;
}
}
// 注意:i 和 j 都有 1 个位置的偏移
for (int i = 1; i <= len; i++) {
for (int j = 1; j <= k; j++) {
//注意prices对应的下标为i - 1
dp[i][j][1] = Math.max(dp[i - 1][j][1], dp[i - 1][j - 1][0] - prices[i - 1]);
//要么状态保持不变,或者上次不持股,现在买入
dp[i][j][0] = Math.max(dp[i - 1][j][0], dp[i - 1][j][1] + prices[i - 1]);
//要么状态保持不变,或者上次持股的累计值,现在抛出。
//注意与上面的区别在于 dp[i - 1][j][1],注意下标不是j -1;
}
}
// 说明:第一维和第二维状态都具有前缀性质的,输出最后一个状态即可
//只是表示一个状态,但我觉得k(0-k-1)都对比一下更稳妥
return dp[len][k][0];
}
private int greedy(int[] prices, int len) {
// 转换为股票系列的第 2 题,使用贪心算法完成,思路是只要有利润,就交易
int res = 0;
for (int i = 1; i < len; i++) {
if (prices[i] > prices[i - 1]) {
res += prices[i] - prices[i - 1];
}
}
return res;
}
2.缩小一下空间
public int maxProfit(int k, int[] prices) {
int len = prices.length;
// 特殊判断
if (k == 0 || len < 2) {
return 0;
}
// 特殊判断,因为交易一次需要 2 天,如果 k >= len / 2,相当于没有限制
// 转换为「力扣」第 122 题,使用贪心算法
if (k >= len / 2) {
return greedy(prices, len);
}
int[][] dp = new int[k + 1][2];
for(int i = 0; i <= k; i++){
dp[i][1] = Integer.MIN_VALUE;
}
for(int price : prices){
for(int i = 1; i <= k; i++){
//因为从头开始,可以直接参考本身
dp[i][1] = Math.max(dp[i][1], dp[i - 1][0] - price);
//dp[i][0] = Math.max(dp[i][0], dp[i - 1][1] + price);
//注意这里不一样,为dp[i][1] + price,因为要参考的是相同k的状态
dp[i][0] = Math.max(dp[i][0], dp[i][1] + price);
}
}
return dp[k][0];
}
private int greedy(int[] prices, int len) {
// 转换为股票系列的第 2 题,使用贪心算法完成,思路是只要有利润,就交易
int res = 0;
for (int i = 1; i < len; i++) {
if (prices[i] > prices[i - 1]) {
res += prices[i] - prices[i - 1];
}
}
return res;
}