Best Time to Buy and Sell Stock IV-买卖股票问题

leetcode原题地址：https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/

REFERENCE:

https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/discuss/135704/Detail-explanation-of-DP-solution

这篇explanation是我见过这个题目最清晰的解释，没有之一！

题目思路是用dp，状态转移方程：

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

dp[k,i]表示第i天，最多进行k次交易能获得的最大利润，它可能是以下几种情况得到：

1. 可以在第i天什么也不做，即为dp[k,i-1]

2. 在前面的某一天 j 之前进行了最多k-1交易，最后一次交易为从第j到第i天，因此利润为：price[i]-price[j]+dp[k-1,j-1]

有了状态转移方程很容易写出。这里有个trick，要求所有j中 max(price[i]-price[j]+dp[k-1,j-1])，即求min(price[j]-dp[k-1,j-1])

版本1代码可写为：

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

时间复杂度为O(kn²)，空间复杂度为O(kn)

复杂度过高，导致超时：209 / 211 test cases passed.

版本2：

注意到 j 从1到 i 时，每一个循环都要计算一次 “prices[j] - dp[k-1][j-1]” j = [1,2,3……,i]

而这个值实际上已经被计算过，在i之前的循环中，“prices[j] - dp[k-1][j-1]” j = [1,2,3……,i] 都被计算过，因此可以在i循环时更新minP，代码如下：

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

时间复杂度为O(kn)，空间复杂度为O(kn)

复杂度仍然过高，还是超时：209 / 211 test cases passed.

版本3

注意到版本2中，dp[k，i]仅仅与dp[k，i-1]和dp[k-1，i-1]有关，也就是说，只与上一个i有关。因此可以只看成一个变量。

dp[k，i]-->dp[k]，dp[k，i-1]-->dp[k]，dp[k-1，i-1]-->dp[k-1]。

代码如下：

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

时间复杂度为O(kn)，空间复杂度为O(k)

虽然已经优化了这么多，提交后发现：内存超限(?……): 209 / 211 test cases passed.

版本4

接下来考虑k, 当k>=n/2时，退化为交易任意次了。因为买卖最多交易n/2。

交易任意次就不需要用dp，后一天价格高于前一天；则累加，否则不累加。这样将每个增加的全部加起来了，即为结果。

代码如下：

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

时间复杂度为O(kn)，空间复杂度为O(k)

这次终于过了那个长样例!

总结：

1. 版本1就应该检测k和n/2的关系，说不定就过了！

2. 股票买入卖出四部曲结束，写出简单的转移方程，并一步步优化可以得到一个很精简的(但是直接看不懂的)版本