Изменения

Перейти к: навигация, поиск

Алгоритм Тарьяна поиска LCA за O(1) в оффлайн

3211 байт добавлено, 5 сентябрь
м
Исправлена описка
Дано [[Дерево, эквивалентные определения | дерево ]] <tex> G </tex> и набор запросов: пары вершин <tex>\langle v, u \rangle </tex>, и для . Для каждой пары нужно найти наименьшего общего предка. Считаем, что все запросы известны заранее, поэтому будем решать задачу оффлайн.Алгоритм позволяет найти ответы для дерева из <tex>n</tex> вершин и <tex>m</tex> запросов за время <tex>O (n + m)</tex>, то есть при достаточно большом <tex>m</tex>, за <tex>O (1)</tex> на запрос.
== Алгоритм ==
Подвесим наше дерево за любую вершину, и запустим [[Обход в глубину, цвета вершин|обход в глубину]] из неё.
Ответ на каждый запрос мы найдём в течение поиска в глубину. Ответ для вершин <tex>v</tex> и <tex>u</tex> находится, когда мы уже посетили вершину <tex>u</tex>, а так же также посетили всех сыновей вершины <tex>v</tex>, и собираемся выйти из неё.
Зафиксируем момент: мы собираемся выйти из вершины <tex>v</tex> (обработали всех сыновей) и хотим узнать ответ для пары <tex>\langle v</tex>, <tex>u \rangle</tex>.
Тогда заметим, что ответ {{---}} это либо вершина <tex>u</tex>, либо какой-то её предок. Значит, нам нужно найти предка вершины <tex>v</tex>, который является предком вершины <tex>u</tex> с наибольшей глубиной. Заметим, что при фиксированном <tex>v</tex> каждый из предков вершины <tex>v</tex> порождает некоторый класс вершин <tex>u</tex>, для которых он является ответом, в этом классе содержатся все вершины , которые находятся "слева" от этого предка.
На рисунке разные цвета {{---}} разные непосещённые вершины раскрашены в белый цвет, а посещённые разбиты на классы, а белые вершины ещё не просмотренные в <tex>dfs</tex>каждому из которых соответствует свой цвет.
Классы этих вершин не пересекаются, а значит мы их можем эффективно обрабатывать с помощью [[СНМ (реализация с помощью леса корневых деревьев)file:mytree.png|системы непересекающихся множеств500px|разные цвета {{---}} разные классы, а белые вершины ещё не просмотренные в dfs]], которую будем хранить в массиве <tex>dsu</tex>.
Будем поддерживать массив <tex>ancestor[1 \dots n]</tex> {{---}} представитель множества в котором содержится вершина <tex>v</tex>.Для каждого класса мы образуем множество и представителя этого множества.Когда, мы приходим в новую вершину <tex>v</tex> мы должны добавить её в новый класс (<tex>ancestor[v] = v</tex>)Классы этих вершин не пересекаются, а когда просмотрим всё поддерево какого-то ребёнказначит, мы должны объединить это поддерево можем их эффективно обрабатывать с нашим классом помощью [[СНМ (операция <tex>union</tex>реализация с помощью леса корневых деревьев) и не забыть установить представителя как вершину |системы непересекающихся множеств]], которую будем хранить в массиве <tex>vdsu</tex>.
После того как мы обработали всех детей вершины <tex>v</tex>, мы можем ответить на все запросы вида Будем поддерживать также массив <tex>lcaClass[1 \langle v, u \rangle dots n]</tex>, где <tex>ulcaClass[w] </tex> {{---}} уже посещённая вершина.Нетрудно заметитьнаименьший общий предок всех вершин, которые лежат в том же классе, что и <tex> w </tex>. Обновление массива <tex> lcaClass </tex> для каждого элемента будет неэффективно. Поэтому зафиксируем в каждом классе какого-то представителя. Функция <tex>lca \langle vmathrm{find}(w) </tex> вернёт представителя класса, u \rangle = ancestorв котором находится вершина <tex> w </tex>. Тогда наименьшим общим предком всех вершин из класса <tex> w </tex> будет вершина <tex> lcaClass[\mathrm{find}(uw)]</tex>. Для каждого запроса это условие (что одна вершина уже посещена, а другую мы обрабатываем) выполнится только один раз.
Предположим, что нашли предка, который не является наименьшим, тогда это нас моментально приводит к противоречиюОбновление массива <tex> lcaClass </tex> будем производить следующим образом:* когда мы приходим в новую вершину <tex>v</tex>, потому что запросмы мы должны были рассмотреть ранее добавить её в новый класс {{---}} на минимальном предке. <tex>lcaClass[v] = v</tex>Если он не минимальный, значит, есть на какой* когда просмотрим всё поддерево какого-то большей глубинеребёнка <tex> u </tex> у вершины <tex> v </tex>, мы должны объединить поддерево ребёнка с классом вершины <tex> v </tex> (<tex>\mathrm{union}(v, то есть такая вершинаu, которая была посещена раньше v)</tex> {{---}} объединить классы вершин <tex> v </tex> и для которой условия на <tex>u</tex> и , а наименьшим общим предком представителя нового класса сделать вершину <tex>v</tex> выполнялись, значит, тогда должна была найтись эта вершина ). Система непересекающихся множеств сама определит представителя в качестве зависимости от используемой нами эвристики. Нам надо лишь правильно установить значение массива <tex>LCAlcaClass </tex>у нового представителя.
[[file:mytree.png|500px|разные цвета После того как мы обработали всех детей вершины <tex>v</tex>, мы можем ответить на все запросы вида <tex>\langle v, u \rangle </tex>, где <tex>u</tex> {{---}} разные классыуже посещённая вершина.Нетрудно заметить, что <tex>lca(v, u) = lcaClass[\mathrm{find}(u)]</tex>. Для каждого запроса это условие (что одна вершина уже посещена, а белые вершины ещё не просмотренные в dfs]]другую мы обрабатываем) выполнится только один раз.
=== Реализация ===
'''bool''' visited[n]
vector<'''int'''> query[n]
'''int''' dsuGet(v : '''int'''):
'''if''' v == dsu[v]
'''return''' v
'''else'''
'''return''' dsu[v] = dsuGet(dsu[v])
'''function''' union(a x : '''int''', b y : '''int''', newAncestor : '''int'''): a leader = dsuGetdsuUnion(ax, y) b <font color= dsuGet(b)green> // объединяем классы вершин <tex> x </tex> и <tex> y </tex> и получаем нового представителя класса </font> dsu lcaClass[aleader] = b ancestor[b] newAncestor <font color= newAncestorgreen> // устанавливаем нового предка представителю множества </font>
<font color=green>// можно запустить от любой вершины дерева.в самый первый раз</font>
'''function''' dfs(v : '''int'''):
visited[v] = ''true'' lcaClass[v] = v
'''foreach''' u : (v, u) '''in''' G
'''if''' '''not''' visited[u]
dfs(u)
union(v, u, v)
'''for''' i = 0 '''to''' query[(u : <tex>\langle v].size , u \rangle </tex> {{--- 1}} есть такой запрос) '''if''' visited[query[v][i]u] запомнить, что ответ для запроса <tex>\langle v, u \rangle </tex> = ancestorlcaClass[dsuGet[qfind[u]] == Корректность == Случай, когда <tex> u </tex> является наименьшим общим предком вершин <tex> u </tex> и <tex> v]</tex>, обработается правильно, потому что по алгоритму в этот момент <tex> lcaClass[i]]\mathrm{find}(u)]= u </tex>. Пусть теперь наименьшим общим предком вершин <tex> u </tex> и <tex> v </tex> будет вершина, отличная от этих двух. Во время обработки запроса алгоритм точно вернёт общего предка этих двух вершин, так как он будет предком одной из вершин по массиву <tex> lcaClass </tex>, а предком другой из-за обхода в глубину.  Покажем, что найдём наименьшего предка. Пусть это не так. Тогда существует какая-то вершина <tex> w </tex>, которая тоже является предком вершин <tex> u </tex> и <tex> v </tex>, и из которой мы вышли раньше во время обхода в глубину. Но тогда ситуация, что одна из вершин посещена, а у другой рассмотрены все дети, должна была выполниться раньше, и в качестве ответа должна была вернуться вершина <tex> w </tex>. '''Замечание:''' для корректности алгоритма достаточно было бы одного массива <tex> dsu </tex>, а представителем класса всегда выбирать наименьшего общего предка вершин класса. Это несложно сделать, так как мы всегда объединяем ребёнка со своим родителем. Но в таком случае алгоритм получился бы менее эффективным, потому что одна только эвристика сжатия путей работает недостаточно быстро.
== Оценка сложности ==
Она состоит из нескольких оценокчастей.
*Обход в глубину выполняет выполняется за <tex>O(n)</tex>.*Операции по объединению множеств, которые в сумме для всех разумных <tex>n</tex> затрачивают работают <tex>O (n)</tex> операцийвремени. Каждый запрос <tex>\langle v, u \rangle </tex> будет рассмотрен дважды {{---}} при посещение посещении вершины <tex>u</tex> и <tex>v</tex>, но обработан лишь один раз, поэтому можно считать, что все запросы обработаются суммарно за <tex>O (m)</tex>.
*Для каждого запроса проверка условия и определение результата, опять же, для всех разумных <tex>n</tex> выполняется за <tex>O (1)</tex>.
Итоговая Следовательно, итоговая асимптотика получается {{---}} <tex>O (n + m)</tex>, но что при достаточно больших <tex>m</tex> ответ за составляет <tex>O (1)</tex> на один запрос. ==См. также==* [[Сведение задачи LCA к задаче RMQ]]* [[Heavy-light декомпозиция]]
== Источники информации ==
24
правки

Навигация