代码随想录算法训练营第48天（py）| 动态规划 | 188.买卖股票的最佳时机IV、309.最佳买卖股票时机含冷冻期、714.买卖股票的最佳时机含手续费

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

力扣链接
最多可以完成 k 笔交易。也就是说，你最多可以买 k 次，卖 k 次。不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

思路

1. 确定dp含义
   第i天的状态为j时，所剩下最大现金是dp[i][j]
   状态包括：0.不操作，1.第一次持有股票，2.第一次不持有股票，3.第二次持有股票，4.第二次不持有股票…
   可以发现，j偶数为卖出，奇数为买入。
   题目要求最多k次交易，那么j = 2*k+1
2. 确定递推公式
   达到dp[i][1]有以下操作：
   (1) 第i天买入，dp[i][1] = dp[i-1][0] - prices[i]
   (2) 第i-1天就已经持有了，dp[i][1] = dp[i-1][1]
   达到dp[i][2]有以下操作：
   (1) 第i天卖出，dp[i][2] = dp[i-1][1] + prices[i]
   (2) 第i-1天就已经不持有了，dp[i][2] = dp[i-1][2]
   以此类推：

for (int j = 0; j < 2 * k - 1; j += 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]);
}

3. 初始化
   dp[0][0] = 0
   dp[0][1] = -prices[0]
   dp[0][2] = 0 #当天买入当天卖出
   dp[0][3] = -prices[0]
   dp[0][4] = 0
   以此类推：

for (int j = 1; j < 2 * k; j += 2) {
    dp[0][j] = -prices[0];
}

4. 确定遍历方向
   从前往后

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

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

力扣链接
可以无限次买卖股票，但卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

思路

1. 确定dp含义
   第i天的状态为j时，所剩下最大现金是dp[i][j]
   状态包括：0.持有股票，1.保持卖出，2.今日卖出，3.今日为冷冻期
2. 确定递推公式
   达到状态0有以下操作：
   (1) 前一天就持有了，dp[i][0] = dp[i - 1][0]
   (2) 今日买入，dp[i - 1][3] - prices[i]或dp[i - 1][1] - prices[i]
   达到状态1有以下操作：
   (1) 前一天就是状态1，dp[i][1] = dp[i - 1][1]
   (2) 前一天是冷冻期，今日依旧不卖，dp[i][1] = dp[i - 1][3]
   达到状态2有以下操作：
   (1) 昨天一定是持有股票的状态，dp[i][2] = dp[i - 1][0] + prices[i]
   达到状态3有以下操作：
   (1) 昨天卖出了，dp[i][3] = dp[i - 1][2]
   综上：

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

3. 初始化
   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:
        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][3], dp[i - 1][1]) - prices[i])
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][3])
            dp[i][2] = dp[i - 1][0] + prices[i]
            dp[i][3] = dp[i - 1][2]
        return max(dp[-1])

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

力扣链接
可以无限次买卖股票，但每笔交易都需要付手续费fee。

思路

和买卖股票的最佳时机 II思路一致，不过需要在递推公式上考虑手续费。
不考虑手续费的递推公式为：

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

考虑手续费：

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

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