买卖股票问题

121. 买卖股票的最佳时机

分析：
第i天有两种状态，持有股票和不持有股票，dp[i][0] dp[i][1] 分别表示在第i天持有和不持有这支股票取得的最大利润
所以dp初始化为天数*2大小，全0，dp[0][0]=-price(花钱买股票），显然第一天如果不买入就是0

递推公式
dp[i][0]：第i天持有该股票取得的最大利润
有两种选择——①之前已经持有，则dp[i][0]=dp[i-1][0]②今天新购入，则dp[i][0]=-price[i]（花钱勾股）
要得到第i天持股的最大利润，则上述两种情况取最大

dp[i][1]：第i天不持有该股票取得的最大利润
有两种选择——①之前也不持有，则dp[i][1]=dp[i-1][1]②今天新卖出，则dp[i][1]=price[i]+dp[i-1][0]（今天卖出的价格加上前一天持有的利润）
同理，取最大

递归顺序：由小到大

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        # dp[i][0]  dp[i][1] 分别表示在第i天持有和不持有这支股票取得的利润

        n = len(prices)
        dp = [[0]*2 for _ in range(n)]
        dp[0][0]= -prices[0]

        # 递推公式
        for i in range(1, n):
            dp[i][0] = max(dp[i-1][0], -prices[i])
            dp[i][1] = max(dp[i-1][1], dp[i-1][0]+prices[i])

        return dp[-1][1]  # 最后一天肯定是不持有的状态

代码简化：只有用一个大小为2的数组/两个变量
（观察上面的递推公式，dp[i][0]的更新只与dp[i-1][0]有关，与dp[i-1][1]状态无关，所以可以先更新1状态再跟新0状态）

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        dp0, dp1 = -prices[0], 0 #注意这里只维护两个常量，因为dp0的更新不受dp1的影响
        for i in range(1, length):
            dp1 = max(dp1, dp0 + prices[i])
            dp0 = max(dp0, -prices[i])
        return dp1

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

和上述只可买卖一次的类似，递推公式有差别
递推公式
dp[i][0]：第i天持有该股票取得的最大利润
有两种选择——①之前已经持有，则dp[i][0]=dp[i-1][0]②今天新购入，则**dp[i][0]=dp[i-1][1]-price[i]**（前一天不持有获得的最大利润减去今天买股需要的前）
要得到第i天持股的最大利润，则上述两种情况取最大

dp[i][1]：第i天不持有该股票取得的最大利润
有两种选择——①之前也不持有，则dp[i][1]=dp[i-1][1]②今天新卖出，则dp[i][1]=price[i]+dp[i-1][0]（今天卖出的价格加上前一天持有的利润）
同理，取最大

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        dp = [[0]*2 for _ in range(n)]
        dp[0][0] = -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[-1][1] 

这里不能简化为2个变量了，但可以使用2*2的数组

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

区别在于限制次数，最多买卖两次，所以有四种状态
本题易错点在于初始值的设置（一开始没注意到dp[0][2])
由于买卖可以同一天，所以第一天第一次买入为-prices[0]，第一次卖出（相当于同一天买入卖出，利润为0；第二次买入为-prices[0]，相当于第一天实现了一买一卖一买）

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        # 第i天不在仅仅是持有和不持有两个状态，而是第一次持有、第一次不持有、第二次持有、第二次不持有 四个状态
        n = len(prices)
        dp = [[0]*4 for _ in range(n)]
        dp[0][0] = -prices[0]  
        dp[0][2] = -prices[0]  # 易忽视
        for i in range(1,n):
            dp[i][0] = max(dp[i-1][0], -prices[i])
            dp[i][1] = max(dp[i-1][0] + prices[i], dp[i-1][1])
            dp[i][2] = max(dp[i-1][2], dp[i-1][1]-prices[i])
            dp[i][3] = max(dp[i-1][2] + prices[i], dp[i-1][3])
        print(dp)

        return max(dp[-1][1], dp[-1][3])  # dp[-1][3]即可

同理，若想降低空间复杂度，观察递推公式，dp[i][j]更新，j从大到小即可，所以只需一个大小为4的数组

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

与上题的区别在于最大交易次数为K
分析：观察递推公式知，对状态设为j，有2K个状态，先遍历天数，再遍历状态，为实现空间优化，只需一个大小为2K的数组，j从大到小遍历

class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:     
        n = len(prices)   
        dp = [0]*(2*k+1)
        for i in range(2*k+1):
            if i%2==1:
                dp[i] = -prices[0]   # 奇数买入
        for i in range(1,n):
            for j in range(2*k, 0, -1):
                if j%2==1:
                    dp[j] = max(dp[j], dp[j-1]-prices[i])
                else:
                    dp[j] = max(dp[j], dp[j-1] + prices[i])

        return dp[-1]

注意：这里多加了第0列，是方便递推公式统一，否则若按上一题，dp[i][0] = max(dp[i-1][0], -prices[i])这一行不好和其他的统一

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

分析：和上面不同的是第i天的状态，不能仅用持有和不持有来分析，因为递推过程中当天若想持有会分之前已持有、前一天卖出（今天为冷冻期）、前一天为冷冻期和前一天非冷冻期的情况，所以状态要分为四类：
持有状态、不持有当天卖出、不持有当天冷冻期、不持有当天非冷冻期

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        # dp[i][0] dp[i][1] dp[i][2] dp[i][3]在第i天持有/不持有(当天卖出)/不持有(冷冻期)/不持有(非冷冻期) 股票获得的最大利润
        
        n = len(prices)
        dp = [[0]*4 for _ in range(n)]
        dp[0][0] = -prices[0]

        # 递推
        for i in range(1,n):
            # 第i天持有获得的最大利润=max（前一天已经持有，前一天为不持有状态（前一天卖出）不可能持有，前一天为不持有状态（前一天为冷冻期），不持有(前一天非冷冻期) ）
            dp[i][0] = max(dp[i-1][0], dp[i-1][2]-prices[i], dp[i-1][3]-prices[i])

            # 第i天卖出获得的最大利润=前一天持有今天卖出
            dp[i][1] = dp[i-1][0]+prices[i]

            # 第i天处于冷冻期的最大利润=前一天卖出获得的利润
            dp[i][2] = dp[i-1][1]

            # 第i天处于不持有 非冷冻期的最大利润= max(之前不持有冷冻期的利润,之前不持有非冷冻期的利润）
            dp[i][3] = max(dp[i-1][2], dp[i-1][3])
        
        return max(dp[-1][1], dp[-1][2], dp[-1][3])

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

分析：持有状态 不持有状态（若第i天卖出成为不持有状态则需要在利润中减去手续费）

class Solution:
    def maxProfit(self, prices: List[int], fee: int) -> int:
        '''
        n = len(prices)
        dp = [[0]*2 for _ in range(n)]
        dp[0][0] = -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][0] + prices[i]-fee, dp[i-1][1])
        return dp[-1][-1]
        '''
        
        #简化  只使用四个变量
        n = len(prices)        
        dp1 = -prices[0]
        dp2 = 0
        
        for i in range(1,n):
            temp1 = max(dp1, dp2-prices[i])
            temp2 = max(dp1 + prices[i]-fee, dp2)
            dp1,dp2 = temp1,temp2
        return dp2

小结

股票买卖

• 只可买卖一次

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

• 可无限次买卖

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])

• 只可买卖两次

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

• 只可买卖k次

 for i in range(1,n):
     for j in range(2*k, 0, -1):
         if j%2==1:
             dp[j] = max(dp[j], dp[j-1]-prices[i])
         else:
             dp[j] = max(dp[j], dp[j-1] + prices[i])

• 冷冻期(可无限次买卖)

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

• 手续费(可无限次买卖)

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][0] + prices[i]-fee, dp[i-1][1])

重点：对状态的分析