【递归】(三) (Memorization) 记忆化技术

最新推荐文章于 2023-01-09 21:47:42 发布

何处闻韶

最新推荐文章于 2023-01-09 21:47:42 发布

阅读量708

点赞数

分类专栏：【LeetCode笔记】

本文链接：https://blog.csdn.net/qq_39478403/article/details/107468507

版权

这篇博客探讨了递归中的重复计算问题，通过斐波那契数列的计算实例展示了记忆化技术的重要性。文章详细介绍了如何使用记忆化递归提高算法性能，包括有记忆递归的实现以及官方和自定义的解决方案。此外，还讨论了爬楼梯问题，利用数学方法和斐波那契数列的特性提出了解决策略，并分析了不同方法的时间复杂度和空间复杂度。

摘要由CSDN通过智能技术生成

一、递归中的重复计算

# Python implementation
def fibonacci(n):
    """
    :type n: int
    :rtype: int
    """
    if n < 2:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)

def fib(self, N):
    """
    :type N: int
    :rtype: int
    """
    cache = {}
    def recur_fib(N):
        if N in cache:
            return cache[N]
        if N < 2:
            result = N
        else:
            result = recur_fib(N-1) + recur_fib(N-2)

        # put result in cache for later reference.
        cache[N] = result
        return result

    return recur_fib(N)

参考文献：https://leetcode-cn.com/explore/orignial/card/recursion-i/258/memorization/1211/

二、斐波那契数

2.1 题目要求

2.2 解决过程

个人实现

法一：无记忆递归。

2020/07/19 - 18.27% (800ms) - 最简单但低效的方法

class Solution:
    def fib(self, N: int) -> int:
        if N == 1:
            return 1
        if N == 0:
            return 0
        return self.fib(N-1) + self.fib(N-2)

法二：有记忆递归。使用字典 memory 来记忆计算过的结果，避免重复冗余的计算。

2020/07/19 - 53.74% (44ms) - 性能显著提升，但由于实现存在问题，未能发挥最佳效果 (对比官方法三)

class Solution:
    def __init__(self):
        self.memory = {0: 0, 1: 1}  # 计算记录, 但其实这种方式效率并不高, 详见官方法三

    def fib(self, N: int) -> int:
        if N in self.memory:
            return self.memory[N]
        else:
            self.memory[N] = self.fib(N-1) + self.fib(N-2)  # 记忆
        
        return self.memory[N]

官方实现与说明

class Solution:
    def fib(self, N: int) -> int:
        if N <= 1:
            return N
        return self.fib(N-1) + self.fib(N-2)

2020/07/19 - 12.98% (800ms)

class Solution:
    def fib(self, N: int) -> int:
        if N <= 1:
            return N
        return self.memoize(N)

    def memoize(self, N: int) -> {}:
        cache = {0: 0, 1: 1}
        # Since range is exclusive and we want to include N, we need to put N+1.
        for i in range(2, N+1):
            cache[i] = cache[i-1] + cache[i-2]
        return cache[N]

2020/07/19 - 73.37% (40ms)

## 这比个人实现二还要好, 注意对比 cache 的来源与差异
class Solution:
    def fib(self, N: int) -> int:
        if N <= 1:
            return N
        self.cache = {0: 0, 1: 1}  # 比放在数据成员的个人实现法二要好
        return self.memoize(N)

    def memoize(self, N: int) -> {}:
        if N in self.cache:
            return self.cache[N]
        self.cache[N] = self.memoize(N-1) + self.memoize(N-2)
        return self.memo