|
|
package class15;
|
|
|
|
|
|
//leetcode 309
|
|
|
public class Code05_BestTimeToBuyAndSellStockWithCooldown {
|
|
|
|
|
|
// 该方法是对的，提交之后大量的测试用例通过，最后几个会超时
|
|
|
// 如果把这个方法改成动态规划，是可以通过的，但这个尝试不是最优解
|
|
|
public static int maxProfit1(int[] prices) {
|
|
|
return process1(prices, false, 0, 0);
|
|
|
}
|
|
|
|
|
|
// buy == false 目前可以交易，而且当前没有购买行为
|
|
|
// buy == true 已经买了，买入价buyPrices，待卖出
|
|
|
public static int process1(int[] prices, boolean buy, int index, int buyPrices) {
|
|
|
if (index >= prices.length) {
|
|
|
return 0;
|
|
|
}
|
|
|
if (buy) {
|
|
|
int noSell = process1(prices, true, index + 1, buyPrices);
|
|
|
int yesSell = prices[index] - buyPrices + process1(prices, false, index + 2, 0);
|
|
|
return Math.max(noSell, yesSell);
|
|
|
} else {
|
|
|
int noBuy = process1(prices, false, index + 1, 0);
|
|
|
int yesBuy = process1(prices, true, index + 1, prices[index]);
|
|
|
return Math.max(noBuy, yesBuy);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 最优尝试如下：
|
|
|
// buy[i] : 在0...i范围上，最后一次操作是buy动作，
|
|
|
// 这最后一次操作有可能发生在i位置，也可能发生在i之前
|
|
|
// buy[i]值的含义是：max{ 所有可能性[之前交易获得的最大收益 - 最后buy动作的收购价格] }
|
|
|
// 比如：arr[0...i]假设为[1,3,4,6,2,7,1...i之后的数字不用管]
|
|
|
// 什么叫，所有可能性[之前交易获得的最大收益 - 最后buy动作的收购价格]？
|
|
|
// 比如其中一种可能性：
|
|
|
// 假设最后一次buy动作发生在2这个数的时候，那么之前的交易只能在[1,3,4]上结束，因为6要cooldown的，
|
|
|
// 此时最大收益是多少呢？是4-1==3。那么，之前交易获得的最大收益 - 最后buy动作的收购价格 = 3 - 2 = 1
|
|
|
// 另一种可能性：
|
|
|
// 再比如最后一次buy动作发生在最后的1这个数的时候，那么之前的交易只能在[1,3,4,6,2]上发生，因为7要cooldown的，
|
|
|
// 此时最大收益是多少呢？是6-1==5。那么，之前交易获得的最大收益 - 最后buy动作的收购价格 = 5 - 1 = 4
|
|
|
// 除了上面两种可能性之外，还有很多可能性，你可以假设每个数字都是最后buy动作的时候，
|
|
|
// 所有可能性中，(之前交易获得的最大收益 - 最后buy动作的收购价格)的最大值，就是buy[i]的含义
|
|
|
// 为啥buy[i]要算之前的最大收益 - 最后一次收购价格？尤其是最后为什么要减这么一下？
|
|
|
// 因为这样一来，当你之后以X价格做成一笔交易的时候，当前最好的总收益直接就是 X + buy[i]了
|
|
|
//
|
|
|
// sell[i] :0...i范围上，最后一次操作是sell动作，这最后一次操作有可能发生在i位置，也可能发生在之前
|
|
|
// sell[i]值的含义：0...i范围上，最后一次动作是sell的情况下，最好的收益
|
|
|
//
|
|
|
// 于是通过分析，能得到以下的转移方程：
|
|
|
// buy[i] = Math.max(buy[i - 1], sell[i - 2] - prices[i])
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// 如果i位置没有发生buy行为，说明有没有i位置都一样，那么buy[i] = buy[i-1]，这显而易见
|
|
|
// 如果i位置发生了buy行为, 那么buy[i] = sell[i - 2] - prices[i]，
|
|
|
// 因为你想在i位置买的话，你必须保证之前交易行为发生在0...i-2上，
|
|
|
// 因为如果i-1位置有可能参与交易的话，i位置就要cooldown了，
|
|
|
// 而且之前交易行为必须以sell结束，你才能buy，而且要保证之前交易尽可能得到最好的利润，
|
|
|
// 这正好是sell[i - 2]所代表的含义，并且根据buy[i]的定义，最后一定要 - prices[i]
|
|
|
//
|
|
|
// sell[i] = Math.max(sell[i - 1], buy[i - 1] + prices[i])
|
|
|
// 如果i位置没有发生sell行为，那么sell[i] = sell[i-1]，这显而易见
|
|
|
// 如果i位置发生了sell行为，那么我们一定要找到 {之前获得尽可能好的收益 - 最后一次的收购价格尽可能低}，
|
|
|
// 而这正好是buy[i - 1]的含义！之前所有的"尽可能"中，最好的一个！
|
|
|
public static int maxProfit2(int[] prices) {
|
|
|
if (prices.length < 2) {
|
|
|
return 0;
|
|
|
}
|
|
|
int N = prices.length;
|
|
|
int[] buy = new int[N];
|
|
|
int[] sell = new int[N];
|
|
|
// buy[0] 不需要设置 buy[0] = -arr[0]
|
|
|
// sell[0] = 0
|
|
|
buy[1] = Math.max(-prices[0], -prices[1]);
|
|
|
sell[1] = Math.max(0, prices[1] - prices[0]);
|
|
|
for (int i = 2; i < N; i++) {
|
|
|
buy[i] = Math.max(buy[i - 1], sell[i - 2] - prices[i]);
|
|
|
sell[i] = Math.max(sell[i - 1], buy[i - 1] + prices[i]);
|
|
|
}
|
|
|
return sell[N - 1];
|
|
|
}
|
|
|
|
|
|
// 最优解就是方法2的空间优化而已
|
|
|
public static int maxProfit3(int[] prices) {
|
|
|
if (prices.length < 2) {
|
|
|
return 0;
|
|
|
}
|
|
|
int buy1 = Math.max(-prices[0], -prices[1]);
|
|
|
int sell1 = Math.max(0, prices[1] - prices[0]);
|
|
|
int sell2 = 0;
|
|
|
for (int i = 2; i < prices.length; i++) {
|
|
|
int tmp = sell1;
|
|
|
sell1 = Math.max(sell1, buy1 + prices[i]);
|
|
|
buy1 = Math.max(buy1, sell2 - prices[i]);
|
|
|
sell2 = tmp;
|
|
|
}
|
|
|
return sell1;
|
|
|
}
|
|
|
|
|
|
}
|
