Вычислить число представлений числа как сумму чисел Фибоначчи

меня заинтриговали два аспекта Никлас Б.ответ: скорость вычисления (даже для огромных чисел) и тенденция результатов иметь малые простые коэффициенты. Они намекают, что решение может быть вычислено как произведение малых членов, и это действительно так.

чтобы объяснить, что происходит, мне нужны некоторые обозначения и терминология. Для любого неотрицательного целого n, я определю (уникальный)жадина представление of n быть суммой чисел Фибоначчи, полученных многократно принимая наибольшее число Фибоначчи, не превышающее n. Так, например, жадное представление 10 is 8 + 2. Легко заметить, что мы никогда не используем Fib(1) в таком жадном представлении.

я также хочу компактный способ написать эти представления, и для этого я собираюсь использовать bitstrings. Очень похоже на binary, за исключением того, что значения места следуют за Фибоначчи последовательность вместо последовательности степеней 2, и я напишу с наименее значимой цифрой первым. Так, например,00100001 и 1в должности 2 и позицию 7, таким образом, представляет Fib(2) + Fib(7) = 1 + 13 = 14. (Да, я начинаю считать на 0, и следуя обычному соглашению, что Fib(0) = 0.)

способ грубой силы найти все представления-начать с жадного представления, а затем исследовать все возможности для перезаписи подшаблона формы 001 в шаблон вида 110; т. е., заменив Fib(k+2) С Fib(k) + Fib(k+1) для некоторых k.

поэтому мы всегда можем написать жадное представление n как битовая строка, и эта битовая строка будет последовательностью 0s и 1s, без двух смежных 1s. Теперь ключевое наблюдение заключается в том, что мы можем разбить эту битовую строку на части и вычислить количество перезаписей для каждой отдельной части, умножая, чтобы получить общее количество представлений. Это работает, потому что некоторые подзаголовки в bitstring предотвращают взаимодействие между правилами перезаписи для части строки слева от шаблона и тех, кто справа.

для примера, давайте посмотрим на n = 78. Его жадное представление -00010000101, и подход грубой силы быстро идентифицирует полный набор представлений. Их десять:

00010000101
01100000101
00010011001
01100011001
00011101001
01101101001
0001001111
0110001111
0001110111
0110110111

мы можем отделить первую часть рисунка,0001 из второго, 0000101. Каждая из приведенных выше комбинаций происходит от переписывания 0001, отдельно рерайтинг 0000101, и склеивание двух перезаписей вместе. Есть 2 перезаписи (включая оригинал) для левой части шаблона и 5 для правой, поэтому мы получаем 10 представлений в целом.

что делает эту работу, так это то, что любая перепись левой половины,0001, заканчивается либо 01 или 10, в то время как любая перепись правой половины начинается с 00 или 11. Так нет ни 001 или 110 это перекрывает границу. Мы получим это разделение, когда у нас будет два 1s разделены даже количество нулей.

и это объясняет небольшие простые факторы, замеченные в ответе Никласа: в случайно выбранном числе будет много последовательностей 0s четной длины, и каждый из них представляет собой точку, где мы можем разделить вычисление.

объяснения становятся немного запутанный, так что вот код Python. Я проверил, что результаты согласуются с результатами Никласа для всех n до 10**6, и для выбора случайно выбранного большого n. Он должен иметь такую же алгоритмическую сложность.

def combinations(n):
    # Find Fibonacci numbers not exceeding n, along with their indices.
    # We don't need Fib(0) or Fib(1), so start at Fib(2).
    fibs = []
    a, b, index = 1, 2, 2
    while a <= n:
        fibs.append((index, a))
        a, b, index = b, a + b, index + 1

    # Compute greedy representation of n as a sum of Fibonacci numbers;
    # accumulate the indices of those numbers in indices.
    indices = []
    for index, fib in reversed(fibs):
        if n >= fib:
            n -= fib
            indices.append(index)
    indices = indices[::-1]

    # Compute the 'signature' of the number: the lengths of the pieces
    # of the form 00...01.
    signature = [i2 - i1 for i1, i2 in zip([-1] + indices[:-1], indices)]

    # Iterate to simultaneously compute total number of rewrites,
    # and the total number with the top bit set.
    total, top_set = 1, 1
    for l in signature:
        total, top_set = ((l + 2) // 2 * total - (l + 1) % 2 * top_set, total)

    # And return the grand total.
    return total

EDIT: код существенно упрощен.

EDIT 2: я просто наткнулся на этот ответ снова и подозревал, что есть более простой способ. Вот еще одно упрощение кода, показывающее ясно это O(log n) требуются операции.

def combinations(n):
    """Number of ways to write n as a sum of positive
    Fibonacci numbers with distinct indices.
    """
    # Find Fibonacci numbers not exceeding n.
    fibs = []
    fib, next_fib = 0, 1
    while fib <= n:
        fibs.append(fib)
        fib, next_fib = next_fib, fib + next_fib

    # Compute greedy representation, most significant bit first.
    greedy = []
    for fib in reversed(fibs):
        greedy.append(fib <= n)
        if greedy[-1]:
            n -= fib

    # Iterate to compute number of rewrites.
    x, y, z = 1, 0, 0
    for bit in reversed(greedy):
        x, y, z = (0, y + z, x) if bit else (x + z, z, y)
    return y + z

вы можете найти лексикографически наибольшее представление 0/1 в базе Фибоначчи, взяв наибольшее число Фибоначчи меньше или равно вашему числу, вычесть это, а затем взять следующее по величине число Фибоначчи меньше или равно остатку и т. д. Тогда возникает вопрос, как найти все остальные 0/1 представления в базе Фибоначчи из лексикографически наибольшего. Я считаю, что вы можете использовать рекуррентное отношение Фибоначчи для этого. Например, если ваше представление 1100... затем вы можете заменить 2-е по величине число Fib в представлении суммой следующих двух, давая 1011.....Если вы рекурсивно обрабатываете строку таким образом слева направо несколько раз, либо выбирая замену, либо нет, когда вы можете, и используя динамическое программирование, чтобы помнить, какие представления вы уже исследовали, я считаю, что вы получите все представления, и в O(M log n) время, где m-общее количество представлений Фибоначчи для вашего номер n. Я сообщу, если найду убедительные доказательства. Тем временем вы можете проверить гипотезу на число до миллиона или около того. Если он проверяет, на все эти случаи, то это почти наверняка так.

одна из наивных возможностей в python (работает до 10^6 в разумное время)

def nfibhelper(fibm1,fibm2,n):
    fib = fibm1 + fibm2
    if fib > n:
        return 0
    r=0
    if n == fib :
        r+=1
    return r + nfibhelper(fibm2,fib,n-fib) + nfibhelper(fibm2,fib,n)


def F(n):
    return nfibhelper(1,0,n) ##1 will be used twice as fib