123. Best Time to Buy and Sell Stock III

http://www.cnblogs.com/grandyang/p/4281975.html
https://blog.csdn.net/linhuanmars/article/details/23236995
https://blog.csdn.net/liuchonge/article/details/73274871

方法1: dynamic programming，two passes

思路：

这个方法参考了上面第三个博主的第一种方法，用两次遍历找出两次最佳交易的时间。第一次基本和121一样，不同的是为了找出第一次交易的最大利润并且记录交易发生的时间，不能只记录利润，要维持一个vector，记录“在第n天以前进行一次交易最大利润”。第二次从后往前找和第一次找buy的最低点原理一样， 找到sell的最高点，并更新此时如果买入和之后最高点之间能赚取的两次累计最大利润。注意这个利润需要加上第一次截止买入日期为止能赚取的最大利润，两者求和取最大值。这个方法比较慢，25%/

易错点：

1. maxBefore(n+ 1, 0)， 和prices的index不一样

Complexity

Time complexity: O(n)
Space complexity: O(n)

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() <= 1) return 0;
        int n = prices.size();
        // 第一次循环，找到每一步能够得到的最大利润值
        vector<int> maxBefore(n + 1 , 0);
        int buy = INT_MAX;
        for (int i = 1; i < n + 1; i++){
            maxBefore[i] = max(maxBefore[i - 1], prices[i - 1] - buy);
            buy = min(buy, prices[i - 1]);
        }
        
        int sell = INT_MIN;
        int result = 0;
        for (int i = n - 1; i >= 0; i--){
            sell = max(sell, prices[i]);
            result = max(result, sell - prices[i] + maxBefore[i + 1]);
        }
        
        return result;

    }
};

方法2: dynamic programming，one-pass，2-dimension

思路：

可以看上面前两篇博客，以及discussion。
首先是第二篇博客中分析的，将问题generalize为最多进行k次交易。那么maintain两个dp，一个是local[i][j], i = {1,…,n}, j = {1, …, k}, 记录到第 i 天为止，在当天进行了第 j 次卖出的解当中中，最大可能利润；另一个是global[i][j], 记录到第 i 天为止，进行了 j 次交易的最大可能利润。那么global的转移方程是：global[i][j] = max(global[i - 1][j], local[i][j])，也就是第i天卖出和没有卖出的较大解。而local[i][j]的转移方程式是：local[i][j] = max(global[i - 1][j - 1] + max(diff, 0), local[i - 1][j] + diff)。第一项是在前一天进行完 j - 1次交易，并且i - 1买，i 卖出的净利润diff = prices[i] - prices[i - 1]。取max(diff, 0)是因为如果亏钱，宁可少交易一次也不会买入。第二项是在第i - 1天卖出第 j 次的利润 + 如果将本打算在第i - 1天卖出的股票放到第 i 天卖出的差值。这里因为规定了第 i 天必须卖出，所以不管正负都要加进去。 代码参考了第一篇博客。

易错点

1. 如果只有一天是赚不到前的
2. 初始化i = 0和j = 0 全部是0：因为一天无法赚钱，不卖无法赚钱
3. local要比global先计算，因为global[i][j]用到了local[i][j]

Complexity

Time complexity: O(n)
Space complexity: O(kn)

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() <= 1) return 0;
        int n = prices.size();
        vector<vector<int>> local(n, vector<int>(3, 0));
        vector<vector<int>> global(n, vector<int>(3, 0));
        
        for (int i = 1; i < n; i++){
            for (int j = 1; j < 3; j++){
                int diff = prices[i] - prices[i - 1];
                local[i][j] = max(global[i - 1][j - 1] + max(diff, 0), local[i - 1][j] + diff);
                global[i][j] = max(local[i][j], global[i - 1][j]);
            }
        }
        
        return global[n - 1][2];

    }
};

方法3: dynamic programming， one-pass，1-dimension

思路：

观察到上面的转移方程式可以用一维变量来维护，可以减少空间复杂度。代码参考第一篇博客。

易错点

1. 这个时候必须从后往前扫 j ， 因为l[j]用到了g[j - 1]， 从前往后g[j - 1]就已经被覆盖了。

class Solution {
public:
    int maxProfit(vector<int> &prices) {
        if (prices.empty()) return 0;
        int g[3] = {0};
        int l[3] = {0};
        for (int i = 0; i < prices.size() - 1; ++i) {
            int diff = prices[i + 1] - prices[i];
            for (int j = 2; j >= 1; --j) {
                l[j] = max(g[j - 1] + max(diff, 0), l[j] + diff);
                g[j] = max(l[j], g[j]);
            }
        }
        return g[2];
    }
};