Fibonacci序列生成算法的优化

Question

众所周知，生成Fibonacci序列的最简单算法如下：

if(n<=0) return 0;
else if(n==1) return 1;
f(n) = f(n-1) + f(n-2);

但是这个算法有一些重复计算。例如，如果计算f（5），它将计算f（4）和f（3）。计算f（4）时，它将再次计算f（3）和f（2）。有人能给我一个更节省时间的递归算法吗？

Answer 1

一种简单的方法是迭代计算而不是递归计算。这将以线性时间计算F（n）。

def fib(n):
    a,b = 0,1
    for i in range(n):
        a,b = a+b,a
    return a

Answer 2

在这里查看使用公式的implementation in Erlang 。它显示了良好的线性结果行为，因为O(M(n) log n)部分M(n)对于大数字是指数的。它在2s中计算一百万的fib，其中结果有208988个数字。诀窍是你可以使用（尾部）递归公式计算O(log n)乘法中的取幂（当使用适当的编译器或重写循环时，尾部意味着O(1)空间）：

% compute X^N
power(X, N) when is_integer(N), N >= 0 ->
    power(N, X, 1).

power(0, _, Acc) ->
    Acc;
power(N, X, Acc) ->
    if N rem 2 =:= 1 ->
            power(N - 1,   X,     Acc * X);
        true ->
            power(N div 2, X * X, Acc)
    end.

其中X和Acc替换为矩阵。 X将以和Acc开头，其中I标识等于。

Answer 3

提示：使用Binet's formula：

可以获得更快结果的一种方法

以下是在Python中执行此操作的方法：

from decimal import *

def fib(n):
    return int((Decimal(1.6180339)**Decimal(n)-Decimal(-0.6180339)**Decimal(n))/Decimal(2.236067977))

Answer 4

您可以保存结果并使用它们：

public static long[] fibs;

public long fib(int n) {
    fibs = new long[n];
    return internalFib(n);
}
public long internalFib(int n) {
    if (n<=2) return 1;
    fibs[n-1] = fibs[n-1]==0 ? internalFib(n-1) : fibs[n-1];
    fibs[n-2] = fibs[n-2]==0 ? internalFib(n-2) : fibs[n-2];
    return fibs[n-1]+fibs[n-2];
}

Answer 5

我已经阅读了一些计算斐波纳契数的方法，这些方法具有高效的时间复杂度，下面是其中的一些方法-

方法1-动态编程 现在这里的子结构是众所周知的，因此我将直接跳转到解决方案-

static int fib(int n) 
{ 
int f[] = new int[n+2]; // 1 extra to handle case, n = 0 
int i; 

f[0] = 0; 
f[1] = 1; 

for (i = 2; i <= n; i++) 
{ 
    f[i] = f[i-1] + f[i-2]; 
} 

return f[n]; 
}

上述的空间优化版本可以按以下步骤完成-

static int fib(int n) 
 { 
    int a = 0, b = 1, c; 
    if (n == 0) 
        return a; 
    for (int i = 2; i <= n; i++) 
    { 
        c = a + b; 
        a = b; 
        b = c; 
    } 
    return b; 
} 

方法2-（使用矩阵{{1,1}，{1,0}}的幂）

这是一个O（n），它依赖于以下事实：如果我们n次将矩阵M = {{{1,1}，{1,0}}与其自身相乘（换句话说，计算power（M，n） ），然后获得第（n + 1）个斐波那契数作为结果矩阵中行和列（0，0）的元素。该解决方案将具有O（n）时间。

矩阵表示法给出了斐波那契数的以下闭合表达式： Fibonaccimatrix

static int fib(int n) 
{ 
int F[][] = new int[][]{{1,1},{1,0}}; 
if (n == 0) 
    return 0; 
power(F, n-1); 

return F[0][0]; 
} 

/*multiplies 2 matrices F and M of size 2*2, and 
puts the multiplication result back to F[][] */
static void multiply(int F[][], int M[][]) 
{ 
int x = F[0][0]*M[0][0] + F[0][1]*M[1][0]; 
int y = F[0][0]*M[0][1] + F[0][1]*M[1][1]; 
int z = F[1][0]*M[0][0] + F[1][1]*M[1][0]; 
int w = F[1][0]*M[0][1] + F[1][1]*M[1][1]; 

F[0][0] = x; 
F[0][1] = y; 
F[1][0] = z; 
F[1][1] = w; 
} 

/*function that calculates F[][] raise to the power n and puts the 
result in F[][]*/
static void power(int F[][], int n) 
{ 
int i; 
int M[][] = new int[][]{{1,1},{1,0}}; 

// n - 1 times multiply the matrix to {{1,0},{0,1}} 
for (i = 2; i <= n; i++) 
    multiply(F, M); 
} 

可以将其优化为以O（Logn）时间复杂度工作。我们可以使用先前的方法进行递归乘法以获得幂（M，n）。

static int fib(int n) 
{ 
int F[][] = new int[][]{{1,1},{1,0}}; 
if (n == 0) 
    return 0; 
power(F, n-1); 

return F[0][0]; 
} 

static void multiply(int F[][], int M[][]) 
{ 
int x =  F[0][0]*M[0][0] + F[0][1]*M[1][0]; 
int y =  F[0][0]*M[0][1] + F[0][1]*M[1][1]; 
int z =  F[1][0]*M[0][0] + F[1][1]*M[1][0]; 
int w =  F[1][0]*M[0][1] + F[1][1]*M[1][1]; 

F[0][0] = x; 
F[0][1] = y; 
F[1][0] = z; 
F[1][1] = w; 
} 

static void power(int F[][], int n) 
{ 
if( n == 0 || n == 1) 
  return; 
int M[][] = new int[][]{{1,1},{1,0}}; 

power(F, n/2); 
multiply(F, F); 

if (n%2 != 0) 
   multiply(F, M); 
} 

方法3（O（log n）时间） 下面是一个更有趣的递归公式，可用于在O（log n）时间中找到第n个斐波那契数。

如果n为偶数，则k = n / 2： F（n）= [2 * F（k-1）+ F（k）] * F（k）

如果n为奇数，则k =（n + 1）/ 2 F（n）= F（k）* F（k）+ F（k-1）* F（k-1） 这个公式如何运作？ 该公式可以从上述矩阵方程式导出。 Fibonaccimatrix

考虑双方的决定因素，我们得到 （-1）n = Fn + 1Fn-1 – Fn2 此外，由于对于任何正方形矩阵A，AnAm = An + m，可以得出以下恒等式（它们是从矩阵乘积的两个不同系数中获得的）

FmFn + Fm-1Fn-1 = Fm + n-1

通过放置n = n + 1，

FmFn + 1 + Fm-1Fn = Fm + n

放入m = n

F2n-1 = Fn2 + Fn-12

F2n =（Fn-1 + Fn + 1）Fn =（2Fn-1 + Fn）Fn（来源：Wiki）

要得到证明的公式，我们只需要执行以下操作 如果n是偶数，我们可以把k = n / 2 如果n为奇数，我们可以将k =（n + 1）/ 2

public static int fib(int n) 
{ 

    if (n == 0) 
        return 0; 

    if (n == 1 || n == 2) 
        return (f[n] = 1); 

    // If fib(n) is already computed 
    if (f[n] != 0) 
        return f[n]; 

    int k = (n & 1) == 1? (n + 1) / 2 
                        : n / 2; 

    // Applyting above formula [See value 
    // n&1 is 1 if n is odd, else 0. 
    f[n] = (n & 1) == 1? (fib(k) * fib(k) +  
                    fib(k - 1) * fib(k - 1)) 
                   : (2 * fib(k - 1) + fib(k))  
                   * fib(k); 

    return f[n]; 
} 

方法4-使用公式 在这种方法中，我们直接实现斐波那契数列第n个项的公式。时间O（1）空间O（1） Fn = {[（√5+ 1）/ 2] ^ n} /√5

static int fib(int n) { 
double phi = (1 + Math.sqrt(5)) / 2; 
return (int) Math.round(Math.pow(phi, n)  
                    / Math.sqrt(5)); 
} 

参考：http://www.maths.surrey.ac.uk/hosted-sites/R.Knott/Fibonacci/fibFormula.html

Answer 6

F（n）=（φ^ n）/√5并舍入到最接近的整数，其中φ是黄金比例....

φ^ n可以在O（lg（n））时间内计算，因此F（n）可以在O（lg（n））时间内计算。

Answer 7

// D Programming Language 

void vFibonacci ( const ulong X, const ulong Y, const int Limit ) {    
       // Equivalent : if ( Limit != 10 ). Former ( Limit ^ 0xA ) is More Efficient However.
       if ( Limit ^ 0xA ) {    
           write ( Y, " " ) ;
           vFibonacci ( Y, Y + X, Limit + 1 ) ;
       } ;
} ;

// Call As    
// By Default the Limit is 10 Numbers
vFibonacci ( 0, 1, 0 ) ;

Answer 8

编辑：我实际上认为Hynek Vychodil的答案优于我的，但是我要离开这里以防万一有人正在寻找替代方法。

我认为其他方法都是有效的，但不是最优的。使用Binet的公式原则上应该给出正确的答案，但是舍入到最接近的整数会给n的大值带来一些问题。每次调用函数时，其他解决方案都会不必要地重新计算n值，因此函数不会针对重复调用进行优化。

在我看来，最好的办法是定义一个全局数组，然后在需要的数组中添加新值。在Python中：

import numpy

fibo=numpy.array([1,1])
last_index=fibo.size

def fib(n):
    global fibo,last_index
    if (n>0):
        if(n>last_index):
            for i in range(last_index+1,n+1):
                fibo=numpy.concatenate((fibo,numpy.array([fibo[i-2]+fibo[i-3]])))
            last_index=fibo.size
        return fibo[n-1]
    else:
        print "fib called for index less than 1"
        quit()

当然，如果你需要为n> 80（大约）调用fib，那么你需要实现任意精度整数，这在python中很容易实现。

Answer 9

这将执行得更快，O（n）

def fibo(n):
    a, b = 0, 1
    for i in range(n):
        if i == 0:
            print(i)
        elif i == 1:
            print(i)
        else:
            temp = a
            a = b
            b += temp
    print(b)
n = int(input())
fibo(n)