leetcode 123. 买卖股票的最 佳时机 III hard

leetcode 123. 买卖股票的最佳时机 III  hard       

题目描述：

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。

注意: 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: [3,3,5,0,0,3,1,4]
输出: 6
解释: 在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
     随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。
示例 2:

输入: [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。   
     注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。   
     因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3:

输入: [7,6,4,3,1] 
输出: 0 
解释: 在这个情况下, 没有交易完成, 所以最大利润为 0。

解题思路：

挺好的总结： 力扣

经典dp题。可以从两个角度理解：

完整参考：here

dp[i][k][1 或者 0] 

i表示第i天，k表示最多进行了k次交易，第3个维度 0表示现在没有持有股票，1表示现在持有股票

dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
              max(   选择 rest  ,           选择 sell      )

解释：今天我没有持有股票，有两种可能：
要么是我昨天就没有持有，然后今天选择 rest，所以我今天还是没有持有；
要么是我昨天持有股票，但是今天我 sell 了，所以我今天没有持有股票了。

dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
              max(   选择 rest  ,           选择 buy         )

解释：今天我持有着股票，有两种可能：
要么我昨天就持有着股票，然后今天选择 rest，所以我今天还持有着股票；
要么我昨天本没有持有，但今天我选择 buy，所以今天我就持有股票了。

我们在选择 buy 的时候，把 k 减小了 1，很好理解吧，当然你也可以在 sell 的时候减 1，一样的。

代码一：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        //  k1：最多进行1次交易的最大获利  0：代表当前没有持有股票， 1：代表当前持有股票
        //  初值的设定,还没开始交易，自然  _0的初值都是0， _1的初值是无穷小
        int dp_k1_0 = 0;
        int dp_k1_1 = INT_MIN;
        int dp_k2_0 =0;
        int dp_k2_1 = INT_MIN;
        
        int dp_k0_0 = 0; // 最多进行0次交易的最大获利，且当前没有股票 自然是0
        //int dp_k0_1 = INT_MIN;  这一题不需要这个变量 
        
        for(int i:prices){
            //因为使用了压缩空间的技巧，所以先k2，再k1，先_0再_1,这样实际上一天的值才不会被覆盖
            // 如果不空间压缩，顺序无所谓
            dp_k2_0=max(dp_k2_0,dp_k2_1+i);
            dp_k2_1=max(dp_k2_1,dp_k1_0-i);
            
            dp_k1_0=max(dp_k1_0,dp_k1_1+i);
            dp_k1_1=max(dp_k1_1,-i); //实际是dp_k1_1=max(dp_k1_1,dp_k0_0-i);
            

        }
        
		return dp_k2_0;
    }
};

第二个角度：英文leetcode评论区  （要fan~qiang~）

可以直接看代码，其实是一样的（高星评论给调了顺序，第一眼看上去更符合直观，但是我觉得真正的顺序应该是第一个角度的顺序）

代码二：

//原代码，跟上面的角度是一样的
public class Solution {
    public int maxProfit(int[] prices) {
        int hold1 = Integer.MIN_VALUE, hold2 = Integer.MIN_VALUE;
        int release1 = 0, release2 = 0;
        for(int i:prices){                              // Assume we only have 0 money at first
            release2 = Math.max(release2, hold2+i);     // The maximum if we've just sold 2nd stock so far.
            hold2    = Math.max(hold2,    release1-i);  // The maximum if we've just buy  2nd stock so far.
            release1 = Math.max(release1, hold1+i);     // The maximum if we've just sold 1nd stock so far.
            hold1    = Math.max(hold1,    -i);          // The maximum if we've just buy  1st stock so far. 
        }
        return release2; ///Since release1 is initiated as 0, so release2 will always higher than release1.
    }
}




//调了顺序的代码
public int maxProfit(int[] prices) {
    int oneBuy = Integer.MIN_VALUE;
    int oneBuyOneSell = 0;
    int twoBuy = Integer.MIN_VALUE;
    int twoBuyTwoSell = 0;
    for(int i = 0; i < prices.length; i++){
        oneBuy = Math.max(oneBuy, -prices[i]);//we set prices to negative, so the calculation of profit will be convenient
        oneBuyOneSell = Math.max(oneBuyOneSell, prices[i] + oneBuy);
        twoBuy = Math.max(twoBuy, oneBuyOneSell - prices[i]);//we can buy the second only after first is sold
        twoBuyTwoSell = Math.max(twoBuyTwoSell, twoBuy + prices[i]);
    }
    
    return Math.max(oneBuyOneSell, twoBuyTwoSell);
}