LeerCode 123 Best Time to Buy and Sell Stock III之O(n)解法

Say you have an array for which the ith element is the price of a given stock on day i.

Design an algorithm to find the maximum profit. You may complete at most two transactions.

Note:

You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

才意识到能够在整个区间的每一点切开，然后分别计算左子区间和右子区间的最大值，然后再用O(n)时间找到整个区间的最大值。

看来以后碰到与2相关的问题，一定要想想能不能用二分法来做！

 

以下复制pickless的解说，我认为我不能比他讲的更好了

O(n^2)的算法非常easy想到：

找寻一个点j，将原来的price[0..n-1]切割为price[0..j]和price[j..n-1]，分别求两段的最大profit。

进行优化：

对于点j+1，求price[0..j+1]的最大profit时，非常多工作是反复的，在求price[0..j]的最大profit中已经做过了。

类似于Best Time to Buy and Sell Stock，能够在O(1)的时间从price[0..j]推出price[0..j+1]的最大profit。

可是怎样从price[j..n-1]推出price[j+1..n-1]？反过来思考，我们能够用O(1)的时间由price[j+1..n-1]推出price[j..n-1]。

终于算法：

数组l[i]记录了price[0..i]的最大profit，

数组r[i]记录了price[i..n]的最大profit。

已知l[i]，求l[i+1]是简单的，相同已知r[i]，求r[i-1]也非常easy。

最后，我们再用O(n)的时间找出最大的l[i]+r[i]，即为题目所求。

package Level4;  
   
import java.util.Arrays;  
   
/** 
 * Best Time to Buy and Sell Stock III 
 *  
 *  Say you have an array for which the ith element is the price of a given stock on day i. 
 
Design an algorithm to find the maximum profit. You may complete at most two transactions. 
 
Note: 
You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again). 
 * 
 */ 
public class S123 {  
   
    public static void main(String[] args) {  
//      int[] prices = {3,3,5,0,0,3,1,4};  
        int[] prices = {2,1,2,0,1};  
        System.out.println(maxProfit(prices));  
    }  
       
    // 基本思想是分成两个时间段，然后对于某一天，计算之前的最大值和之后的最大值  
    public static int maxProfit(int[] prices) {  
        if(prices.length == 0){  
            return 0;  
        }  
           
        int max = 0;  
        // dp数组保存左边和右边的利润最大值  
        int[] left = new int[prices.length];        // 计算[0,i]区间的最大值  
        int[] right = new int[prices.length];   // 计算[i,len-1]区间的最大值  
           
        process(prices, left, right);  
           
        // O(n)找到最大值  
        for(int i=0; i<prices.length; i++){  
            max = Math.max(max, left[i]+right[i]);  
        }  
           
        return max;  
    }  
       
    public static void process(int[] prices, int[] left, int[] right){  
        left[0] = 0;  
        int min = prices[0];  
           
        // 左边递推公式  
        for(int i=1; i<left.length; i++){  
            left[i] = left[i - 1] > prices[i] - min ? left[i - 1] : prices[i] - min;    
            min = prices[i] < min ? prices[i] : min;   
        }  
           
        right[right.length-1] = 0;  
        int max = prices[right.length-1];  
        // 右边递推公式  
        for(int i=right.length-2; i>=0; i--){  
            right[i] = right[i + 1] > max - prices[i] ? right[i + 1] : max - prices[i];    
            max = prices[i] > max ? prices[i] : max;    
        }  
           
//      System.out.println(Arrays.toString(left));  
//      System.out.println(Arrays.toString(right));  
    }  
   
}