LEETCODE力扣股票问题总结

在力扣网站中，最常见的动态规划问题就是股票系列的问题

这里我把题号给放上来

121
122
123
188
309
714

股票问题总思路

既然涉及到动态规划，那么我们肯定是需要根据题意来定义状态转移方程的

对于股票的操作，我们一共有3个，分别是买，卖，不交易
我们可以定义一个三维的数组，维度分别代表天数，交易次数，状态（用0，1代表没持有股票还是持有股票）

dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
这个方程意思是我现在没持有股票，那么有两种可能，一个是昨天我就没有持有股票，也就是dp[i-1][k][0]，第二个是我昨天持有股票，今天卖了，因此是dp[i-1][k][1]加上卖出去股票的价格

同理我们可以写出另外一个
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
这个方程的意思是我现在持有股票，那么有两种可能，一个是昨天我就持有股票，对于的就是dp[i-1][k][1]。第二个是我昨天没持有股票，今天买了。由于涉及到买，所以我们交易次数要减1，天数减1，同时减去今天买股票的钱

上面这两个方程很重要，这两个方程能解决股票系列所有问题

推导出转移方程，我们来看看基本情况

基本情况：

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
解释：不允许交易的情况下，是不可能持有股票的，用负无穷表示这种不可能

初探股票问题

121. 买卖股票的最佳时机
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。

注意：你不能在买入股票前卖出股票。



示例 1:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

这是股票系列的第一个问题，这题只有一次交易次数，所以我们可以把第二维度给去掉
然后应用我们的转移方程即可

def maxProfit(prices: List[int]) -> int:
    n = len(prices)
    dp = [[0, 0] for _ in range(n)]
    for i in range(n):
        if i - 1 == -1:
            dp[i][0] = 0
            dp[i][1] = -prices[i]

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

当然这道问题不用那么复杂，我们直接贪心也是可以的，要想利润最大，我们直接维护一个最小值和最大值即可

def maxProfitV2(prices):
    """
    遍历法，维护最小值和最大profit
    :param prices:
    :return:
    """
    inf = int(1e9)
    maxprofit = 0
    minprice = inf
    for price in prices:
        maxprofit = max(maxprofit, price - minprice)
        minprice = min(price, minprice)

    return maxprofit

然后我们接着看第二道题

122. 买卖股票的最佳时机 II
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

这道题对交易次数则没有限制，因此我们仍然是可以去掉第二维度的
天数也并不重要，我们只需要一次遍历就可以替代掉第一个维度，因此也可以去掉，还是根据转移方程，先列出基本情况，在此基础上用我们的转移方程

def maxProfit2(prices: List[int]) -> int:
    n = len(prices)
    dp_i_0 = 0
    dp_i_1 = -float("inf")
    for i in range(n):
        temp = dp_i_0
        dp_i_0 = max(dp_i_0, dp_i_1 + prices[i])
        dp_i_1 = max(dp_i_1, temp - prices[i])

    return dp_i_0

这题同样是能进行贪心算法的，没必要动态规划。因为我们股票操作，肯定是后一天比今天价格高才操作，因此利润要么为0（即我们不卖股票），要么就是这两天股票的差值
基于这个思想我们也可以写出对应的代码

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        maxprofit = 0
        for i in range(len(prices)-1):
            maxprofit += max(0, prices[i+1]-prices[i])

        return maxprofit

进阶版股票问题

后面几道就比较难了，先来看第三道

123. 买卖股票的最佳时机 III
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。

注意: 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: [3,3,5,0,0,3,1,4]
输出: 6
解释: 在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
     随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。
示例 2:

输入: [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。   
     注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。   
     因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3:

输入: [7,6,4,3,1] 
输出: 0 
解释: 在这个情况下, 没有交易完成, 所以最大利润为 0。

这道题开始对交易次数有限制了，因此我们的转移方程一个维度都不能去掉。我们的基本情况可以根据交易次数单独列出来

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        """
        未持股，未卖出过股票：说明从未进行过买卖，利润为0
        dp[i][0][0]=0

        未持股，卖出过1次股票：可能是今天卖出，也可能是之前卖的（昨天也未持股且卖出过）
        dp[i][0][1]=max(dp[i-1][1][0]+prices[i],dp[i-1][0][1])

        未持股，卖出过2次股票:可能是今天卖出，也可能是之前卖的（昨天也未持股且卖出过）
        dp[i][0][2]=max(dp[i-1][1][1]+prices[i],dp[i-1][0][2])

        持股，未卖出过股票：可能是今天买的，也可能是之前买的（昨天也持股）
        dp[i][1][0]=max(dp[i-1][0][0]-prices[i],dp[i-1][1][0])

        持股，卖出过1次股票：可能是今天买的，也可能是之前买的（昨天也持股）
        dp[i][1][1]=max(dp[i-1][0][1]-prices[i],dp[i-1][1][1])

        持股，卖出过2次股票：最多交易2次，这种情况不存在
        dp[i][1][2]=float('-inf')


        :param prices:
        :return:
        """
        idp_i_10 = 0
	    dp_i_11 = -float("inf")
	    dp_i_20 = 0
	    dp_i_21 = -float("inf")
	
	    for price in prices:
	        dp_i_20 = max(dp_i_20, dp_i_21 + price)
	        dp_i_21 = max(dp_i_21, dp_i_10 - price)
	        dp_i_10 = max(dp_i_10, dp_i_11 + price)
	        dp_i_11 = max(dp_i_11, -price)
	
	    return dp_i_20

然后是第四道

188. 买卖股票的最佳时机 IV
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。

注意: 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

我们可以基于第三道题目的思想，存储每个k笔交易得到的值，最后取最大值即可。难是难在如何对基本情况做正确的初始化

class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:
        # 定义卖出股票,交易次数 j + 1
        # dp[i][j][0] 今天是第i天 进行 j次 交易 手上没有股票
        # dp[i][j][1] 今天是第i天 进行 j次 交易 手上有股票
        if k == 0 or len(prices) < 2:
            return 0
        n = len(prices)
        res = []
        if k > n // 2:
            # 每次买卖，交易次数为2
            # 当k 大于 n/2，说明此时k交易次数已经无法限制，相当于我们无限次买卖股票
            # 也就是回到我们第二题的贪心算法
            max_profit = 0
            for i in range(1, n):
                profit = prices[i] - prices[i - 1]
                if profit > 0:
                    max_profit += profit
            return max_profit

        # 初始化dp数组
        dp = [[[0] * 2 for _ in range(k + 1)] for _ in range(n)]
        for i in range(k + 1):
            # 每种交易方法,它一开始如果没有股票，则利润为0，一开始若持有股票，则利润为0-prices[0]
            dp[0][i][0] = 0
            dp[0][i][1] = -prices[0]
        for i in range(1, n):
            for j in range(k + 1):
                if not j:
                    # 如果j=0，j-1是不合理的，我们只能维持之前的利润
                    dp[i][j][0] = dp[i - 1][j][0]
                else:
                    dp[i][j][0] = max(dp[i - 1][j][0], dp[i - 1][j - 1][1] + prices[i])  # 在j-1天卖出

                # 由于前面对i是有考虑基本情况的，这里就不需要单独讨论
                dp[i][j][1] = max(dp[i - 1][j][1], dp[i - 1][j][0] - prices[i])  # 在第j天买

        for m in range(k + 1):
            # 将0-k交易次数的利润都添加到res数组中，然后取数组中的最大值
            res.append(dp[-1][m][0])
        return max(res)

拓展变形股票问题

309. 最佳买卖股票时机含冷冻期
给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。​

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
示例:

输入: [1,2,3,0,2]
输出: 3 
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]

由于存在冷冻期，所以我们状态转移方程需要改一下，改的地方应该是第二个方程，也就是持有股票的方程。题目说了卖出股票无法在第二天买入，因此状态转移应从i-2开始转移

def maxProfit3(prices: List[int]) -> int:
    """
    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 天选择 buy 的时候，要从 i-2 的状态转移，而不是 i-1 。

    :param prices:
    :return:
    """
    n = len(prices)
    dp_i_0 = 0
    dp_i_1 = -float("inf")
    dp_pre_0 = 0
    for i in range(n):
        temp = dp_i_0
        dp_i_0 = max(dp_i_0, dp_i_1 + prices[i])
        dp_i_1 = max(dp_i_1, dp_pre_0 - prices[i])
        dp_pre_0 = temp

    return dp_i_0

714. 买卖股票的最佳时机含手续费
给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；非负整数 fee 代表了交易股票的手续费用。

你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，

在卖出它之前你就不能再继续购买股票了。

返回获得利润的最大值。

注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

示例 1:

输入: prices = [1, 3, 2, 8, 4, 9], fee = 2
输出: 8
解释: 能够达到的最大利润:  
在此处买入 prices[0] = 1
在此处卖出 prices[3] = 8
在此处买入 prices[4] = 4
在此处卖出 prices[5] = 9
总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8.

这里存在手续费，直接将手续费加入到我们的转移方程即可,
加在第一个方程或者是第二个方程都是可以的，这里我将手续费额外开销加在第二个方程内

def maxProfit4(prices: List[int], fee: int) -> int:
    n = len(prices)
    dp_0 = 0
    dp_1 = -float("inf")

    for i in range(n):
        temp = dp_0
        dp_0 = max(dp_0, dp_1 + prices[i])
        dp_1 = max(dp_1, temp - fee - prices[i])  # 这里减去手续费

    return dp_0

股票系列问题就到此为止了，如果想得到这种复杂的三维转移方程，根据题意进行化简，那么是很厉害的。当然我们也不要只局限于动态规划这种解法，有些题意下面我们使用别的算法会更简单，理解起来更容易