188 Best Time to Buy and Sell Stock IV 買賣股票的最佳時機 IV

Description:
Say you have an array for which the i-th element is the price of a given stock on day i.

Design an algorithm to find the maximum profit. You may complete at most k transactions.

Note:
You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

Example:

Example 1:

Input: [2,4,1], k = 2
Output: 2
Explanation: Buy on day 1 (price = 2) and sell on day 2 (price = 4), profit = 4-2 = 2.

Example 2:

Input: [3,2,6,5,0,3], k = 2
Output: 7
Explanation: Buy on day 2 (price = 2) and sell on day 3 (price = 6), profit = 6-2 = 4.
Then buy on day 5 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.

題目描述:
給定一個數組，它的第 i 個元素是一支給定的股票在第 i 天的價格。

設計一個算法來計算你所能獲取的最大利潤。你最多可以完成 k 筆交易。

注意:
你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。

示例 :

示例 1:

輸入: [2,4,1], k = 2
輸出: 2
解釋: 在第 1 天 (股票價格 = 2) 的時候買入，在第 2 天 (股票價格 = 4) 的時候賣出，這筆交易所能獲得利潤 = 4-2 = 2 。

示例 2:

輸入: [3,2,6,5,0,3], k = 2
輸出: 7
解釋: 在第 2 天 (股票價格 = 2) 的時候買入，在第 3 天 (股票價格 = 6) 的時候賣出, 這筆交易所能獲得利潤 = 6-2 = 4 。
隨后，在第 5 天 (股票價格 = 0) 的時候買入，在第 6 天 (股票價格 = 3) 的時候賣出, 這筆交易所能獲得利潤 = 3-0 = 3 。

思路:

參考LeetCode #123 Best Time to Buy and Sell Stock III 買賣股票的最佳時機 III
注意在 k > n / 2時, 由于買入賣出需要 2天時間, 這時可以簡化為無限次購買, 可用貪心求解
時間復雜度O(nk), 空間復雜度O(k)

代碼:
C++:

class Solution 
{
public:
    int maxProfit(int k, vector<int>& prices) 
    {
        int n = prices.size(), dp = 0;
        if (k > n / 2) 
        {
            for (int i = 0; i < n - 1; i++) if (prices[i + 1] > prices[i]) dp += prices[i + 1] - prices[i];
            return dp;
        }
        vector<int> buy(k + 1, 0), sell(k + 1, INT_MIN);
        for (int i = 0; i < n; i++) 
        {
            for (int j = 1; j < k + 1; j++) 
            {
                buy[j] = max(buy[j], sell[j] + prices[i]);
                sell[j] = max(sell[j], buy[j - 1] - prices[i]);
            }
        }
        return buy[k];
    }
};

Java:

class Solution {
    public int maxProfit(int k, int[] prices) {
        int n = prices.length;
        if (k > n / 2) {
            int dp = 0, pre = Integer.MIN_VALUE;
            for (int price : prices) {
                int temp = dp;
                dp = Math.max(dp, pre + price);
                pre = Math.max(pre, temp - price);
            }
            return dp;
        }
        int dp[][] = new int[k + 1][2];
        for (int i = 0; i < k + 1; i++) dp[i][1] = Integer.MIN_VALUE;
        for (int i = 0; i < n; i++) {
            for (int j = 1; j < k + 1; j++) {
                dp[j][0] = Math.max(dp[j][0], dp[j][1] + prices[i]);
                dp[j][1] = Math.max(dp[j][1], dp[j - 1][0] - prices[i]);
            }
        }
        return dp[k][0];
    }
}

Python:

class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:
        n = len(prices)
        def maxProfit_k_inf(prices: List[int]) -> int:
            dp_i_0, dp_i_1 = 0, -float('inf')
            for price in prices:
                dp_i_0, dp_i_1 = max(dp_i_0, dp_i_1 + price), max(dp_i_1, dp_i_0 - price)
            return dp_i_0
        if k > n // 2:
            return maxProfit_k_inf(prices)
        
        dp = [[0] * (k + 1), [-float('inf')] * (k + 1)]
        for i in range(n):
            for j in range(1, k + 1):
                dp[0][j], dp[1][j] = max(dp[0][j], dp[1][j] + prices[i]), max(dp[1][j], dp[0][j - 1] - prices[i])
        return dp[0][k]