leetcode123:买卖股票的最佳时机 III

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。

注意: 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

实例1

输入: [3,3,5,0,0,3,1,4] 输出: 6 解释: 在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。

实例2

输入: [1,2,3,4,5] 输出: 4 解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 =5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

不同于买卖股票的最佳时机的前两道题，这道题明显是dp问题，因为本题限制了交易次数，所以就有了Leetcode上面的得magic解法，但是如果不限制交易次数，那么这道题就要用经典DP来解，下面先来介绍这个magic解法。

int maxProfit1(vector<int>& prices) {
        if(prices.size()==1||prices.size()==0)return 0;

        int buy1 = -prices[0], buy2 = -prices[0];
        int sell1 = 0, sell2 = 0;
        
        for(int i=0;i<prices.size();i++){
            buy1=max(buy1,-prices[i]);
            sell1=max(buy1+prices[i],sell1);
            buy2=max(buy2,sell1-prices[i]);
            sell2=max(buy2+prices[i],sell2);
        }
        return sell2;
    }

其中，buy1代表第一次买入，sell表示第一次卖出，buy2代表第二次买入，sell2代表第二次卖出。直观理解是buy是要花钱的，即减去当日的交易价格，sell就是卖出即加上当日的交易价格那么就有:

buy1=max(buy1,-prices[i]),
sell1=max(buy1+prices[i],sell1)
buy2=max(buy2,sell1-prices[i])
sell2=max(sell2,prices[i]+buy2)

接下来介绍常规的DP解法，假设我们可以进行K次交易。dp[k][i]代表前i个日子进行K次交易最大的收益值。

dp[k][j]=max(dp[k][j-1],dp[k-1][j-1]+prices[i]-prices[j])(j is range(0,i))
dp[k][j]=max(dp[k][j-1],prices[i]+max(dp[k-1][j-1]-prices[j])

代码如下：

int maxProfit(vector<int>& prices) {
        if(prices.size()<=1)return 0;
        int K=3;
        vector<vector<int>>dp(K,vector<int>(prices.size(),0));
        for( int k=1;k<K;k++){
           // int max_pf=-prices[0];
            for(int i=1;i<prices.size();i++){
                //int max_pf=prices[i]-prices[0]+dp[k-1][j];//dp[k-1][j]=0;
                int max_pf=-prices[0];
                for(int j=1;j<=i;j++){
                    max_pf=max(max_pf,dp[k-1][j-1]-prices[j]);
                }
                dp[k][i]=max(max_pf+prices[i],dp[k][i-1]);         
            }
        }
        return dp[2][prices.size()-1];
    }

上面这种方法可以只能通过199/200个case最后一个case是超时错误，那么接下来就需要优化时间复杂度，我们可以看出，在最内层的for循环中，我们存在重复计算max_pf，因为我们每一次都要重新计算从从0-i的max_pf,我们可以优化成在每一次的迭代的时候我们更新当前的max_pf，收益变大，就更新，变小则维持不变。
就有下面的代码：

int maxProfit2(vector<int>& prices) {
        if(prices.size()<=1)return 0;
        int K=3;
        vector<vector<int>>dp(K,vector<int>(prices.size(),0));
       
        for( int k=1;k<K;k++){
            int max_pf=-prices[0];
            for(int i=1;i<prices.size();i++){
            	//在这里我们没一次迭代都更新我们的max_pf，这样的时间复杂度就是O(Kn)
                max_pf=max(max_pf,dp[k-1][i-1]-prices[i]);
                dp[k][i]=max(max_pf+prices[i],dp[k][i-1]);        
            }
        }
        return dp[2][prices.size()-1];
    }