LeetCode123-买卖股票的最佳时机III

LeetCode123-买卖股票的最佳时机III

题目

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

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

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

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

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

解法

方法一：
思路：因为是最多完成两笔交易，这个题是121题的一个延伸，可以将这个问题看成将一段时期切成两段看。
先按照121题的第二个方法进行一次遍历，得到只交易一次的最大值，同时也用数组maxPro得到了第i天时的最大值，maxPro[i]代表，到第i天时，能获得的最大值。使用maxPro数组中的值加上[i+1:len]中的最大值，就可以得到两次交易的最大值。

class Solution {
    public int maxProfit(int[] prices) {
        if(prices.length == 0) return 0;
        int len = prices.length;
        //一次交易时到第i天时的最大值
        int[] maxPro = new int[len];
        maxPro[0] = 0;
        int max = 0;
        int min = prices[0];
        for(int i = 1 ; i < len ; ++i){
            if(prices[i]<min){
                min = prices[i];
            }else{
                int cur = prices[i]-min;
                max = Math.max(max,cur);
                maxPro[i] = max;
            }
        }
        //如果一次交易过后，最大值是0，那不用二次交易了
        if(max==0) return max;
		//第二次交易，是在第一次交易的基础上，找第i天之后的最大值
        for(int i = 0 ; i < len - 2; ++i){
            int left = maxPro[i];
            if(i+1<len){
                int minRight = prices[i+1];
                for(int j = i + 1; j < len ; ++j){
                    if(prices[j]<minRight){
                        minRight = prices[j];
                    }else{
                        int cur = prices[j]-minRight;
                        max = Math.max(max,cur+left); 
                    }
                }
            }
        }
        return max;
    }
}

方法二：dp未经过优化，使用三维数组

1. 定义状态：
dp一维日期，二维持有状态，0，不持有股票，1持有股票,三维卖出次数：0 ，1，2
dp[i][j][k] 表示：在下标为 i 的这一天，用户手上持股状态为 j 所获得的最大利润，同时在之前和今天已经出售了k次了。

2. DP方程过程：
2.1 第i天不持有股票：
（1）之前从未卖出过：dp[i][0][0] =dp[i-1][0][0]
（2）之前和今天卖出过一次：dp[i][0][1] = Math.max(dp[i-1][0][1],dp[i-1][1 ][0]+price[i])
（3）之前和今天已经卖出过两次:dp[i][0][2] = Math.max(dp[i-1][0][2],dp[i-1][1][1]+price[i])
2.2第i天持有股票
（1）之前从未卖出过：dp[i][1][0]=Math.max(dp[i-1][1][0],dp[i-1][0][0]-price[I])
（2）之前和今天卖出过一次：dp[i][1][1]=Math.max(dp[i-1][1][1],dp[i-1][0][1]-price[I])
（3）之前和今天已经卖出过两次:该情况不存在

3.DP方程初始状态
（1）第一天持有：dp[0][1][?] = -price[0]
（2）第一天不持有：dp[0][1][?] = 0

4.结果
获取最大收益,一定是用户手上不在持有股票，可能交易过一次，也可能交易过两次
Math.max(dp[len-1][0][2],dp[len-1][0][1]);

class Solution {
    public int maxProfit(int[] prices) {
        int len = prices.length;
        if(len < 1) return 0;
        int[][][] dp = new int[len][2][3];
        dp[0][0][0] = 0;
        dp[0][0][1] = 0;
        dp[0][0][2] = 0;
        dp[0][1][0] = -prices[0];
        dp[0][1][1] = -prices[0];
        dp[0][1][2] = -prices[0];
        
        for(int i = 1 ; i < len ; ++i){
            int cur = prices[i];
            dp[i][0][0] = dp[i-1][0][0];
            dp[i][0][1] = Math.max(dp[i-1][0][1],dp[i-1][1][0]+cur);
            dp[i][0][2] = Math.max(dp[i-1][0][2],dp[i-1][1][1]+cur);
            dp[i][1][0] = Math.max(dp[i-1][1][0],dp[i-1][0][0]-cur);
            dp[i][1][1] = Math.max(dp[i-1][1][1],dp[i-1][0][1]-cur);
        }
        return Math.max(dp[len-1][0][2],dp[len-1][0][1]);
    }
}

方法三：dp，方法二的优化，使用二维数组

1.状态：0，未交易，1，买入一次，2卖出1次，3买入2次，4卖出2次

2. DP公式
   dp[i][j]为 用户手上金钱，i是日期，j是状态。
   - dp[i][0] = dp[i-1][0]
   - dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]-prices[i]);
   - dp[i][2] = Math.max(dp[i-1][2],dp[i-1][1]+prices[i]);
   - dp[i][3] = Math.max(dp[i-1][3],dp[i-1][2]-prices[i]);
   - dp[i][4] = Math.max(dp[i-1][4],dp[i-1][3]+prices[i]);

class Solution {
    public int maxProfit(int[] prices) {
        int len = prices.length;
        if(len == 0) return 0;
        int[][] dp = new int[len][5];
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        dp[0][2] = 0;
        dp[0][3] = -prices[0];
        dp[0][4] = 0;
        for(int i = 1 ; i < len ; ++i){
            int cur = prices[i];
            dp[i][0] = dp[i-1][0];
            dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]-cur);
            dp[i][2] = Math.max(dp[i-1][2],dp[i-1][1]+cur);
            dp[i][3] = Math.max(dp[i-1][3],dp[i-1][2]-cur);
            dp[i][4] = Math.max(dp[i-1][4],dp[i-1][3]+cur);
        }
        return Math.max(dp[len-1][2],dp[len-1][4]);
    }
}

方法四：方法三的再次优化，使用一维数组

class Solution {
    public int maxProfit(int[] prices) {
        int len = prices.length;
        if(len == 0) return 0;
        int[] dp = new int[5];
        dp[0] = 0;
        dp[1] = -prices[0];
        dp[2] = 0;
        dp[3] = -prices[0];
        dp[4] = 0;
        for(int i = 1 ; i < len ; ++i){
            int cur = prices[i];
            dp[4] = Math.max(dp[4],dp[3]+cur);
            dp[3] = Math.max(dp[3],dp[2]-cur);
            dp[2] = Math.max(dp[2],dp[1]+cur);
            dp[1] = Math.max(dp[1],dp[0]-cur);
        }
        return Math.max(dp[2],dp[4]);
    }
}