先从这个系列中最难的那个出发，引出通用的动态规划模板，然后再一题一题解决。这里只给出了模板解法，空间复杂度还可以根据具体题目进一步优化。
一、买卖股票最佳时机 IV 188
https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iv/
给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
1、分析
抽象出来三个状态：是哪一天（i），最多可以完成多少笔交易（k），当前是持有股票还是没有（0表示没有，1 表示有）。用一个三位的DP数组来记录这些状态下对应的最大利润。
状态转移方程如下
dp[i][k][0] = max(dp[i-1][k][0],dp[i-1][k][1]+prices[i]) #i-1天就不持有；或者i-1天持有，i天卖出
dp[i][k][1] = max(dp[i-1][k][1],dp[i-1][k-1][0]-prices[i]) #i-1天就持有；或者i-1天不持有，第i天买入
其中k-1，是由于i天要买入的话，那i-1天的最大交易次数必须是k-1次，否则就不能完成此次交易了。
另外，由于股票有效交易次数最多应该为len(prices)//2。如果k大于该值，则相当于交易次数并无限制。那么状态转移方程可以简化如下：
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])
具体见代码
2、代码
class Solution:
def maxProfit(self, k: int, prices: List[int]) -> int:
n = len(prices)
if n<1: #特判
return 0
if k>n//2: #若k值大于n//2，相当于不限制交易次数，状态转移方程就不一样了（不需要考虑k这个维度的状态变化了）
return self.maxProfit_infk(prices)
dp = [[[0,0] for _ in range(k+1)] for _ in range(n)]
for i in range(n):
for j in range(k,0,-1):
if i-1 == -1: #特化处理，其实就是第一天的状态初始化，放在这里写，是为了后续统一模板
dp[i][j][0] = 0
dp[i][j][1] = -prices[i]
continue
dp[i][j][0] = max(dp[i-1][j][0],dp[i-1][j][1]+prices[i])
dp[i][j][1] = max(dp[i-1][j][1],dp[i-1][j-1][0]-prices[i])
return dp[n-1][k][0]
def maxProfit_infk(self,prices): #不限制交易次数的情况
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],dp[i-1][0]-prices[i])
return dp[n-1][0]
二、买卖股票最佳时机 121
https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
1、分析
本题限制了最大交易次数为1
我们先看通用的状态转移方程
dp[i][k][0] = max(dp[i-1][k][0],dp[i-1][k][1]+prices[i]) #i-1天就不持有；或者i-1天持有，i天卖出
dp[i][k][1] = max(dp[i-1][k][1],dp[i-1][k-1][0]-prices[i]) #i-1天就持有；或者i-1天不持有，第i天买入
当k=1时转化为
dp[i][1][0] = max(dp[i-1][1][0],dp[i-1][1][1]+prices[i]) #i-1天就不持有；或者i-1天持有，i天卖出
dp[i][1][1] = max(dp[i-1][1][1],dp[i-1][0][0]-prices[i]) #i-1天就持有；或者i-1天不持有，第i天买入
因为dp[i-1][0][0]为0，即不允许交易且持有股票，所以为0
简化如下
dp[i][0] = max(dp[i-1][0],dp[i-1][1]+prices[i]) #i-1天就不持有；或者i-1天持有，i天卖出
dp[i][1] = max(dp[i-1][1],-prices[i]) #i-1天就持有；或者i-1天不持有，第i天买入
其他细节见代码
2、代码
class Solution:
def maxProfit(self, 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]
三、买卖股票最佳时机 II 122
https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/
给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。
在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。
返回 你能获得的 最大 利润 。
1、分析
与121的区别在于交易次数不限，与k无关所以简化的状态转移方程如下
dp[i][0] = max(dp[i-1][0],dp[i-1][1]+prices[i]) #i-1天就不持有；或者i-1天持有，i天卖出
dp[i][1] = max(dp[i-1][1],dp[i-1][0]-prices[i]) #i-1天就持有；或者i-1天不持有，第i天买入
具体见代码
2、代码
class Solution:
def maxProfit(self, 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],dp[i-1][0]-prices[i])
return dp[n-1][0]
四、买卖股票的最佳时机 III 123
https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iii/
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
1、分析
这道题目在于限制了交易的次数k，所以要考虑进去，状态转移方程如下
dp[i][k][0] = max(dp[i-1][k][0],dp[i-1][k][1]+prices[i]) #i-1天就不持有；或者i-1天持有，i天卖出
dp[i][k][1] = max(dp[i-1][k][1],dp[i-1][k-1][0]-prices[i]) #i-1天就持有；或者i-1天不持有，第i天买入
直接套用通用模板即可
2、代码
class Solution:
def maxProfit(self, prices: List[int]) -> int:
n = len(prices)
max_k = 2
dp = [[[0,0] for _ in range(max_k+1)] for _ in range(n)]
for i in range(n):
for k in range(max_k,0,-1):
if i-1 == -1:
dp[i][k][0] = 0
dp[i][k][1] = -prices[i]
continue
dp[i][k][0] = max(dp[i-1][k][0],dp[i-1][k][1]+prices[i])
dp[i][k][1] = max(dp[i-1][k][1],dp[i-1][k-1][0]-prices[i])
return dp[n-1][max_k][0]
五、最佳买卖股票时机含冷冻期
给定一个整数数组prices，其中第 prices[i] 表示第 i 天的股票价格 。
设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown/
1、分析
这道题和122的区别在于，买入股票需要有冷冻期，所以状态转移方程，稍微修改一点点就行
dp[i][0] = max(dp[i-1][0],dp[i-1][1]+prices[i]) #i-1天就不持有；或者i-1天持有，i天卖出
dp[i][1] = max(dp[i-1][1],dp[i-2][0]-prices[i]) #i-1天就持有；或者i-2天不持有，第i天买入
具体见代码
2、代码
class Solution:
def maxProfit(self, 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
if i-2 == -1: #特化处理
dp[i][0] = max(dp[i-1][0],dp[i-1][1]+prices[i])
dp[i][1] = max(dp[i-1][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],dp[i-2][0]-prices[i])
return dp[n-1][0]
六、买卖股票最佳时期含手续费 714
给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格 ；整数 fee 代表了交易股票的手续费用。
你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。
返回获得利润的最大值。
注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。
https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/
1、分析
与122的区别仅仅在于多了手续费，所以我们在买入股票的时候算上手续费即可。状态转移方程如下
dp[i][0] = max(dp[i-1][0],dp[i-1][1]+prices[i]) #i-1天就不持有；或者i-1天持有，i天卖出
dp[i][1] = max(dp[i-1][1],dp[i-1][0]-prices[i]-fee) #i-1天就持有；或者i-1天不持有，第i天买入
2、代码
class Solution:
def maxProfit(self, prices: List[int], fee: 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]-fee
continue
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 dp[n-1][0]
869
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
