可以编写斐波那契函数以在 O(1) 时间内执行吗？

Question

所以，我们看到了很多斐波那契问题。我个人讨厌他们。很多。不止很多。我认为如果我们可以让任何人都无法再次将其用作面试问题，那就太好了。让我们看看如何接近 O(1) 我们可以得到斐波那契。

这是我的开场白，几乎是从维基百科抄来的，当然还有足够的空间。重要的是，这个解决方案对于任何特别大的 fib 都会引爆，并且它包含对幂函数的相对幼稚的使用，如果你的库不好，它在最坏的情况下将其置于 O(log(n))。我怀疑我们可以摆脱幂函数，或者至少专门化它。有人来帮忙吗？除了使用查找表的有限*解决方案之外，是否存在真正的 O(1) 解决方案？

http://ideone.com/FDt3P

#include <iostream>
#include <math.h>
using namespace std; // would never normally do this.

int main()
{
int target = 10;
cin >> target;
// should be close enough for anything that won't make us explode anyway.
float mangle = 2.23607610; 

float manglemore = mangle;
++manglemore; manglemore = manglemore / 2;
manglemore = pow(manglemore, target);
manglemore = manglemore/mangle;
manglemore += .5;
cout << floor(manglemore);

}

*我知道，我知道，对于斐波那契的任何零实际用途来说，这已经足够了。

Answer 1

这是斐波那契数列项的近似O(1) 解决方案。诚然，O(log n) 取决于系统 Math.pow() 实现，但如果你的面试官正在寻找它，它是没有可见循环的斐波那契。 ceil() 是由于返回 0.9 重复的较大值的舍入精度。

JS 中的示例：

function fib (n) {
  var A=(1+Math.sqrt(5))/2,
      B=(1-Math.sqrt(5))/2,
      fib = (Math.pow(A,n) - Math.pow(B,n)) / Math.sqrt(5);
      return Math.ceil(fib);
}

Answer 2

给定任意大的输入，简单地读取 n 需要 O(log n)，因此从这个意义上说，不可能有恒定时间算法。因此，使用封闭形式的解决方案，或预先计算您关心的值，以获得合理的性能。

编辑：在 cmets 中有人指出它实际上更糟，因为斐波那契是 O(phi^n) 打印斐波那契的 结果 是 O(log (phi^n)) 这是 O(n)!强>

Answer 3

以下答案在 O(1) 中执行，但我不确定它是否适合您的问题。它被称为Template Meta-Programming。

#include <iostream>
using namespace std;

template <int N>
class Fibonacci
{
public:
    enum {
        value = Fibonacci<N - 1>::value + Fibonacci<N - 2>::value
    };
};

template <>
class Fibonacci<0>
{
public:
    enum {
        value = 0
    };
};

template <>
class Fibonacci<1>
{
public:
    enum {
        value = 1
    };
};

int main()
{
    cout << Fibonacci<50>::value << endl;
    return 0;
}

Answer 4

在Programming: The Derivation of Algorithms中，Anne Kaldewaij 扩展了the linear algebra solution 以获得（从该书中使用的编程语言翻译和重构）：

template <typename Int_t> Int_t fib(Int_t n)
{
    Int_t a = 0, b = 1, x = 0, y 1, t0, t1;
    while (n != 0) {
        switch(n % 2) {
            case 1:
                t0 = a * x + b * y;
                t1 = b * x + a * y + b * y;
                x = t0;
                y = t1;
                --n;
                continue;
            default:
                t0 = a * a + b * b;
                t1 = 2 * a * b + b * b;
                a = t0;
                b = t1;
                n /= 2;
                continue;
        }
    }
    return x;
}

这有 O(log n) 复杂度。当然，这不是恒定的，但我认为值得加入讨论，特别是考虑到它只使用相对快速的整数运算并且没有舍入错误的可能性。

Answer 5

是的。预先计算值，并存储在数组中， 然后使用 N 进行查找。

Answer 6

选择一些最大值来处理。对于任何更大的值，引发错误。对于任何小于该值的值，只需将答案存储在该较小值处，然后继续运行“最大”值的计算，然后返回存储的值。

毕竟，O(1) 特指“恒定”，而不是“快速”。使用这种方法，所有计算都将花费相同的时间。

Answer 7

O(1) 空间和时间中的斐波那契（Python 实现）：

PHI = (1 + sqrt(5)) / 2

def fib(n: int):
  return int(PHI ** n / sqrt(5) + 0.5)