动态规划中的第 n 个斐波那契数

Question

每个人都知道斐波那契数列的逻辑

Fib0 = 0
Fib1 = 1
Fibn = Fibn-1 + Fibn-2 , n > 1

我的问题是我必须计算 fib(n)%(100000000+7) 和 输出 应该根据 n

点赞for n=0 output 1

for n=5 output 5

for n=10 output 55

for n=100 output 24278230

我还成功地在scala 中使用tail recursion 对其进行了编码

def fi( n : Int) : Long = { 
  def fib_tail( n: Int, a:Int, b:Int): Int = n match {
    case 0 => a 
    case _ => fib_tail( n-1, b, (a+b))
  }
  return fib_tail( n, 0, 1)
}


   l.map(x=> println(fi(x)%((math.pow(10, 8)).toInt +7  )))

它适用于 0,1,5,10，但它为 100 提供错误的输出，我想要 24278230 为 100

任何人给我一些想法来获得这个输出

Answer 1

我的回答是针对linear recurrence sequences 的一个通用解决方案。您需要一些基本的代数知识才能完全理解它。

让我们有一个向量

然后我们将它与矩阵相乘

我们会收到：

因此，当我们将向量与该矩阵相乘时，我们会得到下一个斐波那契数。但是如果我们将向量乘以 T² 会发生什么？

这样，我们在下一个（第（n+3）个）之后构造了斐波那契数。现在，如果我们从这个向量中的前两个斐波那契数开始并乘以 T^n-1，我们会得到什么？

因此，通过将我们的向量与矩阵 T 相乘，提高到 (n-1) 次方，我们可以得到第 n 个斐波那契数。我们可以通过exponentiation by squaring 在 O(log n) 时间内计算 T^n-1。当然，我们应该通过模 10⁸ + 7 进行所有计算。

这是我的实现链接（Java 中）：http://pastie.org/8519742

这个算法应该适用于 n 的所有正值，直到 2¹⁰⁸。

该方法的示例运行时间（使用与 Peter Lawrey 的 answer 相同的时间测量）：

fib(1,000,000,000,000,000,000) is 8,465,404 took us 1022.8 to calculate
fib(100,000,000,000,000,000) is 60,687,801 took us 325.7 to calculate
fib(10,000,000,000,000,000) is 9,115,009 took us 247.2 to calculate
fib(1,000,000,000,000,000) is 8,361,917 took us 233.3 to calculate
fib(100,000,000,000,000) is 11,279,600 took us 218.3 to calculate
fib(10,000,000,000,000) is 72,758,000 took us 6027.7 to calculate
fib(1,000,000,000,000) is 82,461,898 took us 184.2 to calculate
fib(100,000,000,000) is 60,584,292 took us 180.4 to calculate
fib(10,000,000,000) is 68,453,509 took us 162.0 to calculate
fib(1,000,000,000) is 90,703,191 took us 145.4 to calculate
fib(100,000,000) is 21 took us 131.3 to calculate
fib(10,000,000) is 60,722,758 took us 112.0 to calculate
fib(1,000,000) is 72,117,251 took us 99.8 to calculate
fib(100,000) is 33,178,829 took us 92.3 to calculate
fib(10,000) is 49,520,320 took us 70.8 to calculate
fib(1,000) is 95,802,669 took us 60.1 to calculate
fib(100) is 24,278,230 took us 39.3 to calculate
fib(10) is 55 took us 27.0 to calculate
fib(1) is 1 took us 16.3 to calculate

但是，尽管如此，这不是解决您的问题的最快算法。众所周知，斐波那契数在某些模块下具有周期性残差。在斐波那契数字上引用the wikipedia entry：

可以看出，如果斐波那契数列的成员取 mod n，则所得数列必须是周期最多为 n²-1 的周期。

换句话说，如果您找到这个周期（例如，tortoise and hare algorithm - 线性复杂度），您还可以找到 every 斐波那契数模 10^8+7。

Answer 2

这是我所知道的计算 fib%mod 的最快方法，但您只能看到大约 1000+ 的差异

public static void main(String[] args) {
    long mod = 100_000_007;
    for (int i = 100_000_000; i > 0; i /= 10) {
        long start = System.nanoTime();
        final long l = fibMod3(i, mod);
        long time = System.nanoTime() - start;
        System.out.printf("fib(%,d) %% %,d is %,d took %.1f us to calculate%n", i, mod, l, time / 1e3);
    }
}

// use a simple loop and % each time.
public static long fibMod(int n, long mod) {
    long a = 1, b = 1;
    if (n <= 2) return 1;
    while (n-- > 2) {
        long c = a + b;
        a = b;
        b = c % mod;
    }
    return b;
}

// mod is very expensive so only do this on every third iteration.
public static long fibMod3(int n, long mod) {
    long a = 1, b = 1;
    if (n <= 2) return 1;
    while (n > 5) {
        long c = a + b;
        a = b + c;
        b = (c + a) % mod;
        n -= 3;
    }
    while (n > 2) {
        long c = a + b;
        a = b;
        b = c;
        n--;
    }
    return b % mod;
}

打印

fib(100,000,000) % 100,000,007 is 21 took 546460.1 us to calculate
fib(10,000,000) % 100,000,007 is 60,722,758 took 54079.6 us to calculate
fib(1,000,000) % 100,000,007 is 72,117,251 took 5274.9 us to calculate
fib(100,000) % 100,000,007 is 33,178,829 took 506.0 us to calculate
fib(10,000) % 100,000,007 is 49,520,320 took 50.8 us to calculate
fib(1,000) % 100,000,007 is 95,802,669 took 5.2 us to calculate
fib(100) % 100,000,007 is 24,278,230 took 0.7 us to calculate
fib(10) % 100,000,007 is 55 took 0.3 us to calculate
fib(1) % 100,000,007 is 1 took 0.3 us to calculate

代码预热后，fib(100) 需要 0.7 微秒。如果你循环增加大小，它甚至不会被编译，大约需要 3 微秒。

Answer 3

我用 C++ 编写过代码，效果很好。

LL fi(int n, LL a, LL b) {
   if (n == 0) {
     return a;
  } else {
     return fi(n-1, b, (a+b) % 100000007);
   }
}

你应该在这里Mod：fib_tail( n-1, b, (a+b) % MOD)，否则结果将超出Long的范围。