Мемоизация функции Фибоначчи в Python [дубликат]

Я работаю над проблемой кодовых войн, которая хочет, чтобы вы запомнили последовательность Фибоначчи. Мое решение до сих пор было:

def fibonacci(n):  
    return fibonacci_helper(n, dict())

def fibonacci_helper(n, fib_nums):
    if n in [0, 1]:
        return fib_nums.setdefault(n, n)

    fib1 = fib_nums.setdefault(n - 1, fibonacci_helper(n - 1, fib_nums))
    fib2 = fib_nums.setdefault(n - 2, fibonacci_helper(n - 2, fib_nums))

    return fib_nums.setdefault(n, fib1 + fib2)

Он достаточно хорошо работает для небольших значений n, но значительно замедляется после отметки 30, что заставило меня задуматься - это решение вообще запомнено? Как я могу заставить этот тип решения работать достаточно быстро для больших значений n?

Ваша функция не мемоизирована (по крайней мере, неэффективно), потому что вы вызываете ее fibonacci_helperнезависимо от того, есть ли у вас мемоизированное значение. Это связано с тем, setdefaultчто не происходит никакой магии, которая помешала бы оценке аргументов до их передачи в функцию - вы выполняете рекурсивный вызов до того, как dict проверит, содержит ли он значение.

Смысл мемоизации состоит в том, чтобы избегать выполнения вычислений (в данном случае длительного рекурсивного вызова) в тех случаях, когда вы уже знаете ответ.

Исправить эту реализацию можно примерно так:

def fibonacci(n):  
    return fibonacci_helper(n, {0: 0, 1: 1})

def fibonacci_helper(n, fib_nums):
    if n not in fib_nums:
        fib1 = fibonacci_helper(n-1, fib_nums)
        fib2 = fibonacci_helper(n-2, fib_nums)
        fib_nums[n] = fib1 + fib2
    return fib_nums[n]

Если вам разрешено не изобретать велосипед, вы также можете просто использовать functools.lru_cache, который добавляет мемоизацию к любой функции с помощью магии декораторов:

from functools import lru_cache

@lru_cache
def fibonacci(n):
    if n in {0, 1}:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

Вы обнаружите, что это очень быстро даже для очень высоких значений:

>>> fibonacci(300)
222232244629420445529739893461909967206666939096499764990979600

но если вы определите ту же самую функцию без @lru_cacheнего, она станет очень медленной, потому что не использует кеш.

>>> fibonacci(300)
(very very long wait)

Вы близко. Смысл «памятки» - сохранить вызовы, но вы делаете рекурсивные вызовы независимо от того, был ли уже запомнен результат для аргумента. Значит, вы на самом деле не экономите на звонках. Самый простой - определить кеш вне функции и сразу же вернуть его, если аргумент находится в кеше:

fib_cache = {0 : 0, 1 : 1}

def fib(n):
    if n in fib_cache:
        return fib_cache[n]
    fib_cache[n] = result = fib(n-1) + fib(n-2)
    return result

Тогда кеш будет сохраняться и для вызовов верхнего уровня.

Но теперь возникает другая проблема ;-) Если аргумент достаточно велик (скажем, 30000), вы, вероятно, получите RecursionError(слишком много уровней рекурсивных вызовов). Это не из-за использования кеша, это просто неотъемлемая часть очень глубокой рекурсии.

Вы также можете обойти это, используя кеш, чтобы сначала вызвать меньшие аргументы, продвигаясь к фактическому аргументу. Например, вставьте это после ifблока:

    for i in range(100, n, 100):
        fib(i)

Это гарантирует, что рекурсия никогда не должна проходить более чем на 100 уровней, чтобы найти аргумент, уже сохраненный в кэше. Я подумал, что упомяну об этом, потому что вряд ли кто-нибудь когда-либо сделает это, отвечая на «памятный» вопрос. Но на самом деле записки - это способ не только значительно ускорить некоторые виды рекурсивных алгоритмов, но и применить их к некоторым проблемам, которые «рекурсивны слишком глубоко» без записки, созданной для ограничения максимальной глубины вызова.