Изменения

'''Фибоначчиева куча''' (англ. ''Fibonacci heap'') {{---}} структура данных, отвечающая интерфейсу [[Приоритетные очереди#Операции | приоритетная очередь]]. Эта структура данных имеет меньшую [[Амортизационный анализ#Основные определения | амортизированную сложность]], чем такие приоритетные очереди как [[Биномиальная куча | биномиальная куча]] и [[Двоичная куча | двоичная куча]]. Изначально эта структура данных была разработана Майклом Фридманом<ref>[[wikipedia:en:Michael_Fredman | Майкл Фридман {{---}} Википедия]]</ref> и Робертом Тарьяном<ref>[[wikipedia:en:Robert_Tarjan | Роберт Тарьян {{---}} Википедия]]</ref> при работе по улучшению асимптотической сложности [[Алгоритм Дейкстры | алгоритма Дейкстры]]. Свое название Фибоначчиева куча получила  из-за использования некоторых свойств чисел Фибоначчи<ref>[[wikipedia:en:Fibonacci_number | Числа Фибоначчи {{---}} Википедия]]</ref> в [[Амортизационный анализ#Метод потенциалов | потенциальном анализе]] этой реализации.== Фибоначчиево дерево Структура ==Фибоначчиева куча {{---}} набор из [[Дерево, эквивалентные определения | подвешенных деревьев]] удовлетворяющих свойству: каждый предок не больше своих детей(если дерево на минимум). Это означает, что минимум всей кучи это один из корней этих деревьев. Одним из главных преимуществ Фибоначчиевой кучи {{---}} гибкость её структуры из-за того, что на деревья не наложены никакие ограничения по форме. Например, Фибоначчиева куча может состоять хоть из деревьев в каждом из которых по одному элементу. Такая гибкость позволяет выполнять некоторые операции лениво, оставляя работу более поздним операциям. Далее будут даны некоторые определения, которые понадобятся в дальнейшем.

'''Фибоначчиево деревоСтепень вершины''' (англ. ''Fibonacci treedegree'') {{---}} [[Биномиальная куча#Биномиальное дерево |биномиальное дерево]]количество детей данной вершины. Далее будем обозначать как <tex>degree(x)</tex>, где у каждой вершины удалено не более одного ребенка<tex>x</tex> это вершина.

'''Порядок фибоначчиева дереваСтепень кучи''' (англ. ''Fibonacci tree rankdegree'') {{---}} порядок соответствующего биномиального дереванаибольшая степень вершины этой кучи. Далее будем обозначать как <tex>degree(H)</tex>, из которого оно полученогде <tex>H</tex> это куча.

* Делаем тоже самое, что и на предыдущих итерациях, но теперь объединяем <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|definition500px|Состояние после пятой итерации]]   * Ну и наконец аналогично объедений последние два элемента.  [[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(x.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.right = x x.left = x 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.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> фибоначчиевых деревьев.

|statement= <tex>F_n =\ThetaO(\varphi^n)</tex>, где <tex dpi="160"> \varphi = \frac {1 + \sqrt 5} {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="160">\frac {\varphi^{n}} {\sqrt 5}</tex>, округленному до ближайшего целого числа. Следовательно, <tex>F_n =\ThetaO(\varphi^n)</tex>.

|statement=Максимальная степень <tex>D(n)degree</tex> произвольной вершины в фибоначчиевой куче с <tex>n</tex> вершинами равна <tex>O(\log n)</tex>

Пусть <tex>x</tex> {{---}} произвольная вершина в фибоначчиевой куче с <tex>n</tex> вершинами, и пусть <tex>k</tex> {{---}} степень вершины <tex>x</tex>. Тогда по [[#Лемма2|доказанному выше]] в дереве, корень которого <tex>x</tex>, содержится не менее <tex>F_k</tex> вершин, что в свою очередь по [[#Лемма3|лемме]] равно <tex>\ThetaO(\varphi^k)</tex>.

Таким образом, максимальная степень <tex>D(n)degree</tex> произвольной вершины равна <tex>O(\log n)</tex>.

=== Структура =======Структура узла====Каждый узел Итоговая асимптотика операции <tex>x\mathrm {extraxtMin}</tex> в куче , учитывая и вспомогательную функцию <tex>H\mathrm {consolidate} </tex> содержит следующие указатели и поля, время работы которой доказывается ниже, равно: '''struct''' Node '''int''' key <span styletex> O(1)+O(degree)+O(degree)="color:O(degree) </tex>. По доказанной выше [[#008000"Лемма4|лемме]] <tex> // ключO(degree) = O(\log(n))</spantex>.  '''Node''' p Учетная стоимость <span style="color:#008000"tex> \mathrm {consolidate} <// указатель на родительский узелtex> равна <tex> O(degree) </spantex>. Докажем это: '''Node''' child Изначально в корневом списке было не более <span style="color:#008000"tex> degree + trees - 1 <// указатель на один tex> вершин, поскольку он состоит из дочерних узловисходного списка корней с <tex>trees</spantex> '''Node''' left узлами, минус извлеченный узел и плюс дочерние узлы, количество которых не превышает <span style="color:#008000"tex> degree <// указатель на левый сестринский узелtex>. В ходе операции <tex> \mathrm {consolidate} </spantex> '''Node''' right мы сделали <span style="color:#008000"tex> // указатель на правый сестринский узелO(degree + trees) </spantex> '''int''' degree слияний деревьев. Потенциал перед извлечением минимума равен <span style="color:#008000"tex> // количество дочерних узловtrees + 2 * marked </spantex> '''boolean''' mark , а после не превышает <span style="color:#008000"tex>degree + 1 + 2 * marked<// флагtex>, который показывает, удаляли ли мы дочерние узлы данной вершиныпоскольку в корневом списке остается не более <tex> degree + 1 </spantex>узлов, а количество помеченных узлов не изменяется. Таким образом, амортизированная стоимость не превосходит

====Структура кучи==== '''struct''' Heap '''int''' size <span style="color:#008000"tex>// текущее количество узлов</span> '''Node''' min <span styleO(degree + trees) + (degree + 1 + 2 * marked) - (trees + 2 * marked) ="color:#008000">// указатель на корень дерева с минимальным ключом</span>====Структура списка детей====[[File:FibonacciO(degree) + O(trees) -heap.png|thumb|340px|Пример фибоначчиевой кучи]]* Дочерние узлы <tex>x</tex> объединены при помощи указателей <tex>left</tex> и <tex>right</tex> в [[Список#Циклический список |циклический]] [[Список#Двусвязный список | двусвязный список]].* Корни всех деревьев в <tex>H</tex> связаны при помощи указателей <tex>left</tex> и <tex>righttrees</tex> в [[Список#Циклический список |циклический]] [[Список#Двусвязный список | двусвязный список]] корней.

[[Список#Циклический список |Циклический]] [[Список#Двусвязный список | двусвязный список]] обладает двумя преимуществами для использования в фибоначчиевых кучах. ВоПоскольку мы договорились, что можем масштабировать единицу потенциала таким образом, чтобы покрывать константное количество работы, то итоговая амортизационная оценка {{---первых, удаление элемента из такого списка выполняется за время }} <tex>O(1degree)</tex>. Во-вторых==== Уменьшение значения элемента ====Докажем, если имеется два таких списка, их легко объединить в один за что амортизированное время работы операции <tex> \mathrm {decreaseKey} </tex> есть <tex>O(1)</tex>. Поскольку в процедуре нет циклов, ее время работы определяется лишь количеством рекурсивных вызовов каскадного вырезания.

Для анализа производительности операций введем Рассмотрим, как изменится потенциал для фибоначчиевой кучи в результате выполнения данной операции. Пусть <tex>H</tex> как {{---}} фибоначчиева куча до вызова <tex> \Phi(H) = t[H] + 2m[H] mathrm {decreaseKey} </tex>, где . Тогда после <tex> t[H] k </tex> {{---}} количество элементов в корневом списке кучи, а итераций операции <tex> m[H] \mathrm {cascadingCut} </tex> {{---}} количество вершин, у которых удален один ребенок (то есть вершин с пометкой <tex> x.mark = true </tex>). Договоримсястало как минимум на <tex> k - 2 </tex> меньше, потому что единицы потенциала достаточно для оплаты константного количества работыкаждый вызов каскадного вырезания, за исключением последнего, уменьшает количество помеченных вершин на одну, и в результате последнего вызова одну вершину мы можем пометить. В корневом списке прибавилось <tex> k </tex> новых деревьев (<tex> k - 1 </tex> дерево за счет каскадного вырезания и еще одно из-за самого первого вызова операции <tex> \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> \mathrm {decreaseKey} </tex> равна <tex> O(1) </tex>.====Удаление элемента = Операции ===Рассмотрим операции, которые поддерживают фибоначчиевы кучи. Амортизированное время их работы показано в таблице: <tex> O(1) + O(degree) = O(degree) </tex>.

 Стоит заметить, что структура фибоначчиевых куч, также как биномиальных и бинарных, не могут обеспечить эффективную реализацию поиска элемента с заданным ключом, поэтому операции <tex>\mathrm {decreaseKey}</tex> и <tex>\mathrm {delete}</tex> получают в качестве аргумента указатель на узел, а не значение его ключа. ==== makeHeap ==Недостатки и достоинства == Создается новый пустой корневой [[Список#Двусвязный список | список]], в <tex> H.min </tex> устанавливается значение <tex> null </tex>. Реальное время работы {{---}} <tex> O(1) </tex>. ==== insert ==== Вставка элемента в фибоначчиеву кучу также тривиальна: создается новая куча из одного элемента и сливается с текущей. Для оценки амортизированной стоимости операции рассмотрим исходную кучу <tex> H </tex> и получившуюся в результате вставки нового элемента кучу <tex> H' </tex>. <tex> t[H'] = t[H] + 1 </tex> и <tex> m[H'] = m[H] </tex>. Следовательно, увеличение потенциала составляет <tex> (t[H] + 1 + 2m[H]) - (t[H] + 2m[H]) = 1 </tex>. Так как реальное время работы составляет <tex> O(1) </tex>, то амортизированная стоимость данной операции также равна <tex> O(1) </tex>.Недостатки''': ==== getMin ====Возвращает указатель <tex>H.min</tex>. Реальное время работы {{---}} <tex> O* Большое потребление памяти на узел(1минимум 21 байт) </tex>. ==== merge ==== Слияние двух фибоначчиевых куч происходит просто: объединяем списки этих куч в один, релаксируем минимум. Реальное время работы {{---}} <tex> O(1) </tex>. Амортизированное время * Большая константа времени работы также <tex> O(1) </tex>, поскольку, при объединении двух куч в одну, потенциалы обеих куч суммируются, итоговая сумма потенциалов не изменяется, <tex> \Phi_{n + 1} - \Phi_n = 0 </tex>.что делает ее малоприменимой для реальных задач ==== extractMin ==== Первая рассматриваемая операция, в ходе которой меняется структура кучи. Здесь используется вспомогательная процедура <tex> \mathrm {consolidate} </tex>. Возьмем указатель на <tex> H.min </tex>, удалим эту вершину. Ее поддеревья (их не более, чем <tex> D(n) </tex>, где <tex> D(n) </tex> {{---}} максимальная степень вершины в куче) объединим с корневым списком. Теперь вызываем процедуру <tex> \mathrm {consolidate} </tex>. После этой * Некоторые операции могут в списке корней остается не более чем <tex> D(n) + 1</tex> узлов, среди которых нужно найти минимальный. Итоговая асимптотика операции <tex>\mathrm {extraxtMin}</tex>, учитывая и вспомогательную функцию <tex> \mathrm {consolidate} </tex>, время работы которой доказывается ниже, равно: худшем случае могут работать за <tex> O(1)+O(D(n))+O(D(n))=O(D(n)) </tex>. По доказанной выше [[#Лемма4|лемме]] <tex>O(D(n)) = O(\log(n))</tex>.времени ===== consolidate ===== Данная процедура принимает кучу и преобразует ее таким образом, что в корневом списке остается не более <tex> D(n) + 1</tex> вершин. Для этого возьмем массив списков указателей на корни деревьев <tex> A[0..D[H]] </tex>, где <tex> D[H] </tex> {{---}} максимальная степень вершины в текущем корневом списке. Затем происходит [[Биномиальная_куча#merge | процесс, аналогичный слиянию биномиальных куч]]'''Достоинства''': добавляем поочередно каждый корень, смотря на его степень. Пусть она равна <tex> d </tex>. Если в соответствующей ячейке <tex>A</tex> еще нету вершины, записываем текущую вершину туда. Иначе подвешиваем одно дерево к другому, и пытаемся также добавить дерево, степень корня которого уже равна <tex> d + 1 </tex>. Продолжаем, пока не найдем свободную ячейку. Учетная стоимость <tex> \mathrm {consolidate} </tex> равна <tex> O(D(n)) </tex>. Докажем это: Изначально в корневом списке было не более <tex> D(n) + t[H] - 1 </tex> вершин, поскольку он состоит * Одно из исходного списка корней с <tex>t[H]</tex> узлами, минус извлеченный узел и плюс дочерние узлы, количество которых не превышает <tex> D(n) </tex>. В ходе операции <tex> \mathrm {consolidate} </tex> мы сделали <tex> O(D(n) + t[H]) </tex> слияний деревьев. Потенциал перед извлечением минимума равен <tex> t[H] + 2m[H] </tex>, а после не превышает <tex> D(n) + 1 + 2m[H] </tex>, поскольку в корневом списке остается не более <tex> D(n) + 1 </tex> узлов, а количество помеченных узлов не изменяется. Таким образом, амортизированная стоимость не превосходит <tex> O(D(n) + t[H]) + (D(n) + 1 + 2m[H]) - (t[H] + 2m[H]) = O(D(n)) + O(t[H]) - t[H]</tex> Поскольку мы договорились, что можем масштабировать единицу потенциала таким образом, чтобы покрывать константное количество лучших ассимптотических времен работы, то итоговая амортизационная оценка {{---}} <tex> O(D(n)) </tex>для всех операций==== decreaseKey ==== Основная идея: хотим, чтобы учетная стоимость данной операции была <tex> O(1) </tex>См. Было бы хорошо, чтобы вершина не всплывала до корня, и тогда дерево не придется сильно перестраивать. Для этого при удобном случае будем вырезать поддерево полностью и перемещать его в корневой [[Список |список]]. Итак, сам алгоритм: # Проверяем, если новое значение ключа все же не меньше значения ключа родителя, то все хорошо, и мы выходим.# Иначе, вырезаем дерево с текущей вершиной в корневой [[Список |список]], и производим каскадное вырезание родителя.  ===== cut ===также == При вырезании вершины мы удаляем ее из списка детей своего родителя, уменьшаем степень ее родителя (<tex> x.p.degree </tex>) и снимаем пометку с текущей вершины (<tex> x.mark = false </tex>). ===== cascadingCut ===== * [[File:Каскадное вырезание.png|thumb|500px|Пример каскадного вырезанияПриоритетные очереди]] Перед вызовом каскадного вырезания нам известно, удаляли ли ребенка у этой вершины. Если у вершины до этого не удаляли дочерний узел (<tex> x.mark = false </tex>), то мы помечаем эту вершину (<tex> x.mark = true </tex>) и прекращаем выполнение операции. В противном случае применяем операцию <tex>\mathrm {cut}</tex> для текущей вершины и запускаем каскадное вырезание от родителя. '''Пример''' Рисунок иллюстрирует пример каскадного вырезания: * Изначально, куча состояла из <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> \mathrm {decreaseKey} </tex> есть <tex> O(1) </tex>. Поскольку в процедуре нет циклов, ее время работы определяется лишь количеством рекурсивных вызовов каскадного вырезания. Пусть мы вызвали процедуру каскадного вырезания <tex> k </tex> раз. Так как реальное время работы операции <tex> \mathrm {cascadingCut} </tex> без учета рекурсии составляет <tex> O(1) </tex>, то реальное время работы операции <tex> \mathrm {decreaseKey} </tex> {{---}} <tex> O(k) </tex>.  Рассмотрим, как изменится потенциал в результате выполнения данной операции. Пусть <tex> H </tex> {{---}} фибоначчиева куча до вызова <tex> \mathrm {decreaseKey} </tex>. Тогда после <tex> k </tex> рекурсивных вызовов операции <tex> \mathrm {cascadingCut} </tex> вершин с пометкой <tex> x.mark = true </tex> стало как минимум на <tex> k - 2 </tex> меньше, потому что каждый вызов каскадного вырезания, за исключением последнего, уменьшает количество помеченных вершин на одну, и в результате последнего вызова одну вершину мы можем пометить. В корневом списке прибавилось <tex> k </tex> новых деревьев (<tex> k - 1 </tex> дерево за счет каскадного вырезания и еще одно из-за самого первого вызова операции <tex> \mathrm {cut} </tex>).  В итоге, изменение потенциала составляет: <tex> \Phi_i - \Phi_{i - 1} = ((t[H] + k) + 2(m[HБиномиальная куча] + k - 2)) - (t[H] + 2m[H]) = 4 - k </tex>. Следовательно, амортизированная стоимость не превышает <tex> O(k) + 4 - k </tex>. Но поскольку мы можем соответствующим образом масштабировать единицы потенциала, то амортизированная стоимость операции <tex> \mathrm {decreaseKey} </tex> равна <tex> O(1) </tex>. ==== delete ==== Удаление вершины реализуется через уменьшение ее ключа до <tex> -\infty </tex> и последующим извлечением минимума. Амортизированное время работы: <tex> O(1) + O(D(n)) = O(D(n)) </tex>. Поскольку ранее мы показали, что <tex> D(n) = O(\log n ) </tex>, то соответствующие оценки доказаны. ==См. также==

* [[wikipedia:ruen:Числа Фибоначчи|Числа Фибоначчи {{---}} Википедия]]* [[wikipedia:ruen:Фибоначчиева кучаFibonacci heap|Фибоначчиева куча {{---}} Википедия]]* [https://www.cs.usfca.edu/~galles/visualization/FibonacciHeap.html Fibonacci heap visualization]

* [http://rainwww.cs.ifmoduke.ruedu/catcourses/view.phpfall05/viscps230/heaps ВизуализаторыL-11.pdf Fibonacci Heaps {{---}} Duke University]* [httphttps://www.cs.dukeprinceton.edu/courses/fall05~wayne/cps230teaching/Lfibonacci-11heap.pdf Fibonacci Heaps{{---}} Princeton University]

[[Категория: Дискретная математика Алгоритмы и алгоритмыструктуры данных]]