Question

我想计算非常大的N值的斐波那契。 10 ^ 6，复杂度为O（logN）。这是我的代码，但它在30秒内给出10 ^ 6的结果，这非常耗时。帮我指出错误。我必须以模10 ^ 9 + 7给出输出。

static BigInteger mod=new BigInteger("1000000007");

BigInteger fibo(long n){
    BigInteger F[][] = {{BigInteger.ONE,BigInteger.ONE},{BigInteger.ONE,BigInteger.ZERO}};
    if(n == 0)
        return BigInteger.ZERO;
    power(F, n-1);
    return F[0][0].mod(mod);
}

void power(BigInteger F[][], long n) {
    if( n == 0 || n == 1)
        return;
    BigInteger M[][] = {{BigInteger.ONE,BigInteger.ONE},{BigInteger.ONE,BigInteger.ZERO}};
    power(F, n/2);
    multiply(F, F);
    if( n%2 != 0 )
        multiply(F, M);
  }

void multiply(BigInteger F[][], BigInteger M[][]){
    BigInteger x =  (F[0][0].multiply(M[0][0])).add(F[0][1].multiply(M[1][0])) ;
    BigInteger y =  F[0][0].multiply(M[0][1]).add(F[0][1].multiply(M[1][1])) ;
    BigInteger z =  F[1][0].multiply(M[0][0]).add( F[1][1].multiply(M[1][0]));
    BigInteger w =  F[1][0].multiply(M[0][1]).add(F[1][1].multiply(M[1][1]));

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

Answer 1

使用这些recurrences：

F _{2 n -1} = F _{n < / sub> ² + F _{n -1} ²}

F _{2 n} =（2 _{n - 1} + F _n） F _{n < /子>}

与memoization一起。例如，在Python中，您可以使用@functools.lru_cache装饰器，如下所示：

from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci_modulo(n, m):
    """Compute the nth Fibonacci number modulo m."""
    if n <= 3:
        return (0, 1, 1, 2)[n] % m
    elif n % 2 == 0:
        a = fibonacci_modulo(n // 2 - 1, m)
        b = fibonacci_modulo(n // 2, m)
        return ((2 * a + b) * b) % m
    else:
        a = fibonacci_modulo(n // 2, m)
        b = fibonacci_modulo(n // 2 + 1, m)
        return (a * a + b * b) % m

这将在几微秒内计算10 ⁶的斐波纳契数（模10 ⁹ + 7）：

>>> from timeit import timeit
>>> timeit(lambda:fibonacci_modulo(10 ** 6, 10 ** 9 + 7), number=1)
0.000083282997366

Answer 2

real 0m2.335s使用您的代码时，我觉得更合理 - 尽管仍然很慢 -

计算Fibonacci数的算法是可以的（有一些调整可以加速它，但没有什么非常戏剧性的），所以问题是大BigInteger s上的操作很慢，{{{ 1}}有近700,000位。

由于您希望计算模F(10^6)的余数，mod = 10^9 + 7适合(mod-1)^2，因此您可以使用long代替{{{{}}来实现更快的实施1}}，计算每一步的余数。直接转录

long

在BigInteger中运行。

N值大的矩阵指数算法

2 个答案: