LeetCode 188题：动态规划解买卖股票最佳时机Ⅳ-代码聚汇网

LeetCode 188题：动态规划解买卖股票最佳时机Ⅳ

Sabrina Lee·2026-08-24·阅读 22 GEO检测（免费）

动态规划LeetCode股票买卖

|难度：普通|阅读约 17 分钟

1. 问题背景与核心挑战

LeetCode 188题"买卖股票的最佳时机Ⅳ"是动态规划系列中颇具挑战性的题目。这道题在LeetCode题库中被标记为"困难"难度，主要考察对状态转移和递归关系的理解能力。题目要求我们在最多进行k次交易的前提下，计算出股票价格序列中能够获得的最大利润。

与经典的"买卖股票的最佳时机"系列其他题目相比，188题的独特之处在于它将交易次数限制扩展到了任意k次，而非简单的1次或无限次。这种设定更贴近现实中的量化交易场景——专业交易员往往需要精确控制每日交易频次以降低冲击成本。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 递归解法的基础框架

2.1 递归关系定义

递归解法的核心在于将大问题分解为相似的小问题。对于股票买卖问题，我们可以定义递归函数dp(i, k, holding)，其中：

i表示当前考虑第i天的股价
k表示剩余可交易次数
holding表示当前是否持有股票（布尔值）

这个函数返回从第i天开始，在剩余k次交易机会且当前持仓状态为holding时能获得的最大利润。

2.2 基础递归实现

最朴素的递归实现包含三个主要分支：

当i超过最后一天时，利润为0
当k为0时，无法交易，利润为0
其他情况下，根据当前是否持有股票决定操作

python复制def maxProfit(k, prices):
    n = len(prices)
    
    def dp(i, remaining_k, holding):
        if i >= n or remaining_k == 0:
            return 0
            
        if holding:
            # 可以选择卖出或持有
            return max(
                prices[i] + dp(i+1, remaining_k-1, False),  # 卖出
                dp(i+1, remaining_k, True)  # 持有
            )
        else:
            # 可以选择买入或观望
            return max(
                -prices[i] + dp(i+1, remaining_k, True),  # 买入
                dp(i+1, remaining_k, False)  # 观望
            )
    
    return dp(0, k, False)

这个实现虽然直观，但存在严重的性能问题——时间复杂度为O(2^n)，对于稍大的n和k就会超时。

3. 记忆化递归优化

3.1 重复子问题分析

观察递归树可以发现，很多状态会被重复计算。例如，在计算dp(3,2,False)时，可能会多次遇到相同的子问题dp(5,1,True)。这种重复计算是导致朴素递归效率低下的主要原因。

3.2 引入记忆化存储

我们可以使用一个三维数组或哈希表来存储已经计算过的状态，避免重复计算：

python复制def maxProfit(k, prices):
    n = len(prices)
    memo = {}
    
    def dp(i, remaining_k, holding):
        if (i, remaining_k, holding) in memo:
            return memo[(i, remaining_k, holding)]
            
        if i >= n or remaining_k == 0:
            return 0
            
        if holding:
            res = max(
                prices[i] + dp(i+1, remaining_k-1, False),
                dp(i+1, remaining_k, True)
            )
        else:
            res = max(
                -prices[i] + dp(i+1, remaining_k, True),
                dp(i+1, remaining_k, False)
            )
        
        memo[(i, remaining_k, holding)] = res
        return res
    
    return dp(0, k, False)

3.3 时间复杂度分析

经过记忆化优化后，每个状态最多计算一次。状态总数为n×k×2（i有n种取值，k有k种取值，holding有2种状态），因此时间复杂度优化为O(n×k)，空间复杂度也是O(n×k)。

4. 边界条件与特殊处理

4.1 交易次数充足的情况

当k ≥ n//2时，相当于可以进行无限次交易。此时问题退化为经典的"买卖股票的最佳时机Ⅱ"，可以采用贪心算法求解：

python复制if k >= n//2:
    max_profit = 0
    for i in range(1, n):
        if prices[i] > prices[i-1]:
            max_profit += prices[i] - prices[i-1]
    return max_profit

4.2 空价格序列处理

当价格序列为空或长度为1时，无法进行任何有效交易：

python复制if not prices or len(prices) == 1:
    return 0

5. 递归与动态规划的对比

5.1 自顶向下 vs 自底向上

递归解法采用自顶向下的思路，从完整问题开始逐步分解；而动态规划通常采用自底向上的方式，从小问题开始构建。递归更符合人类思维习惯，但动态规划通常有更好的常数因子性能。

5.2 空间优化潜力

动态规划解法可以通过滚动数组等方式优化空间复杂度，而递归解法由于需要维护调用栈，空间优化相对困难。对于这个问题，动态规划可以将空间复杂度优化到O(k)。

5.3 实际性能对比

在LeetCode测试用例中，记忆化递归和动态规划的性能差异通常在10%-20%之间。递归解法的优势在于代码更直观易懂，适合在面试中快速实现。

6. 递归解法的调试技巧

6.1 打印递归树

在调试递归算法时，可以添加打印语句显示递归调用关系：

python复制def dp(i, remaining_k, holding, depth=0):
    print("  "*depth + f"dp({i}, {remaining_k}, {holding})")
    # ...其余代码不变...

6.2 记忆化命中统计

添加计数器统计记忆化命中的次数，评估优化效果：

python复制hits = 0
memo = {}

def dp(i, remaining_k, holding):
    global hits
    if (i, remaining_k, holding) in memo:
        hits += 1
        return memo[(i, remaining_k, holding)]
    # ...其余代码不变...

max_profit = dp(0, k, False)
print(f"记忆化命中次数: {hits}")

6.3 小规模测试用例验证

使用小规模测试用例手动计算预期结果，验证算法正确性：

python复制assert maxProfit(2, [3,2,6,5,0,3]) == 7
assert maxProfit(2, [1,2,4,2,5,7,2,4,9,0]) == 13

7. 递归解法的常见误区

7.1 交易次数计算错误

一个常见错误是在买入时减少k值，这会导致交易次数计算错误。正确的做法是在卖出时减少k值，因为一次完整的交易包含买入和卖出两个操作。

7.2 状态转移条件遗漏

容易遗漏holding状态的变化，特别是在卖出操作后忘记将holding设为False，或者在买入操作后忘记设为True。

7.3 基准条件顺序错误

基准条件的判断顺序很重要。应该先检查i是否越界和k是否为0，然后再进行其他计算。错误的顺序可能导致数组越界或无限递归。

8. 性能优化进阶技巧

8.1 早期终止条件

当剩余交易次数为0时，可以立即返回0，不需要继续递归：

python复制if remaining_k == 0:
    return 0

8.2 空间优化版本

虽然递归解法难以像动态规划那样进行空间优化，但可以通过以下方式减少内存使用：

使用lru_cache代替手动记忆化
将holding状态转换为0/1而非True/False
对于大k值，先处理k ≥ n//2的特殊情况

python复制from functools import lru_cache

def maxProfit(k, prices):
    n = len(prices)
    
    if k >= n//2:
        return sum(max(prices[i+1]-prices[i], 0) for i in range(n-1))
    
    @lru_cache(maxsize=None)
    def dp(i, remaining_k, holding):
        if i >= n or remaining_k == 0:
            return 0
            
        if holding:
            return max(
                prices[i] + dp(i+1, remaining_k-1, 0),
                dp(i+1, remaining_k, 1)
            )
        else:
            return max(
                -prices[i] + dp(i+1, remaining_k, 1),
                dp(i+1, remaining_k, 0)
            )
    
    return dp(0, k, 0)

8.3 迭代式深度优先搜索

对于特别大的n和k，可以考虑使用显式栈实现迭代式DFS，避免递归深度过大导致的栈溢出：

python复制def maxProfit(k, prices):
    n = len(prices)
    if k >= n//2:
        return sum(max(prices[i+1]-prices[i], 0) for i in range(n-1))
    
    memo = {}
    stack = [(0, k, False, False)]
    result = 0
    
    while stack:
        i, remaining_k, holding, processed = stack.pop()
        
        if i >= n or remaining_k == 0:
            result = 0
            continue
            
        if (i, remaining_k, holding) in memo:
            result = memo[(i, remaining_k, holding)]
            continue
            
        if not processed:
            stack.append((i, remaining_k, holding, True))
            if holding:
                stack.append((i+1, remaining_k-1, False, False))
                stack.append((i+1, remaining_k, True, False))
            else:
                stack.append((i+1, remaining_k, True, False))
                stack.append((i+1, remaining_k, False, False))
        else:
            if holding:
                res = max(
                    prices[i] + result,
                    result
                )
            else:
                res = max(
                    -prices[i] + result,
                    result
                )
            memo[(i, remaining_k, holding)] = res
            result = res
    
    return result if n > 0 else 0

9. 实际应用中的变种问题

9.1 交易费用考虑

现实交易中通常需要支付手续费，可以在卖出时扣除费用：

python复制fee = 1  # 假设每笔交易手续费为1
if holding:
    return max(
        prices[i] - fee + dp(i+1, remaining_k-1, False),
        dp(i+1, remaining_k, True)
    )

9.2 冷却期限制

卖出后需要等待一天才能买入，可以在卖出后跳过下一天：

python复制if holding:
    return max(
        prices[i] + dp(i+2, remaining_k-1, False),
        dp(i+1, remaining_k, True)
    )

9.3 持仓数量限制

限制最多持有一股，可以通过holding状态自然实现。如需持有多股，需要扩展状态表示。

10. 从递归到动态规划的思维转换

虽然本文重点讨论递归解法，但理解递归到动态规划的转换对全面掌握这类问题很有帮助。两者本质上是相同状态转移方程的不同实现方式。

动态规划解法通常使用三维数组dp[i][k][h]表示状态，按照i从大到小的顺序填充数组。这种解法虽然代码稍长，但通常运行效率更高，更适合生产环境使用。

递归解法的优势在于：

更直观，更容易在面试中快速实现
状态转移逻辑更清晰可见
对于复杂状态转移条件更容易调试

在实际应用中，可以根据具体场景选择最合适的实现方式。对于LeetCode等编程竞赛场景，记忆化递归通常是快速解题的有效选择。