Leetcode | Best Time to Buy and Sell Stock

Best Time to Buy and Sell Stock I

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

If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.

这道题就是把差价最高的找出来，当然，买入点必须在卖出点之前。更新最低点，更新最低点后面的差价和总差价。

class Solution {
public:
    int maxProfit(vector<int> &prices) {
        if (prices.size() <= 1) return 0;
        int max = 0, min = prices[0], tmp;
        for (int i = 0; i < prices.size(); ++i) {
            tmp = prices[i] - min; 
            if (tmp < 0) min = prices[i];
            else if (tmp > max) max = tmp;
        }
        return max;
    }
};

Best Time to Buy and Sell Stock II

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 as many transactions as you like (ie, buy one and sell one share of the stock multiple times). However, you may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

方法一，需要跟踪仓位，跟踪区势，再决定买卖。

class Solution {
public:
    int maxProfit(vector<int> &prices) {
        if (prices.size() <= 1) {
            return 0;
        }
        int pos = 0, buy = 0, profit = 0, trend = -1, i = 0;
        for (; i < prices.size() - 1; i++) {
            if (prices[i] < prices[i + 1]) {
                if (trend == -1 && pos == 0) {
                    buy = prices[i];
                    pos = 1;
                }
                trend = 1;
            } else if (prices[i] > prices[i + 1]) {
                if (trend == 1 && pos > 0) {
                    profit += (prices[i] - buy);
                    pos = 0;
                }
                trend = -1;
            }
        }
        if (pos > 0) {
            profit += (prices[i] - buy);
        }
        return profit;
    }
};

方法二，上面的方法太复杂了。因为允许无限次的操作，所以只要是正的操作就都可以，把它们加起来就是了。

class Solution {
public:
    int maxProfit(vector<int> &prices) {
        if (prices.size() <= 1) {
            return 0;
        }
        int profit = 0, diff = 0;
        for (int i = 0; i < prices.size() - 1; i++) {
            diff = prices[i + 1] - prices[i];
            if (diff > 0) profit += diff;
        }
        return profit;
    }
};

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).

 一开始以为像第二题那么做就可以了，求每个波段的profit，然后将最大两个相加。Wrong Answer。想想也是，比如1,2,4,2,5,7，按这种算法得到的最大值是7-2=5，实际上应该是7-1=6。

于是改用DP的算法，设p[i...j]为从第i天到第j天的一次操作最大收益，我们要求的其实是p[0...n-1]。

最后的结果其实是max{p[0...k]+p[k+1...n-1], p[0...n-1]}。

这里其实已经包含以下两种情况：

1. [0, m]进行两次操作，[m+1,n-1]不进行操作。对应地可以找到0<k<m,使得在[0,k]进行一次操作，[k+1,m]进行另一次操作。[m+1,n-1]不进行操作，因为在[k+1,m]里已经找到[k+1,n-1]的最大获益区间。

2. [0,m]不进行操作，[m+1,n-1]进行两次操作。同1.

p[0..k]就是第一题啦，p[k+1...n-1]思路同p[0...k]，就是反向操作，只是p[0...k]是更新最低点，p[k+1...n-1]是更新最高点。

代码如下：

class Solution {
public:
    int maxProfit(vector<int> &prices) {
        if (prices.size() <= 1) return 0;
        
        int n = prices.size();
        vector<int> max(n, 0);
        
        // max[0...i]
        int min = prices[0], t, m = 0;
        for (int i = 1; i < prices.size(); ++i) {
            t = prices[i] - min;
            if (t < 0) min = prices[i];
            else if (t > m) m = t;
            max[i] = m;
            
        }
        
        int ret = max[n - 1], p = 0; 
        m = prices[n - 1];
        // max[j...n-1]
        for (int j = n - 2; j >= 1; --j) {
            t = m - prices[j];
            if (t < 0) m = prices[j];
            else if (t > p) {
                p = t;
                if (p + max[j - 1] > ret) ret = p + max[j - 1];
            }
        }
        return ret;
    }
};