递归中重复计算的报错与记忆化优化

递归中重复计算的报错与记忆化优化

引言

递归是编程中强大而优雅的技巧，广泛应用于树遍历、分治算法、动态规划等问题。然而，未经优化的递归常因“重复计算”导致性能急剧下降，甚至栈溢出或超时。尤其在处理斐波那契数列、路径问题、背包问题等场景时，同一子问题被反复求解，造成指数级时间复杂度。本文结合 CSDN 上多位开发者实战经验，系统梳理 递归中重复计算的典型表现、性能瓶颈与高效优化方案，重点介绍 记忆化（Memoization）技术，并通过 大量代码对比、执行树图、性能表格与复杂度分析，助你将低效递归升级为高效算法。

一、递归中的“重复计算”问题剖析

1. 典型案例：斐波那契数列

❌ 原始递归（指数级时间复杂度）

def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

# 计算 fib(5) 的调用树：
#                  fib(5)
#               /          \
#          fib(4)            fib(3)
#         /      \           /      \
#    fib(3)     fib(2)   fib(2)     fib(1)
#    /    \     /    \   /    \
# fib(2) fib(1) fib(1) fib(0) fib(1) fib(0)
# /    \
# fib(1) fib(0)

问题： fib(2) 被计算了 3 次，fib(1) 被计算了 5 次，存在严重重复。

2. 重复计算的代价

💡 结论： 当 n > 40 时，原始递归已不适用于实际场景。

二、记忆化优化（Memoization）—— 核心解决方案

记忆化 是一种“用空间换时间”的优化技术，通过缓存已计算的子问题结果，避免重复求解。

1. 方法一：手动哈希表缓存（Python）

def fib_memo(n, memo={}):
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fib_memo(n - 1, memo) + fib_memo(n - 2, memo)
    return memo[n]

# 测试
print(fib_memo(50))  # 几乎瞬间完成

缓存状态示例：

2. 方法二：使用装饰器 @lru_cache（推荐）

from functools import lru_cache

@lru_cache(maxsize=None)
def fib_cached(n):
    if n <= 1:
        return n
    return fib_cached(n - 1) + fib_cached(n - 2)

# 测试
print(fib_cached(100))  # 快速计算

✅ 优点： 代码简洁，自动管理缓存，支持 maxsize 限制。

3. 方法三：JavaScript 中的记忆化实现

function memoize(fn) {
    const cache = new Map();
    return function(...args) {
        const key = args.toString();
        if (cache.has(key)) {
            return cache.get(key);
        }
        const result = fn.apply(this, args);
        cache.set(key, result);
        return result;
    };
}

// 使用
const fib = memoize(function(n) {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);
});

console.log(fib(50)); // 快速返回

三、记忆化优化前后性能对比表

⚡ 结论： 记忆化将时间复杂度从 O(φ^n) 优化至 O(n)，空间复杂度为 O(n)。

四、经典问题实战：爬楼梯（LeetCode 70）

问题描述

每次可爬 1 或 2 个台阶，求爬 n 阶的方法数。

❌ 原始递归（超时）

def climbStairs(n):
    if n <= 2:
        return n
    return climbStairs(n - 1) + climbStairs(n - 2)

✅ 记忆化优化

from functools import lru_cache

@lru_cache(maxsize=None)
def climbStairs(n):
    if n <= 2:
        return n
    return climbStairs(n - 1) + climbStairs(n - 2)

✅ 进一步优化：滚动数组（O(1) 空间）

def climbStairs(n):
    if n <= 2:
        return n
    a, b = 1, 2
    for i in range(3, n + 1):
        a, b = b, a + b
    return b

五、记忆化在动态规划中的应用

问题：打家劫舍（LeetCode 198）

✅ 记忆化递归（自顶向下 DP）

from functools import lru_cache

def rob(nums):
    n = len(nums)
    
    @lru_cache(maxsize=None)
    def dp(i):
        if i < 0:
            return 0
        return max(dp(i - 1), dp(i - 2) + nums[i])
    
    return dp(n - 1)

对比：自底向上 DP

def rob(nums):
    if not nums:
        return 0
    if len(nums) == 1:
        return nums[0]
    
    dp = [0] * len(nums)
    dp[0] = nums[0]
    dp[1] = max(nums[0], nums[1])
    
    for i in range(2, len(nums)):
        dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])
    
    return dp[-1]

💡 建议： 先写记忆化递归（逻辑清晰），再转为迭代（空间更优）。

六、高级技巧：自定义记忆化键

当递归参数复杂时（如多个参数、对象），需自定义缓存键。

from functools import lru_cache

# 错误：列表不可哈希
# @lru_cache
# def func(arr, i): ...

# 正确：转换为元组
@lru_cache
def func_tuple(arr_tuple, i):
    arr = list(arr_tuple)
    # 处理逻辑
    return sum(arr) + i

# 或使用字符串键
cache = {}
def func_with_cache(arr, i):
    key = f"{tuple(arr)}:{i}"
    if key in cache:
        return cache[key]
    # 计算结果
    result = sum(arr) + i
    cache[key] = result
    return result

七、记忆化优化的局限性

八、总结

记忆化是解决递归重复计算的“银弹”。通过缓存中间结果，可将指数级算法优化为线性级别。关键要点：

• ✅ 优先使用 @lru_cache（Python）或自定义缓存函数（JS）
• ✅ 理解子问题重叠是记忆化的前提
• ✅ 从记忆化递归出发，再优化为空间更优的迭代
• ✅ 注意缓存键的可哈希性与内存占用