Best Time to Buy and Sell Stock III

最开始的时候想法是对的，由于要求至多只能买卖两次，因此我可以设计一个指针，依次指过每一天，将整个过程分成两个部分，前半部分只允许买卖一次，后半部分也只允许买卖一次，这样求得过程最大值即可。于是算下来复杂度是 O(n^2) 的量级。很明显，这样是过不了测试样例的，因为有更好的 O(n) 的方法的存在。

于是我搜了一下别人的做法，发现这样的做法很好：

“改进的方法就是动态规划了，那就是第一步扫描，先计算出子序列[0,...,i]中的最大利润，用一个数组保存下来，那么时间是O(n)。
第二步是逆向扫描，计算子序列[i,...,n-1]上的最大利润，这一步同时就能结合上一步的结果计算最终的最大利润了，这一步也是O(n)。
所以最后算法的复杂度就是O(n)的。”

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/

于是就有了我下面的解法：

class Solution {
public:
    int maxProfit(vector<int> &prices) {
        if (prices.size() <= 1)
            return 0;
        vector<int> DP;
        int min = INT_MAX;
        int max = INT_MIN;
        for (int i = 0; i < prices.size(); ++i) {
            if (min > prices[i])
                min = prices[i];
            int profile = prices[i] - min;
            if (profile < 0) {
                profile = 0;
            }
            if (profile > max) {
                max = profile;
            }
            DP.push_back(max);
        }
        int high = INT_MIN;
        int res = INT_MIN;
        for (int i = prices.size() - 1; i >= 0; --i) {
            if (prices[i] > high)
                high = prices[i];
            int profile = high - prices[i];
            if (profile < 0)
                profile = 0;
            if (profile + DP[i] > res)
                res = profile + DP[i];
        }
        return res;
    }
};

http://oj.leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/