1632
правки
Изменения
м
Для рангов 0 и 1 соответствующие деревья содержат 1 вершину, Докажем лемму по индукции: при <tex> F_0 \ge 1, F_1 \ge 1 n = 2</tex>.
Рассмотрим дерево ранга <tex> k F_2 = 1 + \sum\limits_{i=0}^0 F_i = 1 + 0 = 1</tex>, что действительно верно.
Оно в худшем случае (удален ребенок ранка По индукции предполагаем, что <tex> k F_{n- 1 </tex>) содержит <tex> } = 1 + F_1 + F_2 + ... + F_\sum\limits_{i=0}^{kn-23} F_i </tex> вершин.Тогда
Эта сумма, в свою очередь, равна <tex> F_k F_n = F_{n-1} + F_{n-2} = 1 + \sum\limits_{i=0}^{n-3} F_i + F_{n-2} = 1 + \sum\limits_{i=0}^{n-2} F_i</tex>
Поскольку {{Лемма|id=Лемма2|statement= Фибоначчиево дерево порядка <tex> F_k = \Omega(\varphi^k) n</tex>, где содержит не менее <tex> \varphi F_n</tex> вершин.|proof= \frac {1 + \sqrt 5}2 Докажем это утверждение по индукции.Пусть <tex>s_n</tex>, то высота {{---}} минимальный размер фибоначчиева дерева есть порядка <tex> O(logN) n</tex>.
Каждая вершина При <tex> x n = 0</tex> знает своего родителя (<tex> p[x] </tex>) и какого-нибудь своего ребенка(<tex> child[x] </tex>).
Дети любой вершины связаны в циклический двусвязный список. Такие списки удобны по двум причинам: из такого списка можно удалить вершину, и два таких списка можно связать в один за <tex> O(s_0 = 1) > F_0</tex>.
Также в любой вершине хранятся поля При <tex> degree[x], \, mark[x] n = 1</tex>: степень вершины(число ее детей) и пометка о том, потеряла ли вершина <tex> x </tex> ребенка после того, как она в последний раз сделалась чьим-либо потомком.
Корни фибоначчиевых деревьев, составляющих фибоначчиеву кучу, также объединены в двусвязный циклический список(корневой список, root list). В отличие от биномиальных куч, в корневом списке может находиться несколько деревьев с одной и той же степенью корня. При <tex>n = 1</tex>
Доступ к куче осуществляется с помощью указателя <tex> min[H] F_1 =</tex> <tex dpi="160">\frac {\varphi^1 - (-\varphi)^{-1}} {\sqrt 5} = \frac {1} {\sqrt 5}(\frac {1 + \sqrt 5} {2} - \frac {1 - \sqrt 5} {2}) = \frac {2\sqrt 5} {2\sqrt 5} = 1</tex>, указывающего на минимальную вершину в кучечто также верно.
Доказательство времени работы для всех операций с фибоначчиевыми кучами проводим с помощью методов амортизационного анализаПо индукции предполагаем, что <tex>F_{n-1} =</tex> <tex dpi="160">\frac {\varphi^{n-1} - (-\varphi)^{1-n}} {\sqrt 5}</tex> и <tex>F_{n-2} =</tex> <tex dpi="160">\frac {\varphi^{n-2} - (-\varphi)^{2-n}} {\sqrt 5}</tex>.Тогда
Введем потенциал фибоначчиевой кучи Подставив вместо <tex> \Phi(H) = t[H] + 2m[H] varphi</tex>его значение, нетрудно убедится, как количество элементов в корневом списке (что <tex> t[H] </tex>) прибавить удвоенное количество вершин с <tex> mark[x] \varphi^{-1} + \varphi^{-2} =-\varphi + \varphi^{2} = true \, (m[H]) 1</tex>. На языке метода предоплаты это выглядит следующим образом: возле каждого корня лежит одна монета, а возле каждой вершины, у которой удалили ребенка, лежит две монеты.
Создается новый пустой корневой список, в <tex> min[H] </tex> устанавливается значение <tex> null </tex>. Реальное время работы - <tex> O(1) </tex>.
Слияние двух фибоначчиевых куч происходит просто: объединяем списки этих куч в один, релаксируем минимум. Реальное время работы - <tex> O(1) </tex>. Амортизированное время работы - также <tex> O(1) </tex>, поскольку, при объединении двух куч в одну, потенциалы обеих куч суммируются, итоговая сумма потенциалов не изменяется, <tex> n \geqslant \Phi_varphi^{n + 1k} - \Phi_n = 0 </tex>.
== Insert ==Логарифмируя по основанию <tex>\varphi</tex>, получаем <tex>\log_{\varphi}n \geqslant k</tex> Таким образом, максимальная степень <tex>degree</tex> произвольной вершины равна <tex>O(\log n)</tex>.}}
Вставка элемента в фибоначчиеву кучу также тривиальна: создается новая куча из одного элемента Итоговая асимптотика операции <tex>\mathrm {extraxtMin}</tex>, учитывая и сливается с текущей. Амортизированная стоимость операциивспомогательную функцию <tex> \mathrm {consolidate} </tex>, время работы которой доказывается ниже, равно: <tex> O(1 )+O(создание кучиdegree) + 2 O(degree)=O(слияние куч + релаксация минимумаdegree) + 1</tex>. По доказанной выше [[#Лемма4|лемме]] <tex>O(изменение потенциалаdegree) = 4O(\log(n))</tex>.
== Extract_min ==Учетная стоимость <tex> \mathrm {consolidate} </tex> равна <tex> O(degree) </tex>. Докажем это:
Первая рассматриваемая операцияИзначально в корневом списке было не более <tex> degree + trees - 1 </tex> вершин, в поскольку он состоит из исходного списка корней с <tex>trees</tex> узлами, минус извлеченный узел и плюс дочерние узлы, количество которых не превышает <tex> degree </tex>. В ходе которой меняется структура кучи. Здесь используется вспомогательная процедура Consolidateоперации <tex> \mathrm {consolidate} </tex> мы сделали <tex> O("уплотнение" кучиdegree + trees)</tex> слияний деревьев. Возьмем указатель на Потенциал перед извлечением минимума равен <tex> min[H] trees + 2 * marked </tex>, удалим эту вершину. Ее поддеревья (их а после не более, чем превышает <tex> D[H] degree + 1 + 2 * marked</tex>) все положим , поскольку в корневой список. Теперь вызываем процедуру корневом списке остается не более <tex> Consolidate degree + 1 </tex>узлов, а количество помеченных узлов не изменяется.Таким образом, амортизированная стоимость не превосходит
Данная процедура принимает кучуПоскольку мы договорились, и делает из нее кучучто можем масштабировать единицу потенциала таким образом, в корневом списке которой чтобы покрывать константное количество работы, то итоговая амортизационная оценка {{---}} <tex> O(D[Hdegree) </tex>==== Уменьшение значения элемента ====Докажем, что амортизированное время работы операции <tex> \mathrm {decreaseKey}</tex> есть <tex> O(1) </tex> вершин. Поскольку в процедуре нет циклов, ее время работы определяется лишь количеством рекурсивных вызовов каскадного вырезания.
Для этого возьмем массив списков указателей на корни деревьев Пусть мы вызвали процедуру каскадного вырезания подверглось <tex> k </tex> A[0раз..D[H]] Так как реальное время работы каждой итерации <tex> \mathrm {cascadingCut} </tex> составляет <tex> O(1) </tex>, где то реальное время работы операции <tex> D[H] \mathrm {decreaseKey} </tex> {{- максимальная степень вершины в текущем корневом списке. Далее мы увидим, что --}} <tex> D[H] = O(logNk) </tex>.
Затем происходит процессРассмотрим, аналогичный слиянию биномиальных куч: добавляем поочередно каждый корень, смотря на его степенькак изменится потенциал в результате выполнения данной операции. Пусть она равна <tex> d H </tex> {{---}} фибоначчиева куча до вызова <tex> \mathrm {decreaseKey} </tex>. Тогда после <tex> k </tex> итераций операции <tex> \mathrm {cascadingCut} </tex> Если вершин с пометкой <tex> x.mark = true </tex> стало как минимум на <tex> k - 2 </tex> меньше, потому что каждый вызов каскадного вырезания, за исключением последнего, уменьшает количество помеченных вершин на одну, и в соответствующей ячейке A еще нету вершины, записываем текущую результате последнего вызова одну вершину тудамы можем пометить. Иначе подвешиваем одно В корневом списке прибавилось <tex> k </tex> новых деревьев (<tex> k - 1 </tex> дерево к другому, за счет каскадного вырезания и пытаемся также добавить дерево, степень корня которого уже равна еще одно из-за самого первого вызова операции <tex> d + 1 \mathrm {cut} </tex>. Продолжаем, пока не найдем свободную ячейку).
Учетная В итоге, изменение потенциала составляет: <tex> \Phi_i - \Phi_{i - 1} = ((trees + k) + 2 * (marked + k - 2)) - (trees + 2 * marked) = 4 - k </tex>. Следовательно, амортизированная стоимость не превышает <tex> O(k) + 4 - k </tex>. Но поскольку мы можем соответствующим образом масштабировать единицы потенциала, то амортизированная стоимость операции <tex> Consolidate \mathrm {decreaseKey} </tex> равна <tex> O(D[H]1) </tex>. Докажем это==== Удаление элемента ====Амортизированное время работы:<tex> O(1) + O(degree) = O(degree) </tex>.
Пусть изначально в корневом списке было Поскольку ранее мы показали, что <tex> r degree = O(\log n ) </tex> вершин, то соответствующие оценки доказаны.==== Итоговая таблица ===={| style="background-color:#CCC;margin:0. Тогда в ходе операции 5px"!style="background-color:#EEE"| Операция!style="background-color:#EEE"| Амортизированная сложность|-align="center"|style="background-color:#FFF;padding:2px 10px"| <tex> Consolidate \mathrm {makeHeap}</tex> мы сделали |style="background-color:#FFF;padding:2px 10px"| <tex> O(r1) </tex> слияний деревьев. Но эти |-align="center"|style="background-color:#FFF;padding:2px 10px"| <tex>\mathrm {insert}</tex>|style="background-color:#FFF;padding:2px 10px"| <tex> O(r1) </tex> слияний скомпенсируются уменьшением потенциала |-align="center"|style="background-color:#FFF;padding:2px 10px"| <tex> t_i + \Phi_i mathrm {getMin}</tex>|style="background- color:#FFF;padding:2px 10px"| <tex>O(1)</tex> |-align="center"|style="background-color:#FFF;padding:2px 10px"| <tex>\Phi_mathrm {i - 1merge} </tex>|style= r + ("background-color:#FFF;padding:2px 10px"| <tex>O(D[H]1) </tex> |- r) align="center"|style="background-color:#FFF;padding:2px 10px"| <tex>\mathrm {extractMin}</tex>|style= "background-color:#FFF;padding:2px 10px"| <tex>O(D[H]\log n ) </tex>. Остальных действий будет также |-align="center"|style="background-color:#FFF;padding:2px 10px"| <tex>\mathrm {decreaseKey}</tex>|style="background-color:#FFF;padding:2px 10px"| <tex> O(D[H]1) </tex>. Таким образом, учетная стоимость |-align="center"|style="background-color:#FFF;padding:2px 10px"| <tex>\mathrm {delete}</tex> Consolidate|style="background-color:#FFF;padding: \, 2px 10px"| <tex>O(D[H]\log n ) </tex>.|}
Основная идея== См. также ==* [[Приоритетные очереди]]* [[Двоичная куча]]* [[Биномиальная куча]]* [[Левосторонняя куча]]* [[Тонкая куча]]* [[Толстая куча на избыточном счетчике]]* [[Куча Бродала-Окасаки]]== Примечания ==<references/>== Источники информации ==* Томас Кормен, Чарльз Лейзерсон, Рональд Ривест, Клиффорд Штайн — Алгоритмы: построение и анализ. — М.: хотимИздательский дом «Вильямс», чтобы учетная стоимость данной операции была <tex> O(1) <2005. — С. 1296. — ISBN 5-8459-0857-4* [[wikipedia:en:Числа Фибоначчи|Числа Фибоначчи {{---}} Википедия]]* [[wikipedia:en:Fibonacci heap|Фибоначчиева куча {{---}} Википедия]]* [https://www.cs.usfca.edu/~galles/visualization/FibonacciHeap.html Fibonacci heap visualization]* [http://www.intuit.ru/department/algorithms/dscm/7/2.html Фибоначчиевы кучи — INTUIT.ru]* [http://www.cs.duke.edu/courses/fall05/cps230/L-11.pdf Fibonacci Heaps {{---}} Duke University]* [https://www.cs.princeton.edu/~wayne/teaching/tex>fibonacci-heap. pdf Fibonacci Heaps {{---}} Princeton University]
- Хотим, чтобы вершина не всплывала до корня[[Категория: Алгоритмы и структуры данных]][[Категория: Приоритетные очереди]]
rollbackEdits.php mass rollback
'''Фибоначчиевы кучиФибоначчиева куча''' (англ. ''Fibonacci heap'' ) {{- модификация биномиальных куч--}} структура данных, в которых всех операцииотвечающая интерфейсу [[Приоритетные очереди#Операции | приоритетная очередь]]. Эта структура данных имеет меньшую [[Амортизационный анализ#Основные определения | амортизированную сложность]], где не требуется удаление элементов, имеют амортизированную стоимость чем такие приоритетные очереди как [[Биномиальная куча | биномиальная куча]] и [[Двоичная куча | двоичная куча]]. Изначально эта структура данных была разработана Майклом Фридманом<texref> O(1) [[wikipedia:en:Michael_Fredman | Майкл Фридман {{---}} Википедия]]</texref>. Также являются сливаемыми кучами("mergeable heap"). Теоретически полезны тогда, когда операций и Робертом Тарьяном<texref> Extract\_min [[wikipedia:en:Robert_Tarjan | Роберт Тарьян {{---}} Википедия]]</texref> и при работе по улучшению асимптотической сложности [[Алгоритм Дейкстры | алгоритма Дейкстры]]. Свое название Фибоначчиева куча получила из-за использования некоторых свойств чисел Фибоначчи<texref> Delete [[wikipedia:en:Fibonacci_number | Числа Фибоначчи {{---}} Википедия]]</texref> значительно меньшев [[Амортизационный анализ#Метод потенциалов | потенциальном анализе]] этой реализации.== Структура ==Фибоначчиева куча {{---}} набор из [[Дерево, чем остальныхэквивалентные определения | подвешенных деревьев]] удовлетворяющих свойству: каждый предок не больше своих детей(если дерево на минимум). К сожалениюЭто означает, скрытые константы великичто минимум всей кучи это один из корней этих деревьев. Одно из главных преимуществ Фибоначчиевой кучи {{---}} гибкость её структуры из-за того, так что на практике использование фибоначчиевых куч оказывается нецелесообразным: обычные деревья не наложены никакие ограничения по форме. Например, Фибоначчиева куча может состоять хоть из деревьев в каждом из которых по одному элементу. Такая гибкость позволяет выполнять некоторые операции лениво, оставляя работу более поздним операциям. Далее будут даны некоторые определения, которые понадобятся в дальнейшем.{{Определение|definition='''Степень вершины''' (англ. ''degree'') {{---}} количество детей данной вершины. Далее будем обозначать как <tex>degree(x)</tex>, где <tex> k x</tex> - ичные кучи на практике эффективнееэто вершина. = Фибоначчиевы деревья =}}
{{Определение
|definition=
'''Фибоначчиево деревоСтепень кучи''' (англ. ''degree'') {{--- биномиальное дерево}} наибольшая степень вершины этой кучи. Далее будем обозначать как <tex>degree(H)</tex>, где у каждой вершины удалено не более одного ребенка<tex>H</tex> это куча.
}}
== Реализация ==
[[File:Fibonacci-heap.png|thumb|340px|Пример фибоначчиевой кучи]]
Для возможности быстрого удаления элемента из произвольного места и объединением с другим списком будем хранить их в [[Список#Циклический список | циклическом двусвязном списке]]. Также будем хранить и все уровни поддерева. Исходя из этого структура каждого узла будет выглядеть вот так.
<code style="display:inline-block">
'''struct''' Node
'''int''' key <span style="color:#008000"> // ключ</span>
'''Node''' parent <span style="color:#008000"> // указатель на родительский узел</span>
'''Node''' child <span style="color:#008000"> // указатель на один из дочерних узлов</span>
'''Node''' left <span style="color:#008000"> // указатель на левый узел того же предка</span>
'''Node''' right <span style="color:#009000"> // указатель на правый узел того же предка</span>
'''int''' degree <span style="color:#008000"> // степень вершины</span>
'''boolean''' mark <span style="color:#008000">// был ли удален в процессе изменения ключа ребенок этой вершины)</span>
</code>Также стоит упомянуть, что нам нужен указатель только на одного ребенка, поскольку остальные хранятся в двусвязном списке с ним. Для доступа ко всей куче нам тоже нужен всего один элемент, поэтому разумно хранить именно указатель на минимум кучи (он обязательно один из корней), а для получения размера за константное время будем хранить размер кучи отдельно.
<code style="display:inline-block">
'''struct''' fibonacciHeap
'''int''' size <span style="color:#008000">// текущее количество узлов</span>
'''Node''' min <span style="color:#008000">// указатель на корень дерева с минимальным ключом</span>
</code>
==== Cоздание кучи ====
Инициализация кучи.
<code style="display:inline-block">
'''function''' buildHeap:
min <tex>= \varnothing</tex>
size = 0
</code>
==== Вставка элемента ====
Данная операция вставляет новый элемент в список корней правее минимума и при необходимости меняет указатель на минимум кучи.
<code style="display:inline-block">
'''function''' insert(x: '''int'''):
'''Node''' newNode <span style="color:#008000"> // создаем новый узел</span>
newNode.key = x <span style="color:#008000"> // инициализируем ключ нового узла</span>
'''if''' size = 0 <span style="color:#008000"> // если куче нет элементов, то только что добавленный минимальный</span>
min = newNode
min.left = newNode
min.right = newNode
'''else'''<span style="color:#008000"> // иначе аккуратно меняем указатели в списке, чтобы не перепутать указатели</span>
'''Node''' prevRight = min.right
min.right = newNode
newNode.left = min
newNode.right = prevRight
prevRight.left = newNode
'''if''' newNode.key < min.key
min = newNode <span style="color:#008000"> // меняем указатель на минимум, если надо</span>
newNode.parent <tex>= \varnothing</tex>
size++ <span style="color:#008000"> // не забываем увеличить переменную size </span>
</code>
==== Получение минимального элемента ====
Получение минимума всей кучи.
<code style="display:inline-block">
'''int''' getMin:
'''return''' min.key
</code>
==== Соедининение двух куч ====
Для сливания двух Фибоначчиевых куч необходимо просто объединить их корневые списки, а также обновить минимум новой кучи, если понадобится. Вынесем в вспомогательную функцию <tex>unionLists</tex> логику, объединяющую два списка вершины, которых подаются ей в качестве аргументов.
<code style="display:inline-block">
'''function''' unionLists(first: '''Node''', second: '''Node'''):
'''Node''' L = first.left <span style="color:#008000"> // аккуратно меняем указатели местами указатели</span>
'''Node''' R = second.right
second.right = first
first.left = second
L.right = R
R.left = L
</code>
Сливаем два корневых списка в один и обновляем минимум, если нужно.
<code style="display:inline-block">
'''function''' merge(that: '''fibonacciHeap'''):
'''if''' that.size = 0 <span style="color:#008000"> // если вторая куча пуста, нечего добавлять</span>
'''return'''
'''if''' size = 0 <span style="color:#008000"> // если наша куча пуста, то результатом будет вторая куча</span>
min = that.min
size = that.size
'''else'''
unionLists(min, that.min) <span style="color:#008000"> // объединяем два корневых списка</span>
size += that.size
'''if''' min <tex>= \varnothing</tex> '''or''' (that.min <tex> \neq \varnothing</tex> '''and''' that.min < min) <span style="color:#008000">// если минимум кучи изменился, то надо обновить указатель</span>
min = that.min
</code>
==== Удаление минимального элемента====
Первая рассматриваемая операция, в ходе которой значительно меняется структура кучи. Здесь используется вспомогательная процедура <tex>consolidate</tex>, благодаря которой собственно и достигается желанная амортизированная оценка. В данном случае <tex> min = \varnothing</tex> не рассматривается и считается нарушением предусловий <tex>deleteMin</tex>
<code style="display:inline-block">
'''int''' deleteMin:
'''Node''' prevMin = min
unionLists(min, min.child) <span style="color:#008000"> // список детей min объединяем с корневым</span>
'''Node''' L = min.left <span style="color:#008000"> // аккуратно удаляем min из списка</span>
'''Node''' R = min.right
L.right = R
R.left = L
'''if''' prevMin.right = prevMin <span style="color:#008000"> // отдельно рассмотрим случай с одним элементом</span>
min <tex>= \varnothing</tex>
'''return'''
min = min.right <span style="color:#008000"> // пока что перекинем указатель min на правого сына, а далее consolidate() скорректирует min в процессе выполнения</span>
consolidate()
size--
'''return''' prevMin.key
</code>
===== Прорежение деревьев =====
Данная процедура принимает кучу и преобразует ее таким образом, что в корневом списке остается не более <tex> degree(H) + 1</tex> вершин.
Для этого возьмем массив списков указателей на корни деревьев <tex> A[0 \dots D[H]] </tex>, где <tex> degree(H) </tex> {{---}} максимальная степень вершины в текущем корневом списке.
Затем происходит [[Биномиальная_куча#merge | процесс, аналогичный слиянию биномиальных куч]]: добавляем поочередно каждый корень, смотря на его степень. Пусть она равна <tex> d </tex>. Если в соответствующей ячейке <tex>A</tex> еще нету вершины, записываем текущую вершину туда. Иначе подвешиваем одно дерево к другому, и пытаемся также добавить дерево, степень корня которого уже равна <tex> d + 1 </tex>. Продолжаем, пока не найдем свободную ячейку. Подвешиваем мы его следующим образом: в корневой список добавляем корень минимальный из тех двух, а корень другого добавляем в список детей корневой вершины. Чтобы лучше понять этот процесс лучше воспользоваться [https://www.cs.usfca.edu/~galles/visualization/FibonacciHeap.html визуализатором]
<code style="display:inline-block">
'''function''' consolidate:
A = '''Node[]'''
A[min.degree] = min <span style="color:#008000"> // создаем массив и инициализируем его min</span>
'''Node''' current = min.right
'''while''' A[current.degree] <tex>\neq</tex> current<span style="color:#008000"> // пока элементы массива меняются</span>
'''if''' A[current.degree] <tex>= \varnothing</tex> <span style="color:#008000"> // если ячейка пустая, то положим в нее текущий элемент</span>
A[current.degree] = current
current = current.right
'''else''' <span style="color:#008000"> // иначе подвесим к меньшему из текущего корня и того, который лежит в ячейке другой</span>
'''Node''' conflict = A[current.degree]
'''Node''' addTo, adding
'''if''' conflict.key < current.key
addTo = conflict
adding = current
'''else'''
addTo = current
adding = conflict
unionLists(addTo.child, adding)
adding.parent = addTo
addTo.degree++
current = addTo
'''if''' min.key > current.key <span style="color:#008000"> // обновляем минимум, если нужно</span>
min = current
</code>
'''Пример'''
Изначально добавляем в нашу кучу <tex>7</tex> элементов <tex>56, 22, 84, 32, 85, 15, 16</tex>. После этого выполним операцию извлечения минимума:
[[File:Fibonacci-heap-consolidate-example-1.png|thumb|center|500px|Начальное состояние кучи]]
* Удалим минимальный элемент из циклического корневого списка и заведем массив <tex>A</tex> для дальнейшего прорежения.
[[File:Fibonacci-heap-consolidate-example-2.png|thumb|center|500px|Удаление мимимума и создание массива]]
* Начнем процесс протяжения с первого элемента {{---}} <tex>56</tex>. Его степень равна <tex>0</tex> поэтому запишем его адрес в нулевую ячейку массива.
[[File:Fibonacci-heap-consolidate-example-3.png|thumb|center|500px|Состояние массива после первой итерации]]
* Следующий элемент <tex>22</tex> тоже имеет степень <tex>0</tex>. Возникает конфликт, который решается подвешиванием к меньшему корню большего. То есть к <tex>22</tex> подвешиваем <tex>56</tex> и увеличиваем степень <tex>22</tex> на <tex>1</tex>. В итоге степень <tex>22</tex> равна <tex>1</tex>. Записываем адрес <tex>22</tex> по индексу <tex>1</tex> в массив.
[[File:Fibonacci-heap-consolidate-example-4.png.png|thumb|center|500px|Состояние после второй итерации]]
* Делаем тоже самое, что и на предыдущих итерациях, но теперь объединяем <tex>32</tex> и <tex>84</tex>
[[File:Fibonacci-heap-consolidate-example-5.png|thumb|center|500px|Состояние после четвертой итерации]]
* Теперь у нас два элемента со степенью <tex>1</tex> в корневом списке. Объединим их подвесив к меньшему корню {{---}} <tex>22</tex>, больший {{---}} <tex>32</tex>. Теперь степень <tex>22</tex> равна <tex>2</tex>, запишем на <tex>2</tex> позицию массива обновленное значение.
[[File:Fibonacci-heap-consolidate-example-6.png|thumb|center|500px|Состояние после пятой итерации]]
* Ну и наконец аналогично объедений последние два элемента.
[[File:Fibonacci-heap-consolidate-example-7.png|thumb|center|500px|Финальное состояние кучи]]
==== Уменьшение значения элемента ====
Основная идея: хотим, чтобы учетная стоимость данной операции была <tex> O(1) </tex>. Было бы хорошо, чтобы вершина не всплывала до корня, и тогда дерево не придется сильно перестраивать. Для этого при удобном случае будем вырезать поддерево полностью и перемещать его в корневой [[Список |список]]. Итак, сам алгоритм:
# Проверяем, если новое значение ключа все же не меньше значения ключа родителя, то все хорошо, и мы выходим.
# Иначе, вырезаем дерево с текущей вершиной в корневой [[Список |список]], и производим каскадное вырезание родителя.
<code style="display:inline-block">
'''function''' decreaseKey(x: '''Node''', newValue: '''int'''):
'''if''' newValue > x.parent.key <span style="color:#008000"> // если после изменения структура дерева сохранится, то меняем и выходим</span>
x.key = newValue
'''return'''
'''Node''' parent = x.parent <span style="color:#008000"> // иначе вызываем cut и cascadingCut</span>
cut(x)
cascadingCut(parent)
</code>
===== Вырезание =====
При вырезании вершины мы удаляем ее из списка детей своего родителя, уменьшаем степень ее родителя (<tex> x.p.degree </tex>) и снимаем пометку с текущей вершины (<tex> x.mark = false </tex>).
<code style="display:inline-block">
'''function''' cut(x: '''Node''')
'''Node''' L = x.left
'''Node''' R = x.right
R.left = L <span style="color:#008000"> // аккуратно удаляем текущую вершину</span>
L.right = R
x.parent.degree--
'''if''' x.parent.child = x <span style="color:#008000"> // чтобы родитель не потерял ссылку на сыновей проверяем: </span>
'''if''' x.right = x. <span style="color:#008000"> // если узел который мы вырезаем содержится в родителе, то меняем его на соседний</span>
x.parent.child <tex>= \varnothing</tex> <span style="color:#008000"> // иначе у родителя больше нет детей</span>
'''else'''
x.parent.child = x.right
x.right = x
x.left = x
x.parent <tex>= \varnothing</tex>
unionLists(min, x) <span style="color:#008000"> // вставляем наше поддерево в корневой список</span>
</code>
===== Каскадное вырезание =====
Перед вызовом каскадного вырезания нам известно, удаляли ли ребенка у этой вершины. Если у вершины до этого не удаляли дочерний узел (<tex> x.mark = false </tex>), то мы помечаем эту вершину (<tex> x.mark = true </tex>) и прекращаем выполнение операции. В противном случае применяем операцию <tex>\mathrm {cut}</tex> для текущей вершины и запускаем каскадное вырезание от родителя.
[[File:Каскадное вырезание.png|thumb|500px|Пример каскадного вырезания]]
<code style="display:inline-block">
'''function''' cascadingCut(x: '''Node''')
'''while''' x.mark = '''true''' <span style="color:#008000"> // пока у нас помеченые вершины вырезаем их</span>
cut(x)
x = x.parent
x.mark = true <span style="color:#008000"> // последнюю вершину нужно пометить {{---}} у нее удаляли ребенка</span>
</code>
'''Пример'''
Рисунок иллюстрирует пример каскадного вырезания:
* Изначально, куча состояла из <tex>3</tex> фибоначчиевых деревьев. У вершины с ключом <tex>24</tex> отсутствует <tex>1</tex> ребенок.
* Уменьшаем ключ <tex>26</tex> до <tex>5</tex> и делаем операцию <tex>\mathrm {cut}</tex> этого дерева. Получаем кучу с <tex>4</tex> деревьями и новым минимумом. Но у вершины с ключом <tex>24</tex> был удален второй ребенок, поэтому запускам операцию <tex>\mathrm {cascadingCut}</tex> для этой вершины: вырезаем ее, помещаем в корневой [[Список |список]] и помечаем ее родителя.
* У вершины с ключом <tex>7</tex> удален лишь один ребенок, поэтому операция <tex>\mathrm {cascadingCut}</tex> от нее не запускается. В итоге, получаем кучу, состоящую из <tex>5</tex> фибоначчиевых деревьев.
==== Удаление элемента ====
Удаление вершины реализуется через уменьшение ее ключа до <tex> -\infty </tex> и последующим извлечением минимума.
<code style="display:inline-block">
'''function''' delete(x: '''Node''')
decreaseKey(x, <tex>-\infty</tex>)
deleteMin()
</code>
== Время работы ==
==== Потенциал ====
Для анализа производительности операций введем потенциал для фибоначчиевой кучи как <tex> \Phi = trees + 2 * marked </tex>, где <tex> trees </tex> {{---}} количество элементов в корневом списке кучи, а <tex> marked </tex> {{---}} количество вершин, у которых удален один ребенок (то есть вершин с пометкой <tex> x.mark = true </tex>). Договоримся, что единицы потенциала достаточно для оплаты константного количества работы.
==== Cоздание кучи ====
Очевидно, что реальное время работы {{---}} <tex> O(1) </tex>.
==== Вставка элемента ====
Для оценки амортизированной стоимости операции рассмотрим исходную кучу <tex> H </tex> и получившуюся в результате вставки нового элемента кучу <tex> H' </tex>. <tex> trees(H') = trees(H) + 1 </tex> и <tex> marked(H') = marked(H) </tex>. Следовательно, увеличение потенциала составляет <tex> (trees(H) + 1 + 2 * marked(H)) - (trees(H) + 2 * marked(H)) = 1 </tex>. Так как реальное время работы составляет <tex> O(1) </tex>, то амортизированная стоимость данной операции также равна <tex> O(1) </tex>.
==== Получение минимального элемента ====
Истинное время работы {{---}} <tex> O(1) </tex>.
==== Соедининение двух куч ====
Реальное время работы {{---}} <tex> O(1) </tex>. Амортизированное время работы также <tex> O(1) </tex>, поскольку, при объединении двух куч в одну, потенциалы обеих куч суммируются, итоговая сумма потенциалов не изменяется, <tex> \Phi_{n + 1} - \Phi_n = 0 </tex>.
==== Удаление минимального элемента====
Для доказательства времени работы этого алгоритма нам понадобится доказать несколько вспомогательных утверждений.
{{Лемма
|id=Лемма1|statement=Для всех целых <tex> n \geqslant 2</tex>Фибоначчиево дерево ранга <tex> k F_n = 1 + \sum\limits_{i=0}^{n-2} F_i </tex> содержит не менее ,где <tex> F_k F_n </tex> ({{---}} <tex> k n </tex> -ое число Фибоначчи) вершин, определяемое формулой:<tex>F_n =\begin{cases} 0, & n = 0 \\ 1, & n = 1 \\ F_{n-1} + F_{n-2}, & n \geqslant 2\end{cases} </tex>
|proof=
}}
<tex>s_1 = Фибоначчиевы кучи 1 =F_1</tex>.
Предположим по индукции, что для всех <tex>i < n \ s_i \geqslant F_i</tex>.Пусть в нашем дереве удалено поддерево порядка <tex>n - 1</tex>. Тогда <tex>s_n = 1 + \sum\limits_{i=0}^{n-2} s_i \geqslant 1 + \sum\limits_{i=0}^{Определениеn-2} F_i</tex> Но по предыдущей [[#Лемма1|definitionлемме]] : <tex>1 + \sum\limits_{i='''Фибоначчиева куча''' 0}^{n- набор фибоначчиевых деревьев2} F_i = F_n</tex>.Следовательно, <tex>s_n \geqslant F_n</tex>
}}
{{Лемма
|id=Лемма3
|statement= <tex>F_n =O(\varphi^n)</tex>, где <tex dpi="160"> \varphi = \frac {1 + \sqrt 5} {2}</tex>
|proof=
Для начала докажем, что <tex>F_n =</tex> <tex dpi="160">\frac {\varphi^n - (-\varphi)^{-n}} {\sqrt 5}</tex>
Используем для этого математическую индукцию.
При <tex>n = 0</tex>
<tex>F_0 =</tex> <tex dpi="160">\frac {\varphi^0 - (-\varphi)^0} {\sqrt 5} = \frac {1 - 1} {\sqrt 5} = 0</tex>, что верно.
<tex>F_n = Операции F_{n-1} + F_{n-2} =</tex> <tex dpi="160">\frac {\varphi^{n-1} - (-\varphi)^{1-n}} {\sqrt 5} + \frac {\varphi^{n-2} - (-\varphi)^{2-n}} {\sqrt 5} =</tex>
<tex dpi="160">= Потенциал \frac {1} {\sqrt 5}</tex> <tex>(\varphi^{n-1} - (-\varphi)^{1-n} + \varphi^{n-2} - (-\varphi)^{2-n}) </tex> <tex dpi="160">=\frac {1} {\sqrt 5}</tex> <tex>(\varphi^{n}(\varphi^{-1} + \varphi^{-2}) - (-\varphi)^{-n}(-\varphi + \varphi^{2}))</tex>
Поскольку <tex>\left\vert (-\varphi)^{-1} \right\vert < 1</tex>, то выполняются неравенства <tex dpi="160">\frac {(-\varphi)^{-n}} {\sqrt 5} < \frac {1} {\sqrt 5} < \frac {1} {2}</tex>. Таким образом, <tex>n</tex>-ое число Фибоначчи равно <tex dpi= Make_heap ="160">\frac {\varphi^{n}} {\sqrt 5}</tex>, округленному до ближайшего целого числа. Следовательно, <tex>F_n =O(\varphi^n)</tex>.}}
{{Лемма|id=Лемма4|statement= Merge =Максимальная степень <tex>degree</tex> произвольной вершины в фибоначчиевой куче с <tex>n</tex> вершинами равна <tex>O(\log n)</tex>|proof=Пусть <tex>x</tex> {{---}} произвольная вершина в фибоначчиевой куче с <tex>n</tex> вершинами, и пусть <tex>k</tex> {{---}} степень вершины <tex>x</tex>. Тогда по [[#Лемма2|доказанному выше]] в дереве, корень которого <tex>x</tex>, содержится не менее <tex>F_k</tex> вершин, что в свою очередь по [[#Лемма3|лемме]] равно <tex>O(\varphi^k)</tex>.То есть
<tex> O(degree + trees) + (degree + 1 + 2 * marked) - (trees + 2 * marked) === Consolidate ===O(degree) + O(trees) - trees</tex>
== Decrease_key Недостатки и достоинства =='''Недостатки''':* Большое потребление памяти на узел(минимум 21 байт)* Большая константа времени работы, что делает ее малоприменимой для реальных задач* Некоторые операции в худшем случае могут работать за <tex>O(n)</tex> времени'''Достоинства''':* Одно из лучших асимптотических времен работы для всех операций
