Как найти свое число фибоначчи

Была ли эта статья полезной?

Задача: посчитать N-е число последовательности, в которой каждый элемент равен сумме двух предыдущих. Такая последовательность называется последовательностью Фибоначчи: 1, 1, 2, 3, 5, 8…

Очень часто на разнообразных олимпиадах попадаются задачи вроде этой, которые, как думается на первый взгляд, можно решить с помощью простого перебора. Но если мы подсчитаем количество возможных вариантов, то сразу убедимся в неэффективности такого подхода: например, простая рекурсивная функция, приведенная ниже, будет потреблять существенные ресурсы уже на 30-ом числе Фибоначчи, тогда как на олимпиадах время решения часто ограничено 1-5 секундами.

int fibo(int n)
{
    if (n == 1 || n == 2) {
        return 1;
    } else {
        return fibo(n - 1) + fibo(n - 2);
    }
}

Давайте подумаем, почему так происходит. Например, для вычисления fibo(30) мы сначала вычисляем fibo(29) и fibo(28). Но при этом наша программа «забывает», что fibo(28) мы уже вычисляли при поиске fibo(29).

Основная ошибка такого подхода «в лоб» в том, что одинаковые значения аргументов функции исчисляются многократно — а ведь это достаточно ресурсоемкие операции. Избавиться от повторяющихся вычислений нам поможет метод динамического программирования — это прием, при использовании которого задача разбивается на общие и повторяющиеся подзадачи, каждая из которых решается только 1 раз — это значительно повышает эффективность программы. Этот метод подробно описан в нашей статье, там же есть и примеры решения других задач.

Самый просто вариант улучшения нашей функции — запоминать, какие значения мы уже вычисляли. Для этого нужно ввести дополнительный массив, который будет служить как бы «кэшем» для наших вычислений: перед вычислением нового значения мы будем проверять, не вычисляли ли его раньше. Если вычисляли, то будем брать из массива готовое значение, а если не вычисляли — придётся считать его на основе предыдущих и запоминать на будущее:

int cache[100];

int fibo(int n)
{
    if (cache[n] == 0) {
        if (n == 1 || n == 2) {
            cache[n] = 1;
        } else {
            cache[n] = fibo(n - 1) + fibo(n - 2);
        }
    }

    return cache[n];
}

Так как в данной задаче для вычисления N-ого значения нам гарантированно понадобится (N-1)-е, то не составит труда переписать формулу в итерационный вид — просто будем заполнять наш массив подряд до тех пор, пока не дойдём до нужной ячейки:

cache[0] = 1;
cache[1] = 1;

for (int i = 2; i <= n; i++) {
    cache[i] = cache[i - 1] + cache[i - 2];
}

cout << cache[n-1];

Теперь мы можем заметить, что когда мы вычисляем значение F(N), то значение F(N-3) нам уже гарантированно никогда не понадобится. То есть нам достаточно хранить в памяти лишь два значения — F(N-1) и F(N-2). Причём, как только мы вычислили F(N), хранение F(N-2) теряет всякий смысл. Попробуем записать эти размышления в виде кода:

//Два предыдущих значения:
int cache1 = 1;
int cache2 = 1;
//Новое значение
int cache3;

for (int i = 2; i <= n; i++) {
    cache3 = cache1 + cache2; //Вычисляем новое значение

    //Абстрактный cache4 будет равен cache3+cache2
    //Значит cache1 нам уже не нужен?..

    //Отлично, значит cache1 -- то значение, которое потеряет актуальность на следующей итерации.
    //cache5 = cache4 - cache3 => через итерацию потеряет актуальность cache2, т.е. он и должен стать cache1

    //Иными словами, cache1 -- f(n-2), cache2 -- f(n-1), cache3 -- f(n).
    //Пусть N=n+1 (номер, который мы вычисляем на следующей итерации). Тогда n-2=N-3, n-1=N-2, n=N-1.
    //В соответствии с новыми реалиями мы и переписываем значения наших переменных:

    cache1 = cache2;
    cache2 = cache3;
}

cout << cache3;

Бывалому программисту понятно, что код выше, в общем-то ерунда, так как cache3 никогда не используется (он сразу записывается в cache2), и всю итерацию можно переписать, используя всего одно выражение:

cache[0] = 1;
cache[1] = 1;
 
for (int i = 2; i <= n; i++) {
    cache[i%2] = cache[0] + cache[1];
    //При i=2 устареет 0-й элемент
    //При i=3 в 0 будет свежий элемент (обновили его на предыдущей итерации), а в 1 -- ещё старый
    //При i=4 последним элементом мы обновляли cache[1], значит ненужное старьё сейчас в cache[0]
    //Интуитивно понятно, что так будет продолжаться и дальше
}
 
cout << cache[n%2];

Для тех, кто не может понять, как работает магия с остатком от деления, или просто хочет увидеть более неочевидную формулу, существует ещё одно решение:

int x = 1;
int y = 1;

for (int i = 2; i < n; i++) {
   y = x + y;
   x = y - x;
}

cout << "Число Фибоначчи: " << y;

Попробуйте проследить за выполнением этой программы: вы убедитесь в правильности алгоритма.

P.S. Вообще, существует единая формула для вычисления любого числа Фибоначчи, которая не требует никаких итераций или рекурсии:

const double SQRT5 = sqrt(5);
const double PHI = (SQRT5 + 1) / 2;

int fibo(int n){
    return int(pow(PHI, n) / SQRT5 + 0.5);
}

Но, как можете догадаться, подвох в том, что цена вычисления степеней нецелых чисел довольно велика, как и их погрешность.

Таинственное число Фибоначчи, равное 1,618, будоражит умы ученых уже на протяжении нескольких тысячелетий. Кто-то считает это число строителем мироздания, кто-то называет его числом Бога, а кто-то, не мудрствуя лукаво, просто применяет его на практике и получает невероятные архитектурные, художественные и математические творения. Число Фибоначчи было обнаружено даже в пропорциях знаменитого «Витрувианского человека» Леонардо Да Винчи, который утверждал, что знаменитое число, пришедшее из математики, руководит всей Вселенной.

Кто такой Фибоначчи?

Леонардо Пизанский считается самым первым крупным математиком в истории средневековой Европы. Несмотря на это, свое знаменитое прозвище «Фибоначчи» ученый получил далеко не из-за своих экстраординарных математических способностей, но из-за своего везения, так как «боначчи» по-итальянски означает «удачливый». Перед тем как стать одним из самых известных математиков раннего Средневековья, Леонардо Пизанский изучал точные науки у самых продвинутых учителей своего времени, которыми считались арабы. Именно благодаря этой деятельности Фибоначчи, в Европе появились десятичная система счисления и арабские цифры, которыми мы пользуемся до сих пор.

В одном из своих самых известных трудов под названием «Liber abaci», Леонардо Пизанский приводит уникальную закономерность чисел, которые при постановке в ряд образуют линию цифр, каждая из которых является суммой двух предыдущих чисел.

Последовательность Фибоначчи

Иными словами, последовательность Фибоначчи выглядит так:
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987 и так далее.

Каждое число из ряда Фибоначчи, разделенное на предыдущее, имеет значение, стремящееся к уникальному показателю, которое составляет 1,618. Первые числа ряда Фибоначчи не дают настолько точное значение, однако по мере нарастания, соотношение постепенно выравнивается и становится все более точным.

Читайте также: Найдено самое длинное простое число Мерсенна, состоящее из 22 миллионов цифр

Где используется число Фибоначчи

Из-за своего повсеместного применения в природе, золотое сечение (именно так число Фибоначчи иногда называют в искусстве и математике) считается одним из самых гармонизирующих законов мироздания, который упорядочивает структуру окружающего нас мира и направляет жизнь на развитие. Так, правило золотого сечения применяется природой для образования траекторий движения вихревых потоков в ураганах, при образовании эллиптических галактик, к которым относится и наш Млечный Путь, при «строительстве» раковины улитки или ушной раковины человека, направляет движение косяка рыб и показывает траекторию движения испуганной стаи оленей, врассыпную убегающую от хищника.

Эстетичность такой гармонизации мироздания воспринимается человеком, который всегда стремился улучшить окружающую его действительность, в качестве стабилизирующего природу закона. Находя золотое сечение в лице того или иного человека, мы инстинктивно воспринимаем собеседника в качестве гармоничной личности, чье развитие происходит без сбоев и нарушений. Этим можно объяснить то, почему иногда нам по непонятным причинам больше нравится одно лицо, чем другое. Оказывается, о наших возможных симпатиях позаботилась природа!

Как вы считаете, является ли повсеместное применение числа Фибоначчи в природе совпадением или свидетельством наличия некоего вселенского разума? Давайте попробуем обсудить этот вопрос в нашем Telegram-чате.

Наиболее распространенное определение золотого сечения гласит, что меньшая часть так относится к большей, как большая часть относится ко всему целому. Уникальное правило встречается во всех областях природы, науки и искусства, позволив некоторым именитым исследователям Средних Веков сделать предположение, что три основные части золотого сечения олицетворяют собой христианских Отца, Сына и Святого Духа.

Что такое золотое сечение

С точки зрения математики, золотое сечение представляет собой некую идеальную пропорцию, к которой каким-то образом стремится все живое и неживое в природе.

Используя основные принципы ряда Фибоначчи, растут семечки в центре подсолнуха, движется спираль ДНК, был построен Парфенон и написана самая знаменитая картина в мире — «Джоконда» Леонардо Да Винчи.

Есть ли в природе гармония? Несомненно, есть. А ее доказательством служит число Фибоначчи, происхождение которого нам еще только предстоит отыскать.

Что такое спираль Фибоначчи

Золотая спираль или спираль Фибоначчи — это логарифмическая спираль. Ее коэффициент роста равен φ4, где φ — золотое сечение. Он показывает, во сколько раз изменился полярный радиус спирали при повороте на угол 360 градусов.

А вот еще один вопрос, имеющий отношение к Фибоначчи: почему от красивых вещей люди становятся счастливее

Эта спираль называется так из-за связи с последовательностью вложенных друг в друга прямоугольников с отношением сторон, равным φ, которые принято называть золотыми. Популярность золотая спираль приобрела из-за того, что известная с начала XVI века и применяющаяся в искусстве спираль, построенная по методу Дюрера, отлично подошла для решения своих задач.

Вычисление n-го числа Фибоначчи — популярная задача, которая на практике почти не встречается, но часто прменяется в обучающих целях, а также на собеседованиях. Задача очень проста, но решить ее можно несколькими алгоритмами, причем время выполнения таких алгоритмов может сильно различаться между собой.

Понятие числа Фибоначчи:

Итак, простой пример последовательности Фибоначчи (каждое последующее число равно сумме двух предыдущих):

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ... .

Рекуррентное соотношение таково:

F(0) = 0,
F(1) = 1,
F(i) = F(i−1) + F(i−2), где i >= 2.

Первый способ

Самый простой алгоритм для вычисления такого числа, который дается во всех книжках, это алгоритм основанный на рекурсии:

1
2
3
4
5
6
7
8

    private static int fibonacci1(int n) {
        if (n == 0)
            return 0;
        if (n == 1)
            return 1;

        return fibonacci1(n - 1) + fibonacci1(n - 2);
    }

Это простой, но и самый неэффективный алгоритм, так как время алгоритма растет экспоненциально — O(2^n).
Рекурсивное дерево вызовов выглядит следующим образом:

Второй способ

Второй способ основан на принципе с сохранением каждого предыдущего числа последовательности в массиве. Такой алгоритм требует уже линейное время — O(n) на выполнение и дополнительное количество памяти для хранения всего массива чисел — O(n):

1
2
3
4
5
6
7
8
9
10
11

    private static int fibonacci2(int n) {
        int[] a = new int[n+1];
        a[0] = 0;
        a[1] = 1;

        for (int i = 2; i <= n; i++) {
            a[i] = a[i-1] + a[i-2];
        }

        return a[n];
    }

Третий способ

Третий способ похож на первый, за исключением того, что, мы будем хранить не весь массив вычисленных чиел, а только предыдущие два. Таким образом, колчиство дополнительной памяти сократится до O(1):

1
2
3
4
5
6
7
8
9
10
11
12
13

    private static int fibonacci3(int n) {
        int fPrev = 0;
        int fCurrent = 1;
        int fNext = 0;

        for (int i = 2; i <= n; i++) {
            fNext = fPrev + fCurrent;
            fPrev = fCurrent;
            fCurrent = fNext;
        }

        return fNext;
    }