LeetCode #188: Best Time to Buy and Sell Stock IV

Problem Statement

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

Analysis

dp[i][j]: the maximum profit can be achieved in the previous j days with at most i transactions.

• Time Complexity: $O(kn^2)$
• Space Complexity: $O(kn)$

---

Tags: Dynamic Programming.

Solution

class Solution(object):
    def maxProfit(self, k, prices):
        """
        :type k: int
        :type prices: List[int]
        :rtype: int
        """
        if k <= 0 or (not prices) or len(prices) < 2:
            return 0


        n = len(prices)
        res = 0

        if k >= (n >> 1): # Arbitray transactions allowed in this case.
            dp = [0 for i in xrange(n + 1)]
            for i in xrange(2, n + 1):
                dp[i] = dp[i - 1]
                j = i - 1
                while j > 0 and prices[i-1] > prices[j-1]:
                    dp[i] = max(dp[i], dp[j-1] + prices[i-1] - prices[j-1])
                    j -= 1
            return dp[-1]

        dp = [[0 for j in xrange(n)] for i in xrange(k + 1)]
        for i in xrange(1, k + 1):
            for j in xrange(1, n):
                dp[i][j] = dp[i][j-1]
                # Buy at day t and sell at day j.
                t = j - 1
                while t >= 0 and prices[t] < prices[j]:
                    profit = max(prices[j] - prices[t], 0)
                    if t - 1 > 0:
                        profit += dp[i-1][t-1]
                    dp[i][j] = max(dp[i][j], profit)
                    t -= 1
                res = max(res, dp[i][j])
        return res