2024/06/18--代码随想录算法8-9/17| 股票问题

121.买卖股票的最佳时机

力扣链接

动规五部曲

1. 确定dp数组（dp table）以及下标的含义
   dp[i][0] 表示第i天持有股票所得最多现金,dp[i][1] 表示第i天不持有股票所得最多现金
2. 确定递推公式
   
   dp[i][0] = max(dp[i-1][0], -price[i])
   dp[i][1]=max(dp[i-1][1], dp[i-1][0]+price[i])
3. dp数组初始化
   那么dp[0][0]表示第0天持有股票，此时的持有股票就一定是买入股票了，因为不可能有前一天推出来，所以dp[0][0] -= prices[0];
   dp[0][1]表示第0天不持有股票，不持有股票那么现金就是0，所以dp[0][1] = 0;
4. 遍历顺序 ：dp[i]都是由dp[i - 1]推导出来的，那么一定是从前向后遍历。
   股票只能买入一次，卖出一次，要先买，才能卖，
   dp[i][0] = max(dp[i-1][0], -prices[i])，而不是max（dp[i-1][0], dp[i-1][1]-prices[i]）

动态规划

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        length = len(prices)
        if len == 0:
            return 0
        dp = [[0] * 2 for _ in range(length)]
        dp[0][0] = -prices[0]
        dp[0][1] = 0
        for i in range(1, length):
            dp[i][0] = max(dp[i-1][0], -prices[i])
            dp[i][1] = max(dp[i-1][1], prices[i] + dp[i-1][0])
        return dp[-1][1]

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        length = 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

贪心法

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        low = float("inf")
        result = 0
        for i in range(len(prices)):
            low = min(low, prices[i]) #取最左最小价格
            result = max(result, prices[i] - low) #直接取最大区间利润
        return result

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

力扣链接

动规五部曲

1. 确定dp数组（dp table）以及下标的含义
   dp[i][0] 表示第i天持有股票所得最多现金,dp[i][1] 表示第i天不持有股票所得最多现金
2. 确定递推公式
   dp[i][0] = max(dp[i-1][0], dp[i-1][1]-price[i])
   dp[i][1]=max(dp[i-1][1], dp[i-1][0]+price[i])
3. dp数组初始化
   那么dp[0][0]表示第0天持有股票，此时的持有股票就一定是买入股票了，因为不可能有前一天推出来，所以dp[0][0] -= prices[0];
   dp[0][1]表示第0天不持有股票，不持有股票那么现金就是0，所以dp[0][1] = 0;
4. 遍历顺序
   和上一题的区别在于，本题股票可以买卖多次

dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);

时间复杂度：O(n) 空间复杂度：O(n)

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        length = len(prices)
        dp = [[0] * 2 for _ in range(length)]
        dp[0][0] = -prices[0]
        dp[0][1] = 0
        for i in range(1, length):
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] - prices[i]) #注意这里是和121. 买卖股票的最佳时机唯一不同的地方
            dp[i][1] = max(dp[i-1][1], dp[i-1][0] + prices[i])
        return dp[-1][1]

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

力扣链接

动规五部曲

1. 确定dp数组（dp table）以及下标的含义
   
2. 确定递推公式
   dp[i][1]=max(dp[i-1][1], -price[i])
   dp[i][2]=max(dp[i-1][2], dp[i-1][1]+price[i])
   dp[i][3] = max(dp[i-1][3], dp[i-1][2]-price[i])
   dp[i][4] = max(dp[i-1][4],dp[i-1][3]+price[i])
3. dp数组初始化
   那么dp[0][0]表示第0天持有股票，所以dp[0][0] = -prices[0];
   dp[0][1]表示第0天不持有股票，不持有股票那么现金就是0，所以dp[0][1] = 0;
   dp[0][3] = -prices[0]
   dp[0][4] = 0
4. 遍历顺序 ：dp[i]都是由dp[i - 1]推导出来的，那么一定是从前向后遍历。
   股票至多买卖两次，可以买卖2次，买卖1次，或者不买卖
   第二次必须在第一次之后后面，控制dp[i][3] = max(dp[i-1][3], dp[i-1][2] - prices[i])，而不是dp[i][3] = max(dp[i-1][3], dp[i-1][4] - prices[i])，后面这种是两个独立的一次买卖
   现在最大的时候一定是卖出的状态，而两次卖出的状态现金最大一定是最后一次卖出。如果想不明白的录友也可以这么理解：如果第一次卖出已经是最大值了，那么我们可以在当天立刻买入再立刻卖出。所以dp[4][4]已经包含了dp[4][2]的情况。也就是说第二次卖出手里所剩的钱一定是最多的。

时间复杂度：O(n) 空间复杂度：O(n × 5)

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if len(prices) == 0:
            return 0
        dp = [[0] * 5 for _ in range(len(prices))]
        dp[0][1] = -prices[0]
        dp[0][3] = -prices[0]
        for i in range(1, len(prices)):
            dp[i][0] = dp[i-1][0]
            dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i])
            dp[i][2] = max(dp[i-1][2], dp[i-1][1] + prices[i])
            dp[i][3] = max(dp[i-1][3], dp[i-1][2] - prices[i])
            dp[i][4] = max(dp[i-1][4], dp[i-1][3] + prices[i])
        return dp[-1][4]

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if len(prices) == 0:
            return 0
        dp = [0] * 5 
        dp[1] = -prices[0]
        dp[3] = -prices[0]
        for i in range(1, len(prices)):
            dp[1] = max(dp[1], dp[0] - prices[i])
            dp[2] = max(dp[2], dp[1] + prices[i])
            dp[3] = max(dp[3], dp[2] - prices[i])
            dp[4] = max(dp[4], dp[3] + prices[i])
        return dp[4]

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

力扣链接

动规五部曲

1. 确定dp数组（dp table）以及下标的含义
   二维数组 dp[i][j] ：第i天的状态为j，所剩下的最大现金是dp[i][j]
   j的状态表示为：
   0 表示不操作
   1 第一次买入
   2 第一次卖出
   3 第二次买入
   4 第二次卖出。。。。。
   dp[i][1]，表示的是第i天，买入股票的状态，并不是说一定要第i天买入股票，这是很多同学容易陷入的误区。
2. 确定递推公式
   最多有k次交易
   dp[i][2k-1] = max(dp[i-1][2k-1], dp[i-1][2k-2]-price[i])
   dp[i][2k]=max(dp[i-1][2k], dp[i-1][2k-1]+price[i])
3. dp数组初始化
   那么dp[0][0]表示第0天持有股票，此时的持有股票就一定是买入股票了，因为不可能有前一天推出来，所以dp[0][0] -= prices[0];
   dp[0][1]表示第0天不持有股票，不持有股票那么现金就是0，所以dp[0][1] = 0;
4. 遍历顺序

class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:
        if len(prices) == 0:
            return 0
        dp = [[0] * (2*k+1) for _ in range(len(prices))]
   #初始化dp数组
        for j in range(1, 2*k, 2):
            dp[0][j] = -prices[0]
        for i in range(1, len(prices)):
            for j in range(0, 2*k-1, 2):
                dp[i][j+1] = max(dp[i-1][j+1], dp[i-1][j] - prices[i])
                dp[i][j+2] = max(dp[i-1][j+2], dp[i-1][j+1] + prices[i])
        return dp[-1][2*k]

309.买卖股票的最佳时期含冷冻期【困难】

动规五部曲

1. 确定dp数组（dp table）以及下标的含义
   dp[i][j]，第i天状态为j，所剩的最多现金为dp[i][j]。
   持有股票:max(昨天就持有,昨天没有今天刚买）
   不持有股票:
   1. 昨天就不持有，今天保持【昨天就是冷冻期、昨天前在冷冻期】
   2. 今天是冷冻期
   3. 刚卖出去

2. 确定递推公式
   dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][2], dp[i-1][1]) - prices[i]);
   dp[i][1] = max(dp[i - 1][1], dp[i - 1][2])
   dp[i][2] = dp[i-1][3]
   dp[i][3] = dp[i-1][0]+price[i]

3. dp数组初始化
   那么dp[0][0]表示第0天持有股票，最大现金 dp[0][0] = -prices[0];
   dp[0][1]=0
   dp[0][2] = 0
   dp[0][3] = 0

4. 遍历顺序

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if len(prices) == 0: return 0
    ## 创建动态规划数组，4个状态分别表示持有股票、不持有股票且处于冷冻期、不持有股票且不处于冷冻期、不持有股票且当天卖出后处于冷冻期
        dp = [[0] * 4 for _ in range(len(prices))]
        #初始化
        dp[0][0] = -prices[0]
        for i in range(1, len(prices)):
            dp[i][0] = max(dp[i-1][0], max(dp[i-1][2], dp[i-1][1]) - prices[i]) # 当前持有股票的最大利润等于前一天持有股票的最大利润或者前一天不持有股票且不处于冷冻期的最大利润减去当前股票的价格
            dp[i][1] = max(dp[i-1][2], dp[i-1][1])# 当前不持有股票且处于冷冻期的最大利润等于前一天持有股票的最大利润加上当前股票的价格
            dp[i][2] = dp[i-1][3] # 当前不持有股票且不处于冷冻期的最大利润等于前一天不持有股票的最大利润或者前一天处于冷冻期的最大利润
            dp[i][3] = dp[i-1][0] + prices[i] # 当前不持有股票且当天卖出后处于冷冻期的最大利润等于前一天不持有股票且不处于冷冻期的最大利润
        return max(dp[-1])

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

力扣链接

动规五部曲

1. 确定dp数组（dp table）以及下标的含义
   二维数组 dp[i][0] ：第i天,持有股票，所获得最大现金
   dp[i][1]:第i天，不持有股票，所获得的最大现金
2. 确定递推公式
   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);
3. dp数组初始化
   那么dp[0][0]表示第0天持有股票，最大现金 dp[0][0] -= prices[0];
   dp[0][1]表示第0天不持有股票，最大现金，所以dp[0][1] = max(-fee,0)=0;
4. 遍历顺序

class Solution:
    def maxProfit(self, prices: List[int], fee: int) -> int:
        n = len(prices)
        dp = [[0] * 2 for _ in range(n)]
    #dp数组初始化
        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] - fee)
        return max(dp[-1][0], dp[-1][1])

股票问题总结

dp[i][0] 表示第i天持有股票所得现金。
dp[i][1] 表示第i天不持有股票所得现金。

1. 只能买卖一次
   第i天买入股票，那么第i-1天不持有股票是0

dp[i][0] = max(dp[i - 1][0], -prices[i]);

2. 可以买卖多次

dp[i][0] = max(dp[i - 1][0], dp[i-1][1] - prices[i]);

3. 最多买卖2次

dp[i][j]中 i表示第i天，j为 [0 - 4] 五个状态，dp[i][j]表示第i天状态j所剩最大现金。

4. 最多买卖K次

使用二维数组 dp[i][j] ：第i天的状态为j，所剩下的最大现金是dp[i][j]
0不操作
j = 2k-1 代表第k次买入    j = 2k 代表第k次卖出

5. 买卖多次，卖出有一天冷冻期

本题则可以花费为四个状态
dp[i][j]：第i天状态为j，所剩的最多现金为dp[i][j]。

状态一：买入股票状态（今天买入股票，或者是之前就买入了股票然后没有操作）

卖出股票：
状态二： 昨天是冷冻期， 昨天前是冷冻期
状态三： 今天是冷冻期
状态四： 今天刚卖出

6. 买卖多次，每次有手续费

dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);