逆斐波那契算法？

Question 1

有数十种方法可以计算任意n的F（n），其中许多具有很大的运行时和内存使用率。

但是，假设我想问相反的问题：

给定F（n）的n> 2，n是多少？

（因为F（1）= F（2）= 1且没有明确的逆，所以n> 2的限制在其中）。

解决这个问题的最有效方法是什么？通过枚举斐波那契数并在达到目标数时停止，可以很容易地在线性时间内完成此操作，但是有什么方法可以比这更快吗？

编辑：当前，此处发布的最佳解决方案使用O（log n）内存在O（log n）时间运行，假设数学运算在O（1）中运行并且一个机器字可以在O（1）空间中保存任何数字。我很好奇是否有可能降低内存需求，因为您可以使用O（1）空间计算斐波那契数。

Question 2

由于OP询问的矩阵解决方案不涉及任何浮点计算，因此就在这里。O(logn)假设数值运算具有O(1)复杂性，我们可以通过这种方式实现复杂性。

让我们以A具有以下结构的2x2矩阵为例

1 1
1 0

现在考虑vector (8, 5)，存储两个连续的斐波那契数。如果将其乘以该矩阵，将得到(8*1 + 5*1, 8*1 + 5*0) = (13, 8)-下一个斐波那契数。
如果我们概括一下A^n * (1, 0) = (f(n), f(n - 1))。

实际算法需要两个步骤。

计算A^2，A^4，A^8，等等，直到我们传递给需要的号码。
n使用计算的幂进行二进制搜索A。

顺便说一句，f(n) = k1*f(n-1) + k2*f(n-2) + k3*f(n-3) + .. + kt*f(n-t)可以像这样显示表格的任何顺序。

Question 3

维基百科给出的结果为

n(F) = Floor[ Log(F Sqrt(5) + 1/2)/Log(Phi)]

其中，Phi是黄金分割率。

Question 4

如果您可以轻松地用二进制解释F（n），

您可能对常量1.7和1.1有所怀疑。这些工作是因为d * 1.44042009041 + C永远不会非常接近整数。

如果有兴趣的话，我明天可以发布一个派生词。

这是n = 2到91的表格，显示了铺地板前的公式结果：

 n  formula w/o floor     F(n) F(n) in binary

 2  2.540                    1 1
 3  3.981                    2 10
 4  4.581                    3 11
 5  5.421                    5 101
 6  6.862                    8 1000
 7  7.462                   13 1101
 8  8.302                   21 10101
 9  9.743                   34 100010
10 10.343                   55 110111
11 11.183                   89 1011001
12 12.623                  144 10010000
13 13.223                  233 11101001
14 14.064                  377 101111001
15 15.504                  610 1001100010
16 16.104                  987 1111011011
17 17.545                 1597 11000111101
18 18.385                 2584 101000011000
19 19.825                 4181 1000001010101
20 20.425                 6765 1101001101101
21 21.266                10946 10101011000010
22 22.706                17711 100010100101111
23 23.306                28657 110111111110001
24 24.147                46368 1011010100100000
25 25.587                75025 10010010100010001
26 26.187               121393 11101101000110001
27 27.028               196418 101111111101000010
28 28.468               317811 1001101100101110011
29 29.068               514229 1111101100010110101
30 30.508               832040 11001011001000101000
31 31.349              1346269 101001000101011011101
32 32.789              2178309 1000010011110100000101
33 33.389              3524578 1101011100011111100010
34 34.230              5702887 10101110000010011100111
35 35.670              9227465 100011001100110011001001
36 36.270             14930352 111000111101000110110000
37 37.111             24157817 1011100001001111001111001
38 38.551             39088169 10010101000111000000101001
39 39.151             63245986 11110001010000111010100010
40 40.591            102334155 110000110010111111011001011
41 41.432            165580141 1001110111101000110101101101
42 42.032            267914296 1111111110000000110000111000
43 43.472            433494437 11001110101101001100110100101
44 44.313            701408733 101001110011101010010111011101
45 45.753           1134903170 1000011101001010011111110000010
46 46.353           1836311903 1101101011100111110010101011111
47 47.193           2971215073 10110001000110010010010011100001
48 48.634           4807526976 100011110100011010000101001000000
49 49.234           7778742049 111001111101001100010111100100001
50 50.074          12586269025 1011101110001100110011100101100001
51 51.515          20365011074 10010111101110110010110100010000010
52 52.115          32951280099 11110101100000011001010000111100011
53 53.555          53316291173 110001101001111001100000101001100101
54 54.396          86267571272 1010000010101111100101010110001001000
55 55.836         139583862445 10000001111111110110001011011010101101
56 56.436         225851433717 11010010010101110010110110001011110101
57 57.276         365435296162 101010100010101101001000001100110100010
58 58.717         591286729879 1000100110101011011011110111110010010111
59 59.317         956722026041 1101111011000001000100111001011000111001
60 60.157        1548008755920 10110100001101100100000110001001011010000
61 61.598        2504730781961 100100011100101101100101101010100100001001
62 62.198        4052739537881 111010111110011010000110011011101111011001
63 63.038        6557470319842 1011111011011000111101100000110010011100010
64 64.478       10610209857723 10011010011001100001110010100010000010111011
65 65.078       17167680177565 11111001110100101001011110101000010110011101
66 66.519       27777890035288 110010100001110001011010001001010011001011000
67 67.359       44945570212853 1010001110000010110100101111110010101111110101
68 68.800       72723460248141 10000100010010001000000000000111101001001001101
69 69.400      117669030460994 11010110000010011110100110000101111111001000010
70 70.240      190392490709135 101011010010100100110100110001101101000010001111
71 71.681      308061521170129 1000110000010111000101001100010011100111011010001
72 72.281      498454011879264 1110001010101011101011110010100001001111101100000
73 73.121      806515533049393 10110111011000010110000111110110100110111000110001
74 74.561     1304969544928657 100101000101101110011100110001010110000110110010001
75 75.161     2111485077978050 111100000000110001001101110000001010111101111000010
76 76.602     3416454622906707 1100001000110011111101010100001100001000100101010011
77 77.442     5527939700884757 10011101000111010000111000010001101100000010100010101
78 78.042     8944394323791464 11111110001101110000100010110011001101000111001101000
79 79.483    14472334024676221 110011011010101000001011011000100111001001001101111101
80 80.323    23416728348467685 1010011001100010110001111101111000000110010000111100101
81 81.764    37889062373143906 10000110100110111110011011000111100111111011010101100010
82 82.364    61305790721611591 11011001110011010100101010110110101000101101011101000111
83 83.204    99194853094755497 101100000011010010011000101111110010000101000110010101001
84 84.644   160500643816367088 1000111010001101100111110000110100111001010110001111110000
85 85.244   259695496911122585 1110011010100111111010110110110011001001111111000010011001
86 86.085   420196140727489673 10111010100110101100010100111101000000011010101010010001001
87 87.525   679891637638612258 100101101111011101011101011110011011001101010100010100100010
88 88.125  1100087778366101931 111101000100010011000000000110000011010000101001100110101011
89 89.566  1779979416004714189 1100010110011110000011101100100011110011101111101111011001101
90 90.406  2880067194370816120 10011111111000000011011101101010100001101110100111100001111000
91 91.846  4660046610375530309 100000010101011110011111011001111000000001100100101011101000101

'

Question 5

通过计数无界词来衡量内存使用情况是很愚蠢的，但是只要是模型，就存在一个类似于Nikita Rybak的O（log n）时间，O（1）词解决方案，本质上是n通过其Zeckendorf表示来计算的，即根据斐波那契数（YO DAWG）。

定义矩阵

      1  1
A  =       ,
      1  0

满足

        F(m + 1)    F(m)
A^m  =                      .
          F(m)    F(m - 1)

代替序列A^(2^k)，我们将使用序列A^F(k)。后一个序列具有可以通过矩阵乘法向前移动的属性

A^F(k + 1) = A^F(k - 1) * A^F(k)

并通过矩阵逆和乘法向后

A^F(k - 1) = A^F(k + 1) (A^F(k))^-1,

因此，假设我们将所有内容都存储为有理数（以避免假设存在单位成本除法），我们就可以仅用八个六十二个词构建一个双向迭代器。其余的只是改编这个O（1）-空间算法来查找Zeckendorf表示。

def zeck(n):
    a, b = (0, 1)
    while b < n:
        a, b = (b, a + b)
    yield a
    n1 = a
    while n1 < n:
        a, b = (b - a, a)
        if n1 + a <= n:
            yield a
            n1 += a
            a, b = (b - a, a)

>>> list(zeck(0))
[0]
>>> list(zeck(2))
[1, 1]
>>> list(zeck(12))
[8, 3, 1]
>>> list(zeck(750))
[610, 89, 34, 13, 3, 1]

Question 6

已经证明，fib n的公式为fib(n) = ( (phi)^n - (-phi)^(-n) ) / sqrt(5)where phi = (1+sqrt(5)) / 2，黄金分割数。（请参阅此链接）。

您可以尝试找到与上述fib函数相反的数学公式，否则可以在32/64个运算中进行二进制搜索（取决于可搜索的最大值），以找到与该数字匹配的n个（通过计算fib来尝试每个n个）（n），然后根据fib（n）与给定的斐波那契数进行比较，将样本空间一分为二）。

编辑：@rcollyer的解决方案更快，因为我的解决方案在O（lg n）中，而他发现的解决方案在O（1）=恒定时间。

Question 7

因此，我正在考虑这个问题，并且我认为有可能在O（lg n）的时间内使用O（lg n）的内存使用量来做到这一点。这是基于以下事实：

F（N）=（1 /√5）（Φ ^ñ - φ ^Ñ）

其中Φ=（1 +√5）/ 2和Φ= 1-Φ。

第一观察是φ ^Ñ <对任意n 1> 1。这意味着对于任意的n> 2，我们有

F（N）=⌊Φ ^ñ /√5⌋

现在，取n并将其以二进制形式写为b _k-1 b _k-2 ... b ₁ b ₀。这意味着

n = 2 ^k-1 b _k-1 + 2 ^k-2 b _k-2 + ... + 2 ¹ b ₁ + 2 ⁰ b ₀。

这意味着

F（N）=⌊Φ ^{2 ^k-1个b _K-1 + 2 ^K-2 b _K-2 + ... + 2 ¹ b ₁ + 2 ⁰ b ₀} /√5⌋

或者更容易理解的是

F（N）=⌊Φ ^{2 ^k-1个b _K-1} Φ ^{2 ^K-2 b _K-2} ...Φ ^{2 ¹ b ₁} Φ ^{2 ⁰ b ₀} /√5⌋

这建议以下算法。首先，启动计算Φ ^{2 ^ķ}对于所有k，直到你计算出一个数，Φ ^ž这样⌊Φ ^ž /√5⌋这是大于你的电话号码F（N）。现在，从那里开始，以这种方式生成的Φ的所有幂向后迭代。如果当前数字大于指示的Φ幂，则将其除以Φ的幂并记录该数字除以该值。通过减去一次可以得到的2的最大幂，该过程实质上一次恢复n的一位。因此，一旦完成，您将找到n。

该算法的运行时间是O（LG N），因为你可以生成Φ ^{2^我}通过反复的平方，我们只生成O（LG n）的条款。内存使用量为O（lg n），因为我们存储了所有这些值。

Question 8

您可以在O（1）时间和O（1）空间中找到任何Fib（n）的n。

您可以使用定点CORDIC算法仅使用shift并添加整数数据类型来计算ln（）。

如果x = Fib（n），则n可以确定为

     n = int(2.0801 * ln(x) + 2.1408)

CORDIC运行时间取决于所需的精度水平。这两个浮点值将被编码为定点值。

该提案的唯一问题是，它返回非斐波那契数列中的数字的值，但是原始问题明确指出该函数的输入为Fib（n），这意味着只有有效的斐波那契数是用过的。

Question 9

编辑：没关系。询问者在评论中表示，求幂绝对不是固定时间。

求幂是您在恒定时间内允许的数学运算之一吗？如果是这样，我们可以通过封闭形式的公式在恒定时间内计算F（n）。然后，给定一些F，我们可以执行以下操作：

计算F（1），F（2），F（4），F（16），F（256），...直到F（2 ^ k）<= F <F（2 ^ {k + 1}）
对2 ^ k和2 ^ {k + 1}之间的i进行二进制搜索，直到F（i）<= F <F（i + 1）

如果F = F（n），则第一部分采取k = O（log（n））步。第二部分是在大小为O（2 ^ k）的范围内进行二进制搜索，因此它也需要k = O（log（n））。因此，总的来说，如果（如果很大的话）我们具有O（1）时间的幂，那么我们在O（1）空间中就有O（log（n））时间。

Question 10

斐波那契数公式的封闭形式为：

Fn = Round(φ^n / Sqrt(5))

φ是黄金比例。

如果忽略舍入因子，则它是可逆的，并且反函数为：

F(-1)n= log(n*Sqrt(5))/logφ

由于我们忽略了舍入因子，因此公式中存在可以计算的误差。但是，如果我们认为数字n是斐波那契数，且间隔[n *φ-1 / n，n *φ+ 1 / n]包含自然数，则：

如果间隔[n *φ-1 / n，n *φ+ 1 / n]包含自然数，则数字是斐波那契数，并且该数字在斐波那契数列中的索引由四舍五入log（n * Sqrt（5））/logφ

根据用于计算对数和平方根的算法，这应该在（伪）恒定时间内可行。

编辑：φ=（1 + Sqrt（5））/ 2

Question 11

这可能类似于user635541的答案。我不完全了解他的方法。

使用斐波纳契数列的矩阵表示，在其他的答案中讨论，我们得到了一个办法从去F_n和F_m来F_{n+m}并F_{n-m}在固定时间，只用加，乘，减和除法（其实不是！看到更新）。我们还有一个零（单位矩阵），所以它是一个数学组！

通常，在进行二进制搜索时，我们还希望除法运算符取平均值。或至少除以2。但是，如果我们想从F_{2n}转到F_n则需要平方根。幸运的是，事实证明，对数时间“接近”二进制搜索只需要加号和减号！

维基百科描述了这种方法，具有讽刺意味的是称为Fibonacci_search，但是文章的写法不是很清楚，所以我不知道它是否与我的方法完全相同。了解用于斐波那契搜索的斐波那契数字与我们要查找的数字无关，这一点非常重要。这有点令人困惑。为了演示该方法，这里首先是仅使用加号和减号的标准“二进制搜索”的实现：

def search0(test):
    # Standard binary search invariants:
    #   i <= lo then test(i)
    #   i >= hi then not test(i)
    # Extra invariants:
    #   hi - lo = b
    #   a, b = F_{k-1}, F_k
    a, b = 0, 1
    lo, hi = 0, 1
    while test(hi):
        a, b = b, a + b
        hi = b
    while b != 1:
        mi = lo + a
        if test(mi):
            lo = mi
            a, b = 2*a - b, b - a
        else:
            hi = mi
            a, b = b - a, a
    return lo

>>> search0(lambda n: n**2 <= 25)
5
>>> search0(lambda n: 2**n <= 256)
8

这test是一些布尔函数；a和b是连续的斐波那契数，f_k并且f_{k-1}上界hi和下界之间的差lo总是f_k。我们既需要a和b所以我们可以有效地增加和减少隐式变量k。

好了，那么我们如何使用它来解决问题呢？我发现围绕我们的斐波那契表示法创建一个包装程序很有用，该包装程序隐藏了矩阵细节。在实践中（斐波那契搜索者有这样的事情吗？），您可能想手动内联所有内容。这将为您节省矩阵中的冗余，并围绕矩阵求逆进行一些优化。

import numpy as np
class Fib:
    def __init__(self, k, M):
        """ `k` is the 'name' of the fib, e.g. k=6 for F_6=8.
             We need this to report our result in the very end.
            `M` is the matrix representation, that is
             [[F_{k+1}, F_k], [F_k, F_{k-1}]] """
        self.k = k
        self.M = M
    def __add__(self, other):
        return Fib(self.k + other.k, self.M.dot(other.M))
    def __sub__(self, other):
        return self + (-other)
    def __neg__(self):
        return Fib(-self.k, np.round(np.linalg.inv(self.M)).astype(int))
    def __eq__(self, other):
        return self.k == other.k
    def value(self):
        return self.M[0,1]

但是该代码确实有效，因此我们可以按以下方式对其进行测试。请注意，当我们的对象是整数而不是斐波那契时，搜索功能与我们的对象几乎没有什么不同。

def search(test):
    Z = Fib(0, np.array([[1,0],[0,1]])) # Our 0 element
    A = Fib(1, np.array([[1,1],[1,0]])) # Our 1 element
    a, b = Z, A
    lo, hi = Z, A
    while test(hi.value()):
        a, b = b, a + b
        hi = b
    while b != A:
        mi = lo + a
        if test(mi.value()):
            lo = mi
            a, b = a+a-b, b-a
        else:
            hi = mi
            a, b = b-a, a
    return lo.k

>>> search(lambda n: n <= 144)
12
>>> search(lambda n: n <= 0)
0

在剩下的开放问题是，是否有对幺高效的搜索算法。那是不需要负/加反的。我的猜测是：没有负号，您就需要Nikita Rybak的额外记忆。

更新资料

我只是意识到我们根本不需要分裂。的的行列式F_n矩阵只是(-1)^n，所以我们实际上可以做的一切不分割。在下面的代码中，我删除了所有矩阵代码，但保留了Fib该类，只是因为否则一切都变得非常混乱。

class Fib2:
    def __init__(self, k, fp, f):
        """ `fp` and `f` are F_{k-1} and F_{k} """
        self.k, self.fp, self.f = k, fp, f
    def __add__(self, other):
        fnp, fn, fmp, fm = self.fp, self.f, other.fp, other.f
        return Fib2(self.k + other.k, fn*fm+fnp*fmp, (fn+fnp)*fm+fn*fmp)
    def __sub__(self, other):
        return self + (-other)
    def __neg__(self):
        fp, f = self.f + self.fp, -self.f
        return Fib2(-self.k, (-1)**self.k*fp, (-1)**self.k*f)
    def __eq__(self, other):
        return self.k == other.k
    def value(self):
        return self.f

def search2(test):
    Z = Fib2(0, 1, 0)
    A = Fib2(1, 0, 1)
    ...

>>> search2(lambda n: n <= 280571172992510140037611932413038677189525)
200
>>> search2(lambda n: n <= 4224696333392304878706725602341482782579852840250681098010280137314308584370130707224123599639141511088446087538909603607640194711643596029271983312598737326253555802606991585915229492453904998722256795316982874482472992263901833716778060607011615497886719879858311468870876264597369086722884023654422295243347964480139515349562972087652656069529806499841977448720155612802665404554171717881930324025204312082516817125)
2000
>>> search2(lambda n: n <= 2531162323732361242240155003520607291766356485802485278951929841991312781760541315230153423463758831637443488219211037689033673531462742885329724071555187618026931630449193158922771331642302030331971098689235780843478258502779200293635651897483309686042860996364443514558772156043691404155819572984971754278513112487985892718229593329483578531419148805380281624260900362993556916638613939977074685016188258584312329139526393558096840812970422952418558991855772306882442574855589237165219912238201311184749075137322987656049866305366913734924425822681338966507463855180236283582409861199212323835947891143765414913345008456022009455704210891637791911265475167769704477334859109822590053774932978465651023851447920601310106288957894301592502061560528131203072778677491443420921822590709910448617329156135355464620891788459566081572824889514296350670950824208245170667601726417091127999999941149913010424532046881958285409468463211897582215075436515584016297874572183907949257286261608612401379639484713101138120404671732190451327881433201025184027541696124114463488665359385870910331476156665889459832092710304159637019707297988417848767011085425271875588008671422491434005115288334343837778792282383576736341414410248994081564830202363820504190074504566612515965134665683289356188727549463732830075811851574961558669278847363279870595320099844676879457196432535973357128305390290471349480258751812890314779723508104229525161740643984423978659638233074463100366500571977234508464710078102581304823235436518145074482824812996511614161933313389889630935320139507075992100561077534028207257574257706278201308302642634678112591091843082665721697117838726431766741158743554298864560993255547608496686850185804659790217122426535133253371422250684486113457341827911625517128815447325958547912113242367201990672230681308819195941016156001961954700241576553750737681552256845421159386858399433450045903975167084252876848848085910156941603293424067793097271128806817514906531652407763118308162377033463203514657531210413149191213595455280387631030665594589183601575340027172997222489081631144728873621805528648768511368948639522975539046995395707688938978847084621586473529546678958226255042389998718141303055036060772003887773038422366913820397748550793178167220193346017430024134496141145991896227741842515718997898627269918236920453493946658273870473264523119133765447653295022886429174942653014656521909469613184983671431465934965489425515981067546087342348350724207583544436107294087637975025147846254526938442435644928231027868701394819091132912397475713787593612758364812687556725146456646878912169274219209708166678668152184941578590201953144030519381922273252666652671717526318606676754556170379350956342095455612780202199922615392785572481747913435560866995432578680971243966868110016581395696310922519803685837460795358384618017215468122880442252343684547233668502313239328352671318130604247460452134121833305284398726438573787798499612760939462427922917659263046333084007208056631996856315539698234022953452211505675629153637867252695056925345220084020071611220575700841268302638995272842160994219632684575364180160991884885091858259996299627148614456696661412745040519981575543804847463997422326563897043803732970397488471644906183310144691243649149542394691524972023935190633672827306116525712882959108434211652465621144702015336657459532134026915214509960877430595844287585350290234547564574848753110281101545931547225811763441710217452979668178025286460158324658852904105792472468108996135476637212057508192176910900422826969523438985332067597093454021924077101784215936539638808624420121459718286059401823614213214326004270471752802725625810953787713898846144256909835116371235019527013180204030167601567064268573820697948868982630904164685161783088076506964317303709708574052747204405282785965604677674192569851918643651835755242670293612851920696732320545562286110332140065912751551110134916256237884844001366366654055079721985816714803952429301558096968202261698837096090377863017797020488044826628817462866854321356787305635653577619877987998113667928954840972022833505708587561902023411398915823487627297968947621416912816367516125096563705174220460639857683971213093125)
20000

这一切都像一个魅力。我唯一担心的是，这样的位复杂性支配了计算，我们也可能只是进行了顺序搜索。或实际上，仅查看数字就可以告诉您几乎所要查看的数字。那可不是那么有趣。