导语
leetcode刷题笔记记录，主要记录题目包括：
Leetcode 123. 买卖股票的最佳时机III
题目描述
给定一个数组，它的第 i个元素是一支给定的股票在第i天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。
注意： 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
输入： prices = [3,3,5,0,0,3,1,4]
输出： 6
解释： 在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。
示例 2：
输入： prices = [1,2,3,4,5]
输出： 4
解释： 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3：
输入： prices = [7,6,4,3,1]
输出： 0
解释： 在这个情况下, 没有交易完成, 所以最大利润为 0。
示例 4：
输入： prices = [1]
输出： 0
提示：
1 <= prices.length <= 1050 <= prices[i] <= 105
解法
使用动规五部曲：
- 定义dp数组，其中 dp[i][j] 表示在第 i 天，处于 j 状态时的最大现金；
- j = 0: 不操作；
- j = 1: 第1次持有股票
- j = 2: 第1次卖出股票
- j = 3: 第2次持有股票
- j = 4: 第2次卖出股票
- 递推公式：每个状态由前一天的状态和当天的操作得到，具体公式见下面代码
- 初始化：初始化第0天的各种状态如下，其中dp[0][2]可以认为是当天买入后卖出、dp[0][3]是当天买入、卖出后又买入，dp[0][4]是当天买入卖出买入又卖出：
dp[0] = [
0, # 不操作的最大现金是0
-prices[0], # 第一次买入股票后的最大现金
0, # 第一次卖出股票后的最大现金
-prices[0], # 第二次买入股票后的最大现金
0 # 第二次卖出股票后的最大现金
]
- 遍历顺序：从前往后
- 打印dp数组
class Solution:
def maxProfit(self, prices: List[int]) -> int:
# 定义dp数组，其中 dp[i][j] 表示在第 i 天，处于 j 状态时的最大现金
# j = 0: 不操作
# j = 1: 第1次持有股票
# j = 2: 第1次卖出股票
# j = 3: 第2次持有股票
# j = 4: 第2次卖出股票
dp = [[0] * 5 for _ in range(len(prices))]
# 初始化第0天的各种状态
dp[0] = [
0, # 不操作的最大现金是0
-prices[0], # 第一次买入股票后的最大现金
0, # 第一次卖出股票后的最大现金
-prices[0], # 第二次买入股票后的最大现金
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[len(prices) - 1][4]
Leetcode 124. 买卖股票的最佳时机IV
题目描述
给你一个整数数组 prices 和一个整数 k ，其中 prices[i] 是某支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。也就是说，你最多可以买 k 次，卖 k 次。
注意： 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1：
输入： k = 2, prices = [2,4,1]
输出： 2
解释： 在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。
示例 2：
输入： k = 2, prices = [3,2,6,5,0,3]
输出： 7
解释： 在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。
提示：
1 <= k <= 1001 <= prices.length <= 10000 <= prices[i] <= 1000
解法
这道题目是上一道题目的拓展版，相当于把约束条件由2次交易泛化到k次交易，那么通过上次总结的递推公式，不难发现一些规律：
- dp数组的第二个维度大小应该为2*k+1
- 递推公式中，这里类比j为奇数是买，偶数是卖的状态。
- 初识化时，需要将dp[0][j]所有奇数下标的元素值初始化为-prices[0]。
完整代码如下：
class Solution:
def maxProfit(self, k: int, prices: List[int]) -> int:
# dp[i][0] 表示第 i 天不操作状态的最大现金
# dp[i][2 * j + 1] 表示第 i 天第 j 次交易持有股票状态的最大现金
# dp[i][2 * j + 2] 表示第 i 天第 j 次交易不持有股票状态的最大现金
# 初始化动态规划数组
dp = [[0] * (2 * k + 1) for _ in range(len(prices))]
# 初始化第 0 天的状态
for j in range(k):
dp[0][2 * j + 1] = -prices[0]
# 从第 1 天开始，计算每一天的状态
for i in range(1, len(prices)):
# 第 i 天不操作的最大现金（保持前一天的状态）
dp[i][0] = dp[i - 1][0]
# 遍历每一次交易
for j in range(k):
# 第 i 天第 j 次交易持有股票的状态可以来自两种情况：
# 1. 前一天持有股票（保持状态）
# 2. 前一天不持有股票，但今天买入
dp[i][2 * j + 1] = max(dp[i - 1][2 * j + 1], dp[i - 1][2 * j] - prices[i])
# 第 i 天第 j 次交易不持有股票的状态可以来自两种情况：
# 1. 前一天不持有股票（保持状态）
# 2. 前一天持有股票，但今天卖出
dp[i][2 * j + 2] = max(dp[i - 1][2 * j + 2], dp[i - 1][2 * j + 1] + prices[i])
# 返回最后一天完成 k 次交易不持有股票的最大现金
return dp[len(prices) - 1][2 * k]
