[leetcode]Best Time to Buy and Sell Stock III

先说思路。参考了这篇：http://blog.unieagle.net/2012/12/05/leetcode%E9%A2%98%E7%9B%AE%EF%BC%9Abest-time-to-buy-and-sell-stock-iii%EF%BC%8C%E4%B8%80%E7%BB%B4%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92/

我们可以看到这个相当于要分两段，取前一段和后一段的分别最大值。这样分割点遍历，最后是O(n^2)的复杂度。

然后优化后，使用一维的DP。可以降低到O(n)。也就是先从左到右扫一遍求得以i结尾的最大利润的数组，然后从右到左扫一遍求得以i开头的最大利润的数组。然后一加就可以了。

public class Solution {

    public int maxProfit(int[] prices) {

        // Start typing your Java solution below

        // DO NOT write main() function

        if (prices.length == 0 || prices.length == 1) return 0;

        int ans = 0;

        

        int max = 0;

        

        int len = prices.length;

        int historyProfit[] = new int[len];

        int futureProfit[] = new int[len];

        int valley  = prices[0];

        for (int i = 1; i < len; i++) {

        	if (prices[i] >= prices[i-1]) {

        		int val = prices[i] - valley ;

        		if (val > max) max = val;     		

        	}

        	else {

        		if (prices[i] < valley ) valley  = prices[i];

        	}

        	historyProfit[i] = max;

        }       

        

        int peek = prices[len - 1];

        ans = max;

        max = 0;

        for (int i = len - 2; i >= 1; i--) {

        	if (prices[i+1] >= prices[i]) {

        		 int val = peek - prices[i];

                 if (val > max) max = val;

        	}

        	else {

        		if (prices[i] > peek) peek = prices[i];

        	}

        	futureProfit[i] = max;

        	int p = futureProfit[i] + historyProfit[i-1];

        	if (p > ans) {

        		ans = p;

        	}

        }

        

        return ans;

    }

}

我的代码比较乱，看看参考代码多么简洁。同时，该讨论第二楼里还有关于更一般情况的讨论，有空好好看看。

class Solution {

public:

    int maxProfit(vector<int> &prices) {

        // null check

        int len = prices.size();

        if (len==0) return 0;



        vector<int> historyProfit;

        vector<int> futureProfit;

        historyProfit.assign(len,0);

        futureProfit.assign(len,0);

        int valley = prices[0];

        int peak = prices[len-1];

        int maxProfit = 0;



        // forward, calculate max profit until this time

        for (int i = 0; i<len; ++i)

        {

            valley = min(valley,prices[i]);

            if(i>0)

            {

                historyProfit[i]=max(historyProfit[i-1],prices[i]-valley);

            }

        }



        // backward, calculate max profit from now, and the sum with history

        for (int i = len-1; i>=0; --i)

        {

            peak = max(peak, prices[i]);

            if (i<len-1)

            {

                futureProfit[i]=max(futureProfit[i+1],peak-prices[i]);

            }

            maxProfit = max(maxProfit,historyProfit[i]+futureProfit[i]);

        }

        return maxProfit;

    }

};