LeetCode 力扣 123. 買賣股票的最佳時機 III

題目描述（困難難度）

依舊是買賣股票的延伸，但比 121 題 ， 122 題 難度高了不少。這道題的意思是，給一個數組代表股票每天的價格。你最多可以買入賣出兩次，但只有賣出了纔可以再次買入，求出最大的收益是多少。

解法一

參考 這裏。

開始的想法是求出收益第一高和第二高的兩次買賣，然後加起來。對於普通的情況是可以解決的，但是對於下邊的情況

1 5 2 8 3 10

第一天買第二天賣，第三天買第四天賣，第五天買第六天賣，三次收益分別是 4，6，7，最高的兩次就是 6 + 7 = 13 了，但是我們第二天其實可以不賣出，第四天再賣出，那麼收益是 8 - 1 = 7，再加上第五天買入第六天賣出的收益就是 7 + 7 = 14了。

所以當達到了一個高點時不一定要賣出，所以需要考慮的情況就很多了，不能像 121 題 ， 122 題 那樣簡單的考慮了。那隻能朝着動態規劃思路想了。

動態規劃關鍵就是數組定義和狀態轉移方程了。

按最簡單的動態規劃的思路想，用 dp[i]表示前i天的最高收益，那麼 dp[i+1] 怎麼根據 dp[i] 求出來呢？發現並不能求出來。

我們注意到我們題目是求那麼多天最多交易兩次的最高收益，還有一個最多交易次數的變量，我們把它加到數組中再試一試。

用 dp[i][k] 表示前i天最多交易k次的最高收益，那麼 dp[i][k] 怎麼通過之前的解求出來呢？

首先第 i 天可以什麼都不操作，今天的最高收益就等於昨天的最高收益

dp[i][k] = dp[i-1][k]

此外，爲了獲得更大收益我們第 i 天也可以選擇賣出，既然選擇賣出，那麼在0到 i-1 天就要選擇一天買入。多選擇了一次買入，那在買入之前已經進行了 k-1 次買賣。

在第 0 天買入，收益就是 prices[i] - prices[0]

在第 1 天買入，收益就是 prices[i] - prices[1] + dp[0][k-1]，多加了前一天的最大收益

在第 2 天買入，收益就是 prices[i] - prices[2] + dp[1][k-1]，多加了前一天的最大收益

…

在第 j 天買入，收益就是 prices[i] - prices[j] + dp[j-1][k-1]，多加了前一天的最大收益

上邊的每一種可能選擇一個最大的，然後與第i天什麼都不操作比較，就是dp[i][k]的值了。

當然上邊的推導已經可以寫代碼了，但爲了最後的代碼更加簡潔（寫完代碼後發現的），我們可以再換一下狀態轉移方程。真的只是爲了簡潔，時間複雜度和空間複雜度上不會有影響。

爲了獲得更大收益我們第 i 天也可以選擇賣出，既然選擇賣出，那麼在0到 i-1 天就要選擇一天買入。

我們也可以選擇0到i天中選擇一天買入，因爲第 i 天買入，第 i天賣出對最後的收益是沒有影響的。

在第 j 天買入，收益就是 prices[i] - prices[j] + dp[j-1][k-1]，多加了前一天的最大收益

我們多加了前一天的最大收益，我們也可以改成加當前天的最大收益。

在第 j 天買入，收益就是 prices[i] - prices[j] + dp[j][k-1]

不嚴謹的想一下，如果第 j 天就是最後我們要選擇的買入點，它使得最後的收益最高，dp[j][k-1] 和 dp[j-1][k-1] 一定是相等的。因爲第 j 天一定是一個低點而第 j - 1 天是個高點，第 j 天爲了得到更高收益肯定選擇不操作，所以和第 j - 1 天的收益是一樣的，所以改了狀態轉移方程，最後求出的最高解還是一致的。

綜上，最後的狀態轉移方程就是

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

也就是

dp[i][k] = Max(dp[i-1][k],prices[i] - prices[j] + dp[j][k-1])，j 取 0 - i。

而 prices[i] - prices[j] + dp[j][k-1] 也可以看做， prices[i] - (prices[j] - dp[j][k-1]) ，爲了求這個表達式的最大值，我們可以找prices[j] - dp[j][k-1]的最小值。

而初始條件對於k 等於 0 的情況，收益就是 0 了。

還有前 0 天的最大收益也是 0 ，也就是dp[0][k]是 0 。由於下標是從0開始的，這裏的前0天其實就是第一天。

因爲初始條件的結果都是0，數組初始化後就是 0 ，所以不需要特殊處理。

public int maxProfit(int[] prices) {
    if (prices.length == 0) {
        return 0;
    }
    int K = 2;
    int[][] dp = new int[prices.length][K + 1];
    for (int k = 1; k <= K; k++) {
        for (int i = 1; i < prices.length; i++) { 
            int min = Integer.MAX_VALUE;
            //找出第 0 天到第 i 天 prices[buy] - dp[buy][k - 1] 的最小值
            for (int buy = 0; buy <= i; buy++) { 
                min = Math.min(prices[buy] - dp[buy][k - 1], min);
            }
            //比較不操作和選擇一天買入的哪個值更大
            dp[i][k] = Math.max(dp[i - 1][k], prices[i] - min);
        }
    }
    return dp[prices.length - 1][K];
}

找第 j 天prices[buy] - dp[buy][k - 1]的最小值的時候，我們考慮了 prices[0] - dp[0][k - 1]、 prices[1] - dp[1][k - 1]、 prices[2] - dp[2][k - 1]…，找第 j + 1 天prices[buy] - dp[buy][k - 1]的最小值的時候，我們又會從頭考慮 prices[0] - dp[0][k - 1]、 prices[1] - dp[1][k - 1]、 prices[2] - dp[2][k - 1]…，所以其實沒必要每次從頭考慮，我們只需要把之前的結果保存起來，然後再和新加入的 prices[j+1] - dp[j+1][k - 1] 比較就可以了。

public int maxProfit(int[] prices) {
    if (prices.length == 0) {
        return 0;
    }
    int K = 2;
    int[][] dp = new int[prices.length][K + 1];
    for (int k = 1; k <= K; k++) {
        int min = prices[0];
        for (int i = 1; i < prices.length; i++) {
            //找出第 1 天到第 i 天 prices[buy] - dp[buy][k - 1] 的最小值 
            min = Math.min(prices[i] - dp[i][k - 1], min); 
            //比較不操作和選擇一天買入的哪個值更大
            dp[i][k] = Math.max(dp[i - 1][k], prices[i] - min);
        }
    }
    return dp[prices.length - 1][K];
}

此時按照動態規劃的套路，結合代碼和下邊的圖。

根據代碼，我們是固定 k 然後一列一列更新 dp。而更新當前列只需要前一列的信息，所以不需要二維數組，只需要一個一維數組。但是注意到最外層的 for 循環是一個常數次，所以我們可以把兩層循環內外顛倒下，可以更好的進行空間複雜度的優化。

public int maxProfit(int[] prices) {
    if (prices.length == 0) {
        return 0;
    }
    int K = 2;
    int[][] dp = new int[prices.length][K + 1];
    int min[] = new int[K + 1];
    for (int i = 1; i <= K; i++) {
        min[i] = prices[0];
    }
    for (int i = 1; i < prices.length; i++) {
        for (int k = 1; k <= K; k++) {
            min[k] = Math.min(prices[i] - dp[i][k - 1], min[k]);
            dp[i][k] = Math.max(dp[i - 1][k], prices[i] - min[k]);
        }
    }
    return dp[prices.length - 1][K];
}

再結合圖看，此時我們就是一行一行的更新了，對於每一列都有一個 min 所以我們多了 min 數組。現在讓我們將二維數組 dp 改成一維數組。

public int maxProfit(int[] prices) {
    if (prices.length == 0) {
        return 0;
    }
    int K = 2;
    int[] dp = new int[K + 1];
    int min[] = new int[K + 1];
    for (int i = 1; i <= K; i++) {
        min[i] = prices[0];
    }
    for (int i = 1; i < prices.length; i++) {
        for (int k = 1; k <= K; k++) {
            min[k] = Math.min(prices[i] - dp[k - 1], min[k]);
            dp[k] = Math.max(dp[k], prices[i] - min[k]);
        }
    }
    return dp[K];
}

由於 K 是一個常數，所以我們的 min 數組和 dp 數組都可以分別當成兩個變量。

public int maxProfit(int[] prices) {
    if (prices.length == 0) {
        return 0;
    } 
    int dp1 = 0;
    int dp2 = 0;
    int min1 = prices[0];
    int min2 = prices[0];
    for (int i = 1; i < prices.length; i++) {
            min1 = Math.min(prices[i] - 0, min1);
            dp1 = Math.max(dp1, prices[i] - min1);

            min2 = Math.min(prices[i] - dp1, min2);
            dp2 = Math.max(dp2, prices[i] - min2);
    }
    return dp2;
}

如果結合一步一步的優化，最後這個代碼也就很好的能解釋通了。

解法二

再分享個利用狀態機的 解法，雖然不容易想到，但真的太強了，上次用狀態機還是 65 題。

每天我們其實是有四個狀態，買入當前價格的股票，以當前價格的股票賣出。第二次買入股票，第二次賣出股票。

s0代表初始狀態，初始時錢是 0。s1代表第一次買入後當前的錢，s2代表第一次賣出後當前的前，s3代表第二次買入後當前的錢，s4代表第二次賣出後當前的錢。

然後我們只需要更新每天的這四個狀態即可。

int maxProfit(vector<int>& prices) {
    if(prices.empty()) return 0;
    //進行初始化，第一天 s1 將股票買入，其他狀態全部初始化爲最小值
    int s1=-prices[0],s2=INT_MIN,s3=INT_MIN,s4=INT_MIN;

    for(int i=1;i<prices.size();++i) {            
        s1 = max(s1, -prices[i]); //買入價格更低的股
        s2 = max(s2, s1+prices[i]); //賣出當前股，或者不操作
        s3 = max(s3, s2-prices[i]); //第二次買入，或者不操作
        s4 = max(s4, s3+prices[i]); //第二次賣出，或者不操作
    }
    return max(0,s4);
}

總

解法一比較常規，但是這個動態規劃難在了我們考慮了兩個變量，相比於之前的動態規劃不容易想到。

更多詳細通俗題解詳見 leetcode.wang 。