[LeetCode]123. Best Time to Buy and Sell Stock III

[LeetCode]123. Best Time to Buy and Sell Stock III

题目描述

思路

动态规划
举例来说

index	0	1	2	3	4	5
原数组	3	2	6	5	0	3
到当前位置的最小值	3	2	2	2	0	0
到当前位置的最大收益	0	0	4	4	4	4
从当前位置到结尾的最大值	6	6	6	5	3	3
从当前位置到结尾的最大收益	4	4	3	3	3	0

因为买入卖出不能同时进行，所以将最大收益数组对角求和取最大值
在这个例子中是
max(4, 0 + 4, 0 + 3, 4 + 3, 4 +3, 4 + 0) = 7
即为最终结果

代码

自己写的O(n)时间、O(1)空间的代码

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        if (len == 0)
            return 0;
        vector<int> curPreMin(len), curPostMax(len), curPreMaxGap(len), curPostMaxGap(len);

        curPreMin[0] = prices[0];
        curPreMaxGap[0] = 0;
        for (int i = 1; i < len; ++i){
            curPreMin[i] = min(curPreMin[i - 1], prices[i]);
            curPreMaxGap[i] = max(curPreMaxGap[i - 1], prices[i] - curPreMin[i]);
        }

        curPostMax[len - 1] = prices[len - 1];
        curPostMaxGap[len - 1] = 0;
        for (int i = len - 2; i >= 0; --i) {
            curPostMax[i] = max(curPostMax[i + 1], prices[i]);
            curPostMaxGap[i] = max(curPostMaxGap[i + 1], curPostMax[i] - prices[i]);
        }

        int res = curPostMaxGap[0];
        for (int i = 0; i < len - 1; ++i)
            res = max(res, curPreMaxGap[i] + curPostMaxGap[i + 1]);

        return res;
    }
};

int main() {
    vector<int> prices = { 3,2,6,5,0,3 };
    Solution s;
    cout << s.maxProfit(prices) << endl;

    system("pause");
    return 0;
}

ps：答案给出了O(1)空间的代码

/*
It is similar to other buy/sell problems. just do DP and define an array of states to track the current maximum profits at different stages. For example, in the below code

states[][0]: one buy
states[][1]: one buy, one sell
states[][2]: two buys, one sell
states[][3]: two buy, two sells
The states transistions occurs when buy/sell operations are executed. For example, state[][0] can move to state[][1] via one sell operation.
*/

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int states[2][4] = {INT_MIN, 0, INT_MIN, 0}; // 0: 1 buy, 1: one buy/sell, 2: 2 buys/1 sell, 3, 2 buys/sells
        int len = prices.size(), i, cur = 0, next =1;
        for(i=0; i<len; ++i)
        {
            states[next][0] = max(states[cur][0], -prices[i]);
            states[next][1] = max(states[cur][1], states[cur][0]+prices[i]);
            states[next][2] = max(states[cur][2], states[cur][1]-prices[i]);
            states[next][3] = max(states[cur][3], states[cur][2]+prices[i]);
            swap(next, cur);
        }
        return max(states[cur][1], states[cur][3]);
    }
};