M

MLOG

中文

通过实例和全球视角，探索记忆化这一强大的动态规划技术。提升您的算法技能，高效解决复杂问题。

精通动态规划：提升解题效率的记忆化模式

动态规划 (Dynamic Programming, DP) 是一种强大的算法技术，通过将优化问题分解为更小的、重叠的子问题来解决。DP 不会重复解决这些子问题，而是存储它们的解，并在需要时重用，从而显著提高效率。记忆化是一种特定的自顶向下的 DP 方法，我们使用缓存（通常是字典或数组）来存储高开销函数调用的结果，并在再次出现相同输入时返回缓存的结果。

什么是记忆化？

记忆化本质上是“记住”计算密集型函数调用的结果，并在之后重用。它是一种通过避免冗余计算来加速执行的缓存形式。可以把它想象成在参考书中查找信息，而不是每次需要时都重新推导一遍。

记忆化的关键要素是：

为什么要使用记忆化？

记忆化的主要好处是提高性能，特别是对于那些用朴素方法解决时具有指数级时间复杂度的难题。通过避免冗余计算，记忆化可以将执行时间从指数级降低到多项式级，从而使棘手的问题变得易于处理。这在许多实际应用中至关重要，例如：

记忆化模式与示例

让我们通过一些实际示例来探索一些常见的记忆化模式。

1. 经典的斐波那契数列

斐波那契数列是展示记忆化力量的经典例子。该数列定义如下：F(0) = 0, F(1) = 1, F(n) = F(n-1) + F(n-2) 当 n > 1。一个朴素的递归实现由于冗余计算，将具有指数级的时间复杂度。

朴素递归实现 (不使用记忆化)

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

这个实现效率极低，因为它会多次重复计算相同的斐波那契数。例如，要计算 `fibonacci_naive(5)`，`fibonacci_naive(3)` 会被计算两次，而 `fibonacci_naive(2)` 会被计算三次。

记忆化斐波那契实现

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

这个记忆化版本显著提高了性能。`memo` 字典存储了先前计算过的斐波那契数的结果。在计算 F(n) 之前，函数会检查它是否已经在 `memo` 中。如果是，则直接返回缓存的值。否则，计算该值，存入 `memo`，然后返回。

示例 (Python):

print(fibonacci_memo(10)) # 输出: 55
print(fibonacci_memo(20)) # 输出: 6765
print(fibonacci_memo(30)) # 输出: 832040

记忆化斐波那契函数的时间复杂度是 O(n)，与朴素递归实现的指数级时间复杂度相比有了显著的改进。由于 `memo` 字典，空间复杂度也是 O(n)。

2. 网格遍历 (路径数量)

考虑一个大小为 m x n 的网格。您只能向右或向下移动。从左上角到右下角有多少条不同的路径？

朴素递归实现

def grid_paths_naive(m, n):
  if m == 1 or n == 1:
    return 1
  return grid_paths_naive(m-1, n) + grid_paths_naive(m, n-1)

由于存在重叠子问题，这个朴素实现具有指数级的时间复杂度。要计算到达单元格 (m, n) 的路径数，我们需要计算到达 (m-1, n) 和 (m, n-1) 的路径数，而这又需要计算到达它们前驱节点的路径，以此类推。

记忆化网格遍历实现

def grid_paths_memo(m, n, memo={}):
  if (m, n) in memo:
    return memo[(m, n)]
  if m == 1 or n == 1:
    return 1
  memo[(m, n)] = grid_paths_memo(m-1, n, memo) + grid_paths_memo(m, n-1, memo)
  return memo[(m, n)]

在这个记忆化版本中，`memo` 字典存储了每个单元格 (m, n) 的路径数量。函数首先检查当前单元格的结果是否已在 `memo` 中。如果是，则返回缓存的值。否则，计算该值，存入 `memo`，然后返回。

示例 (Python):

print(grid_paths_memo(3, 3)) # 输出: 6
print(grid_paths_memo(5, 5)) # 输出: 70
print(grid_paths_memo(10, 10)) # 输出: 48620

记忆化网格遍历函数的时间复杂度是 O(m*n)，与朴素递归实现的指数级时间复杂度相比有了显著的改进。由于 `memo` 字典，空间复杂度也是 O(m*n)。

3. 零钱兑换 (最少硬币数量)

给定一组硬币面额和一个目标金额，找出组成该金额所需的最少硬币数量。您可以假设每种面额的硬币都有无限供应。

朴素递归实现

def coin_change_naive(coins, amount):
  if amount == 0:
    return 0
  if amount < 0:
    return float('inf')
  min_coins = float('inf')
  for coin in coins:
    num_coins = 1 + coin_change_naive(coins, amount - coin)
    min_coins = min(min_coins, num_coins)
  return min_coins

这个朴素的递归实现会探索所有可能的硬币组合，导致指数级的时间复杂度。

记忆化零钱兑换实现

def coin_change_memo(coins, amount, memo={}):
  if amount in memo:
    return memo[amount]
  if amount == 0:
    return 0
  if amount < 0:
    return float('inf')
  min_coins = float('inf')
  for coin in coins:
    num_coins = 1 + coin_change_memo(coins, amount - coin, memo)
    min_coins = min(min_coins, num_coins)
  memo[amount] = min_coins
  return min_coins

记忆化版本将每个金额所需的最少硬币数存储在 `memo` 字典中。在计算给定金额的最少硬币数之前，函数会检查结果是否已在 `memo` 中。如果是，则返回缓存的值。否则，计算该值，存入 `memo`，然后返回。

示例 (Python):

coins = [1, 2, 5]
amount = 11
print(coin_change_memo(coins, amount)) # 输出: 3

coins = [2]
amount = 3
print(coin_change_memo(coins, amount)) # 输出: inf (无法找零)

记忆化零钱兑换函数的时间复杂度是 O(amount * n)，其中 n 是硬币面额的数量。由于 `memo` 字典，空间复杂度是 O(amount)。

关于记忆化的全球视角

动态规划和记忆化的应用是普遍的，但由于不同地区的经济、社会和技术背景各异，所解决的具体问题和数据集也常常有所不同。例如：

记忆化的最佳实践

高级记忆化技术

结论

记忆化是一种通过缓存高开销函数调用的结果来优化递归算法的强大技术。通过理解记忆化的原理并策略性地应用它们，您可以显著提高代码的性能，并更有效地解决复杂问题。从斐波那契数列到网格遍历和零钱兑换，记忆化为应对各种计算挑战提供了多功能的工具集。在您不断发展算法技能的过程中，精通记忆化无疑将成为您解决问题工具库中的宝贵财富。

请记住要考虑问题的全球背景，根据不同地区和文化的具体需求和限制来调整您的解决方案。通过拥抱全球视角，您可以创造出更有效、更具影响力的解决方案，从而惠及更广泛的受众。

精通动态规划：提升解题效率的记忆化模式 | MLOG