即使有记忆，我的程序也不能运行得那么快

Question

我在项目 euler 上尝试了一个问题，我需要找到 400 万以下的所有斐波那契项的总和。 我花了很长时间，但后来我发现我可以使用 memoization 来做到这一点，但似乎还需要很长时间。 经过大量研究，我发现我可以使用一个名为 lru_cache 的内置模块。 我的问题是：为什么它不像记忆一样快？

这是我的代码：

from functools import lru_cache


@lru_cache(maxsize=1000000)
def fibonacci_memo(input_value):
    global value
    fibonacci_cache = {}
    if input_value in fibonacci_cache:
        return fibonacci_cache[input_value]
    if input_value == 0:
        value = 1
    elif input_value == 1:
        value = 1
    elif input_value > 1:
        value = fibonacci_memo(input_value - 1) + fibonacci_memo(input_value - 2)
        fibonacci_cache[input_value] = value
    return value


def sumOfFib():
    SUM = 0
    for n in range(500):
        if fibonacci_memo(n) < 4000000:
            if fibonacci_memo(n) % 2 == 0:
                SUM += fibonacci_memo(n)
    return SUM


print(sumOfFib())

顺便说一句，代码有效。 当我使用 lru_cache 模块时，运行它只需不到一秒钟。

Answer 1

另一个答案是计算斐波那契数列的正确方法，确实，但你也应该知道为什么你的记忆不起作用。 再具体一点：

fibonacci_cache = {}

此行位于 function 内意味着每次调用 fibonacci_memo 时都在清空缓存。

Answer 2

您不应该计算斐波那契数列，甚至不应该通过动态编程。 由于斐波那契数列满足具有常数系数和常数阶的线性递推关系，因此它们的和的序列也是如此。

绝对不要缓存所有值。 这将使您不必要地消耗 memory。 当重复具有恒定顺序时，您只需要记住与重复顺序一样多的先前术语。

此外，还有一种方法可以将常数阶的递归转换为一阶的系统递归。 后者的解由矩阵的幂给出。 对于较大的n值，这提供了更快的算法。 不过，每一步都会更昂贵。 因此，最好的方法是结合使用这两种方法，对于较小的n值选择第一种方法，对于较大的输入选择后者。

O(n) 使用递归求和

表示S_n=F_0+F_1+...+F_n是第一个斐波那契数F_0,F_1,...,F_n的总和。

请注意

• S_{n+1}-S_n=F_{n+1}
• S_{n+2}-S_{n+1}=F_{n+2}
• S_{n+3}-S_{n+2}=F_{n+3}

由于F_{n+3}=F_{n+2}+F_{n+1}我们得到S_{n+3}-S_{n+2}=S_{n+2}-S_n 。 所以

S_{n+3}=2S_{n+2}-S_n

初始条件S_0=F_0=1 、 S_1=F_0+F_1=1+1=2和S_2=S_1+F_2=2+2=4 。

您可以做的一件事是自下而上计算S_n ，在每一步仅记住前三个项的值。 您不需要记住S_k的所有值，从k=0到k=n 。 这为您提供了一个O(n)算法，其中O(1)数量的 memory。

---

O(ln(n)) 通过矩阵求幂

您还可以通过以下方式获得O(ln(n))算法：

调用X_n为具有分量S_{n+2},S_{n+1},S_{n}的列向量

所以，上面的递归给出了递归

X_{n+1}=AX_n

其中A是矩阵

[
 [2,0,-1],
 [1,0,0],
 [0,1,0],
]

因此， X_n=A^nX_0 。 我们有X_0 。 要乘以A^n ，我们可以通过平方来求幂。

Answer 3

为了完整起见，这里是@NotDijkstra 的回答中描述的一般思想的实现以及我的谦虚优化，包括在 integer 算术中实现的“封闭形式”解决方案。

我们可以看到，“智能”方法不仅速度快了一个数量级，而且似乎与 Python 大整数比天真的乘法使用更好的事实（感谢@NotDijkstra）更好地兼容。

import numpy as np
import operator as op
from simple_benchmark import BenchmarkBuilder, MultiArgument
B = BenchmarkBuilder()

def pow(b,e,mul=op.mul,unit=1):
    if e == 0:
        return unit
    res = b
    for bit in bin(e)[3:]:
        res = mul(res,res)
        if bit=="1":
            res = mul(res,b)
    return res

def mul_fib(a,b):
    return (a[0]*b[0]+5*a[1]*b[1])>>1 , (a[0]*b[1]+a[1]*b[0])>>1

def fib_closed(n):
    return pow((1,1),n+1,mul_fib)[1]

def fib_mat(n):
    return pow(np.array([[1,1],[1,0]],'O'),n,op.matmul)[0,0]

def fib_sequential(n):
    t1,t2 = 1,1
    for i in range(n-1):
        t1,t2 = t2,t1+t2
    return t2

def sum_fib_direct(n):
    t1,t2,res = 1,1,1
    for i in range(n):
        t1,t2,res = t2,t1+t2,res+t2
    return res
    
def sum_fib(n,method="closed"):
    if method == "direct":
        return sum_fib_direct(n)
    return globals()[f"fib_{method}"](n+2)-1

methods = "closed mat sequential direct".split()

def f(method):
    def f(n):
        return sum_fib(n,method)
    f.__name__ = method
    return f

for method in methods:
    B.add_function(method)(f(method))

B.add_arguments('N')(lambda:(2*(1<<k,) for k in range(23)))

r = B.run()
r.plot()

import matplotlib.pylab as P
P.savefig(fib.png)

Answer 4

我不确定你是如何接近一秒钟的。 这是没有花哨的记忆版本：

class fibs(object):
    def __init__(self):
        self.thefibs = {0:0, 1:1}

    def __call__(self, n):
        if n not in self.thefibs:
            self.thefibs[n] = self(n-1)+self(n-2)
        return self.thefibs[n]

dog = fibs()

sum([dog(i) for i in range(40) if dog(i) < 4000000])