Викиконспекты - Вклад участника [ru]

Алгоритмы и структуры данных

2019-05-25T12:33:11Z

91.108.28.29: /* Другие задачи */

== Амортизационный анализ ==
* [[Амортизационный анализ]]
* [[Динамический массив]]
* [[Hashed Array Tree]]<tex>^\star</tex>
* [[Список]]
* [[Стек]]
* [[Очередь]]
* [[Дек]]
* [[Мажорирующий элемент]]
* [[Счетчик Кнута]]
* [[Мастер-теорема]]<tex>^\star</tex>
* [[List order maintenance]]<tex>^\star</tex>

== Персистентные структуры данных ==
* [[Персистентные структуры данных]]
* [[Персистентный стек]]
* [[Персистентная очередь]]
* [[Персистентный дек]]
* [[Персистентная приоритетная очередь]]

== [[Приоритетные очереди]] ==
* [[Двоичная куча]]
* [[Биномиальная куча]]
* [[Фибоначчиева куча]]
* [[Левосторонняя куча]]
* [[Тонкая куча]]
* [[Толстая куча на избыточном счетчике]]
* [[Куча Бродала-Окасаки]]<tex>^\star</tex>

== Система непересекающихся множеств ==
* [[СНМ (наивные реализации) | Наивные реализации]]
* [[СНМ (списки с весовой эвристикой) | Списки с весовой эвристикой]]
* [[СНМ(реализация с помощью леса корневых деревьев) | Реализация с помощью леса корневых деревьев]]
* [[СНМ с операцией удаления за О(1)]]<tex>^\star</tex>

== [[Поисковые структуры данных]] ==
* [[Упорядоченное множество]]
* [[Дерево поиска, наивная реализация]]
* [[АВЛ-дерево]]
* [[2-3 дерево]]
* [[B-дерево]]
* [[B+-дерево]]
* [[Красно-черное дерево]]
* [[Декартово дерево]]
* [[Декартово дерево по неявному ключу]]
* [[Splay-дерево]]
* [[Взвешенное дерево]]
* [[Tango-дерево]]<tex>^\star</tex>
* [[Рандомизированное бинарное дерево поиска]]
* [[Дерево ван Эмде Боаса]]
* [[Список с пропусками]]
* [[Fusion tree]]<tex>^\star</tex>
* [[Сверхбыстрый цифровой бор]]
* [[Rope]]<tex>^\star</tex>
* [[AA-дерево]]<tex>^\star</tex>
* [[Техника частичного каскадирования]] <tex>^\star</tex>
* [[Centroid decomposition]] <tex>^\star</tex>

== Запросы на отрезках ==

=== Корневая эвристика ===
* [[Статистики на отрезках. Корневая эвристика]]
* [[Корневая декомпозиция с операциями: get, insert, erase]]
* [[Алгоритм Мо]]

=== Дерево отрезков ===
* [[Дерево отрезков. Построение]]
* [[Реализация запроса в дереве отрезков сверху]]
* [[Реализация запроса в дереве отрезков снизу]]
* [[Несогласованные поддеревья. Реализация массового обновления]]
* [[Многомерное дерево отрезков]]
* [[Сжатое многомерное дерево отрезков]]

== Дерево Фенвика ==
* [[Дерево Фенвика]]
* [[Встречное дерево Фенвика]]
* [[Дерево Фенвика для некоммутативных операций]]
* [[Многомерное дерево Фенвика]]

== Задача о наименьшем общем предке ==
* [[Сведение задачи LCA к задаче RMQ]]
* [[Сведение задачи RMQ к задаче LCA]]
* [[Метод двоичного подъема]]
* [[Решение RMQ с помощью разреженной таблицы]]
* [[Двумерная разреженная таблица]]
* [[Алгоритм Фарака-Колтона и Бендера]] (решение +/-1 RMQ с помощью метода четырех русских)
* [[Алгоритм Хьюи]]
* [[Heavy-light декомпозиция]]
* [[Алгоритм Шибера-Вишкина]]<tex>^\star</tex>
* [[Алгоритм Тарьяна поиска LCA за O(1) в оффлайн]]<tex>^\star</tex>
* [[Link-Cut Tree]]<tex>^\star</tex>
* [[Rake-Compress деревья]]<tex>^\star</tex>

== Хеширование ==
* [[Хеш-таблица]]
* [[Разрешение коллизий]]
* [[Хеширование кукушки]]
* [[Идеальное хеширование]]
* [[Перехеширование]]
* [[Фильтр Блума]]
* [[Quotient filter]]<tex>^\star</tex>
* [[Универсальное семейство хеш-функций]]
* [[Расширяемое хеширование]]<tex>^\star</tex>

== [[Сортировки]] ==
=== Квадратичные сортировки ===
* [[Сортировка выбором]]
* [[Сортировка пузырьком]]
* [[Сортировка вставками]]
=== Сортировки на сравнениях ===
* [[Сортировка Шелла]]<tex>^\star</tex>
* [[Сортировка кучей]]
* [[Быстрая сортировка]]
* [[Сортировка слиянием]]
* [[Cортировка слиянием с использованием O(1) дополнительной памяти]]
* [[Терпеливая сортировка]]<tex>^\star</tex>
* [[Timsort]]<tex>^\star</tex>
* [[Smoothsort]]<tex>^\star</tex>
* [[Теорема о нижней оценке для сортировки сравнениями]]

=== Многопоточные сортировки ===
* [[Многопоточная сортировка слиянием]]<tex>^\star</tex>
* [[PSRS-сортировка]]<tex>^\star</tex>
=== Другие сортировки ===
* [[Поиск k-ой порядковой статистики]]
* [[Поиск k-ой порядковой статистики за линейное время]]
* [[Поиск k-ой порядковой статистики в двух массивах]]<tex>^\star</tex>
* [[Сортировка подсчетом]]
* [[Цифровая сортировка]]
* [[Карманная сортировка]]
* [[Сортировка Хана]]<tex>^\star</tex>
* [[Задача флага Нидерландов]]<tex>^\star</tex>
* [[Блинная сортировка]]<tex>^\star</tex>

== Сортирующие сети ==
* [[Сортирующие сети]]
* [[0-1 принцип | Проверка сети компараторов на то, что она сортирующая. 0-1 принцип]]
* [[Сортирующие сети для квадратичных сортировок]]
* [[Сортировочные сети с особыми свойствами]]<tex>^\star</tex>
* [[Сеть Бетчера]]

== Алгоритмы поиска ==
* [[Целочисленный двоичный поиск]]
* [[Поиск в матрице]]<tex>^\star</tex>
* [[Вещественный двоичный поиск]]
* [[Троичный поиск]]
* [[Поиск с помощью золотого сечения]]
* [[Интерполяционный поиск]]
* [[Метод Фибоначчи]]<tex>^\star</tex>

== [[Динамическое программирование]] ==
=== Классические задачи динамического программирования ===
*[[Кратчайший путь в ациклическом графе]]
*[[Задача о числе путей в ациклическом графе]]
*[[Задача о расстановке знаков в выражении]]
*[[Задача о порядке перемножения матриц]]
*[[Задача о наибольшей общей подпоследовательности]]
*[[Задача о наибольшей возрастающей подпоследовательности]]
*[[Быстрый поиск наибольшей возрастающей подпоследовательности]]*
*[[Задача коммивояжера, ДП по подмножествам]]
*[[Задача о редакционном расстоянии, алгоритм Вагнера-Фишера]]
*[[Задача о рюкзаке]]

=== Способы оптимизации методов динамического программирования ===
*[[Метод четырех русских для умножения матриц]]
*[[Применение метода четырех русских в задачах ДП на примере задачи о НОП]]<tex>^\star</tex>
*[[Задача об оптимальном префиксном коде с сохранением порядка. Монотонность точки разреза]]
*[[Meet-in-the-middle]]<tex>^\star</tex>
*[[Convex hull trick]]

=== Другие задачи ===
*[[Задача о расстоянии Дамерау-Левенштейна]]<tex>^\star</tex>
*[[Задача о выводе в контекстно-свободной грамматике, алгоритм Кока-Янгера-Касами]]
*[[Задача о наибольшей подпоследовательности-палиндроме]]
*[[Задача о наибольшей общей возрастающей последовательности]]<tex>^\star</tex>
*[[Задача о наибольшей общей палиндромной подпоследовательности]]<tex>^\star</tex>
*[[Динамическое программирование по профилю]]<tex>^\star</tex>
*[[Динамика по поддеревьям]]
*[[Level Ancestor problem]]

== Криптографические алгоритмы ==
*[[RSA]]

== Связь между структурами данных ==
* [[Связь между структурами данных]]

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

Level Ancestor problem

2019-05-25T12:26:02Z

91.108.28.29:

'''Задача о уровне предка''' — (англ. "Level Ancestor problem") является задачей о превращении данного подвешенного дерева <tex>T</tex> в структуру данных, которая сможет определить предка любого узла на заданном расстоянии от корня дерева.

{{Задача
|definition = Дано подвешенное дерево <tex>T</tex> c <tex>n</tex> вершинами. Поступают запросы вида <tex>LA(v, k)</tex>, для каждого из которых необходимо
найти предка вершины <tex>v</tex>, который находится на расстоянии <tex>k</tex> от корня дерева <tex>T</tex>.
}}
== Использование Heavy-light декомпозиции ==
[[Файл:LevelAncestor.png|200px|thumb|right]]
Этот алгоритм базируется на различных способах [[Heavy-light декомпозиция | декомпозиции дерева]] (выберем heavy-light декомпозицию), из свойств этого разбиения следует,
что подняться на любую высоту из вершины <tex>v</tex> мы можем за время <tex>O(\log n)</tex>.
Данное разбиение можно строить за <tex>O(n)</tex>, что дает нам алгоритм за <tex>\langle O(n), O(\log n) \rangle</tex>.

В данном примере поступает запрос LA(v, 2), на который алгоритм должен дать ответ h.

== Алгоритм лестниц ==
=== Longest path decomposition <ref>[https://www.mi.fu-berlin.de/en/inf/groups/abi/teaching/lectures/lectures_past/WS0910/V____Discrete_Mathematics_for_Bioinformatics__P1/material/scripts/treedecomposition1.pdf Longest path decomposition]</ref>===
Это декомпозиция дерева, которая разбивает его на множество вершинно-непересекающихся путей, идущих из каждой вершины в ее ребенка с самым глубоким поддеревом.
Сделаем ее следующим образом: обойдем дерево с помощью обхода в глубину, пусть мы стоим в вершине
<tex>v</tex>, обойдем всех ее детей, добавив <tex>v</tex> в путь, идущий в самое глубокое поддерево,
т.е. в котором находится вершина с самой большой глубиной.
Для каждой вершины сохраним номер пути в который она входит.

=== Ladder decomposition ===
Это улучшение Longest-path декомпозиции, позволяющее, как мы потом докажем, подниматься на любую высоту за <tex>O(1)</tex>. Выполним его следующим образом: увеличим каждый путь в два раза вверх, для каждого нового пути сохраним все входящие в него вершины,
а для каждой вершины сохраним ее номер в пути, в который она входит. Построение обычной longest-path декомпозиции займет у
нас <tex>O(n)</tex> времени (обход в глубину), соответственно удлиннение каждого пути ухудшит асимптотику до <tex>O(n \log n)</tex>.

После этого посчитаем двоичные подъемы для каждой вершины за <tex>O(\log n)</tex>, что соответственно не ухудшит асимптотику.

=== Псевдокод ===

Пусть после этого нам пришел запрос LA(v, k).

*<tex>p[i] [v]</tex> — <tex>i</tex>-тый двоичный подъем в предка вершины <tex>v</tex>
*<tex>way[v]</tex> — путь, проходящий через данную вершину
*<tex>num[v]</tex> — номер данной вершины на пути
*<tex>ladder[p][i]</tex> — возвращает <tex>i</tex>-тую вершину на пути <tex>p</tex>

'''function''' LA('''int''' v,'''int''' k):
'''int''' n = h(v) ''// получаем глубину вершины <tex>v</tex>''
n = n - k; ''// на столько необходимо подняться до ответа''
i = <tex>\lfloor \log_2 n \rfloor</tex>
v = p[i][v] ''// делаем максимально большой прыжок вверх''
i = n - i ''// на столько осталось еще подняться''
'''return''' ladder[way[v]][num[v] - i] ''// так как теперь <tex>v</tex> и ответ находятся на одном пути''

=== Доказательство корректности ===
Рассмотрим путь, на котором лежит вершина <tex>v</tex> до удвоения. Он длины хотя бы <tex>2^i</tex>, так как мы точно знаем, что существует вершина потомок <tex>v</tex>, расстояние до которого ровно <tex>2^i</tex> (это вершина, из которой мы только что пришли). Значит, после удвоения этот путь стал длины хотя бы <tex>2^{i + 1}</tex>, причем хотя бы <tex>2^i</tex> вершин в нем — предки <tex>v</tex>. Это означает, что вершина, которую мы ищем, находится на этом пути (иначе бы мы могли до этого прыгнуть еще на <tex>2^i</tex> вверх). Так как мы знаем позицию <tex>v</tex> в этом пути, то нужную вершину мы можем найти за <tex>O(1)</tex>.

Таким образом, наш алгоритм работает за <tex>\langle O(n\log n), O(1)\rangle </tex> времени и за <tex>O(n\log n)</tex> памяти. Методом четырех русских данный метод можно улучшить до <tex>\langle O(n), O(1)\rangle </tex> с помощью оптимизации предподсчета.

== The Macro-Micro-Tree Algorithm ==
В данном разделе мы докажем, что предподсчет предыдущего алгоритма можно улучшить до <tex>O(n)</tex>.
Для начала рассмотрим алгоритм <tex>\langle O(L\log n + n), O(1)\rangle </tex>, где <tex>L</tex> это количество листьев.
*С помощью обхода в глубину запомним по одному листу в ее поддереве для каждой вершины
*Воспользуемся алгоритмом лестниц, но будем выполнять предподсчет только для листьев.
Рассмотрим как можно улучшить данный алгоритм:
*Зададим некую функцию <tex>S(n) = \dfrac{1}{4} \log_2 n</tex>
*Посчитаем размер поддерева для каждой вершины с помощью обхода в глубину, после чего удалим все вершины размер поддерева которых меньше чем <tex>S(n)</tex>.
*Забудем на время про удаленные поддеревья, для оставшегося дерева наш алгоритм работает за <tex>\langle O(\dfrac{n}{S(n)} \log n + n), O(1)\rangle </tex>. Получаем алгоритм <tex>\langle O(n), O(1) \rangle </tex>. Для удаленных поддеревьев же выполним полный предподсчет: таких деревьев не более чем <tex>2^{2S(n)}</tex>, что дает асимптотику предподсчета <tex>O(\sqrt{n} \log^2{n}) = o(n) = O(n)</tex>.

В итоге полученный алгоритм действительно работает за <tex>\langle O(n), O(1)\rangle </tex> времени и за <tex>O(n)</tex> памяти.

== Сравнение с другими реализациями ==
Используя DFS посчитаем глубину каждой вершины дерева (это можно сделать за <tex>O(n)</tex>), после чего можем из вершины <tex>v</tex> подняться до необходимой глубины вершины <tex>k</tex>,
что так же в худшем случае работает за <tex>O(n)</tex>.
Получили алгоритм за <tex>\langle O(n), O(n) \rangle</tex> времени и <tex>O(n)</tex> памяти, где время ответа на
запрос можно улучшить до <tex>O(\log n)</tex> c помощью [[Метод двоичного подъёма | предподсчета двоичных подъемов]] ,
но тогда и время предподсчета в наивной реализации (посчитать подъемы для всех вершин) ухудшится до <tex>\langle O(n \log n),
O(\log n)\rangle </tex> времени и <tex>O(n \log n)</tex> памяти. Также альтернативой данным двум алгоритмам является полный предподсчет всех возможных запросов, что соответственно дает нам асимптотику <tex>\langle O(n^2), O(1)\rangle </tex>времени и <tex>O(n^2)</tex> памяти.

Сравнение различных асимптотик из данной статьи:
{| class="wikitable" style="clear:right;" cellpadding="10"
|+
|-align="center"
!
| Предподсчет
| Ответ на запрос
| Память
|-align="center"
!Обычный подъем до нужного уровня
|<tex>O(n)</tex>||<tex>O(n)</tex>||<tex>O(n)</tex>
|-align="center"
!Полный предподсчет
|<tex>O(n^2)</tex>||<tex>O(1)</tex>||<tex>O(n^2)</tex>
|-align="center"
!Двоичные подъемы
|<tex>O(n \log n)</tex>||<tex>O(\log n)</tex>||<tex>O(n \log n)</tex>
|-align="center"
!Декомпозиция
|<tex>O(n)</tex>||<tex>O(\log n)</tex>||<tex>O(n)</tex>
|-align="center"
!Алгоритм лестниц
|<tex>O(n \log n)</tex>||<tex>O(1)</tex>||<tex>O(n \log n)</tex>
|-align="center"
!Macro-Micro-Tree Algorithm
|<tex>O(n)</tex>||<tex>O(1)</tex>||<tex>O(n)</tex>
|}
== См. также ==
*[[Метод двоичного подъёма]]
*[[Heavy-light декомпозиция]]
== Примечания ==
<references/>
== Источники информации ==
*[https://www.cadmo.ethz.ch/education/lectures/HS18/SAADS/reports/5.pdf Level Ancestor problem simplified Cai Qi]
*[https://en.wikipedia.org/wiki/Level_ancestor_problem Wikipedia: LA]
[[Категория: Алгоритмы и структуры данных]]