Leetcode题解——动态规划一网打尽股票买卖问题

股票买卖问题涉及到的题目：

121. 买卖股票的最佳时机

122. 买卖股票的最佳时机 II

309. 最佳买卖股票时机含冷冻期

714. 买卖股票的最佳时机含手续费

123. 买卖股票的最佳时机 III

188. 买卖股票的最佳时机 IV

此系列的题目可以用状态机的技巧来解决，实际上就是动态规划的DP table，具体可参考团灭 LeetCode 股票买卖问题

具体来说，要构建的动态规划数组为

dp[i][k][0 or 1]
0 <= i <= n-1, 1 <= k <= K
n 为天数，大 K 为最多交易数
此问题共 n × K × 2 种状态，全部穷举就能搞定。

因此，状态转移方程为

dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
              max(   选择 rest  ,             选择 sell      )

解释：今天我没有持有股票，有两种可能：
要么是我昨天就没有持有，然后今天选择 rest，所以我今天还是没有持有；
要么是我昨天持有股票，但是今天我 sell 了，所以我今天没有持有股票了。

dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
              max(   选择 rest  ,           选择 buy         )

解释：今天我持有着股票，有两种可能：
要么我昨天就持有着股票，然后今天选择 rest，所以我今天还持有着股票；
要么我昨天本没有持有，但今天我选择 buy，所以今天我就持有股票了。

 base case：

dp[-1][k][0] = 0
解释：因为 i 是从 0 开始的，所以 i = -1 意味着还没有开始，这时候的利润当然是 0 。
dp[-1][k][1] = -infinity
解释：还没开始的时候，是不可能持有股票的，用负无穷表示这种不可能。
dp[i][0][0] = 0
解释：因为 k 是从 1 开始的，所以 k = 0 意味着根本不允许交易，这时候利润当然是 0 。
dp[i][0][1] = -infinity
解释：不允许交易的情况下，是不可能持有股票的，用负无穷表示这种不可能。

 至于数组索引 -1 及负无穷如何表示，且看具体代码：

121. 买卖股票的最佳时机

对应状态转移方程k=1, k取值相同时可忽略k的影响，

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        if not n or n < 2:
            return 0
        
        dp = [[0,0] for _ in range(n)]
        dp[0][0] = 0
        dp[0][1] = -prices[0]

        for i in range(1, n):
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
            dp[i][1] = max(dp[i-1][1], -prices[i])

        return dp[n-1][0]

122. 买卖股票的最佳时机 II

对应状态转移方程k取正无穷, k取值对状态方程无影响，可忽略

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        if not n or n < 2:
            return 0

        dp = [[0, 0] for _ in range(n)]
        dp[0][0] = 0
        dp[0][1] = -prices[0]

        for i in range(1,n):
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
            dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i])
        
        return dp[n-1][0]

309. 最佳买卖股票时机含冷冻期

同样k为正无穷，每次 sell 之后要等一天才能继续交易，则第 i 天选择 buy 的时候，要从 i-2 的状态转移，而不是 i-1

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        if not n or n < 2:
            return 0

        dp = [[0, 0] for _ in range(n)]
        dp[0][0] = 0
        dp[0][1] = -prices[0]

        for i in range(1,n):
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
            dp[i][1] = max(dp[i-1][1], dp[i-2][0] - prices[i]) #与上一题的唯一变化就是这里变成i-2
        
        return dp[n-1][0]

714. 买卖股票的最佳时机含手续费

同样k为正无穷，每次交易要支付手续费，只要把手续费从利润中减去即可

class Solution:
    def maxProfit(self, prices: List[int], fee: int) -> int:
        n = len(prices)
        if not n or n < 2:
            return 0

        dp = [[0, 0] for _ in range(n)]
        dp[0][0] = 0
        dp[0][1] = -prices[0] - fee

        for i in range(1,n):
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
            dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i] - fee)
        
        return dp[n-1][0]

分割线：以上几题要么 k 是正无穷，状态转移和 k 没关系了；要么 k = 1，跟 k = 0 这个 base case 挨得近，最后也没有存在感，因此可忽略，但是下面两题k=2及k取任意正整数时，要考虑对k的处理，因此状态转移方程就不能省略掉k，而且dp table应该为一个3维数组。

123. 买卖股票的最佳时机 III

此时k=2，要利用循环将所有状态穷举出来，且构建三维数组

class Solution:
    def maxProfit(self, prices: List[int]) -> int:

        maxk = 2
        n = len(prices)
        if not n or n < 2:
            return 0
        # dp = [[0, 0, 0] for _ in range(n)]
        dp = [[[0, 0] for i in range(maxk+1)] for i in range(len(prices))]

        dp[0][2][0] = 0  #第0天，不管还剩几次交易次数，不持有收益是0，也不可能持有(一天内不能瞬间买入卖出)，所以设1为负数
        dp[0][2][1] = -prices[0]                                                
        dp[0][1][0] = 0                                                         
        dp[0][1][1] = -prices[0]  

        for i in range(1, n):
            for k in range(maxk, 0, -1):#这里必须倒着，base case中k是倒着的，这里正序会出现0，1，与前面的设定不同了，就会出错
                dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
                dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])

        return dp[n-1][maxk][0]

188. 买卖股票的最佳时机 IV

一次交易由买入和卖出构成，至少需要两天。所以说有效的限制 k 应该不超过 n/2，如果超过，就没有约束作用了，相当于 k 取正无穷，同上。

class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:

        n = len(prices)
        if not prices: return 0
        def maxProfit_k_inf(prices):
            dp_i_0, dp_i_1 = 0, -float('inf')
            for price in prices:
                temp = dp_i_0
                dp_i_0 = max(dp_i_0, dp_i_1 + price)
                dp_i_1 = max(dp_i_1, temp - price)
            return dp_i_0

        if k > n / 2:
            return maxProfit_k_inf(prices)

        dp = [[[0 for i in range(2)] for i in range(k+1)] for i in range(n)]

        #base case
        for k in range(1, k+1):        
            dp[0][k][0] = 0          
            dp[0][k][1] = -prices[0] 
        
        for i in range(1, n):
            for k in range(1, k+1):
                dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
                dp[i][k][1] = max(dp[i-1][k-1][0] - prices[i], dp[i-1][k][1])

        return dp[n-1][k][0]