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

Материал из Викиконспекты
Перейти к: навигация, поиск
(Алгоритм)
(Реализация)
Строка 26: Строка 26:
  
 
  '''bool''' visited[n]   
 
  '''bool''' visited[n]   
vector<'''int'''> query[n]
 
 
   
 
   
 
  '''function''' union(x : '''int''', y : '''int''', newAncestor : '''int'''):
 
  '''function''' union(x : '''int''', y : '''int''', newAncestor : '''int'''):
Строка 39: Строка 38:
 
             dfs(u)
 
             dfs(u)
 
             union(v, u, v)
 
             union(v, u, v)
     '''for''' i = 0 '''to''' query[v].size - 1
+
     '''foreach''' u : <tex>\langle v, u \rangle </tex> {{---}} есть такой запрос
         '''if''' visited[query[v][i]]
+
         '''if''' visited[u]
             запомнить, что ответ для запроса <tex>\langle v, u \rangle </tex> = ancestor[find[q[v][i]]]
+
             запомнить, что ответ для запроса <tex>\langle v, u \rangle </tex> = ancestor[find[u]]
  
 
== Корректность ==
 
== Корректность ==

Версия 17:26, 9 июня 2014

Дано дерево и набор запросов: пары вершин [math]\langle v, u \rangle [/math], и для каждой пары нужно найти наименьшего общего предка. Считаем, что все запросы известны заранее, поэтому будем решать задачу оффлайн. Алгоритм позволяет найти ответы для дерева из [math]n[/math] вершин и [math]m[/math] запросов за время [math]O (n + m)[/math], то есть при достаточно большом [math]m[/math], за [math]O (1)[/math] на запрос.

Алгоритм

Подвесим наше дерево за любую вершину, и запустим обход в глубину из неё. Ответ на каждый запрос мы найдём в течение поиска в глубину. Ответ для вершин [math]v[/math] и [math]u[/math] находится, когда мы уже посетили вершину [math]u[/math], а так же посетили всех сыновей вершины [math]v[/math], и собираемся выйти из неё.

Зафиксируем момент: мы собираемся выйти из вершины [math]v[/math] (обработали всех сыновей) и хотим узнать ответ для пары [math]\langle v[/math], [math]u \rangle[/math]. Тогда заметим, что ответ — это либо вершина [math]u[/math], либо какой-то её предок. Значит, нам нужно найти предка вершины [math]v[/math], который является предком вершины [math]u[/math] с наибольшей глубиной. Заметим, что при фиксированном [math]v[/math] каждый из предков вершины [math]v[/math] порождает некоторый класс вершин [math]u[/math], для которых он является ответом, в этом классе содержатся все вершины которые находятся "слева" от этого предка.

На рисунке разные цвета — разные классы, а белые вершины ещё не просмотренные в [math]dfs[/math].

разные цвета — разные классы, а белые вершины ещё не просмотренные в dfs

Классы этих вершин не пересекаются, а значит мы можем их эффективно обрабатывать с помощью системы непересекающихся множеств, которую будем хранить в массиве [math]dsu[/math].

Будем поддерживать массив [math]ancestor[1 \dots n][/math], где [math] ancestor[w] [/math] — наименьший общий предок всех вершин, которые лежат в том же классе, что и [math] w [/math]. Обновление массива [math] ancestor [/math] для каждого элемента будет неэффективно. Поэтому зафиксируем в каждом классе какого-то представителя этого класса. Функция [math] \mathrm{find}(w) [/math] вернёт представителя класса, в котором находится вершина [math] w [/math]. Тогда наименьшим общим предком всех вершин из класса [math] w [/math] будет вершина [math] ancestor[\mathrm{find}(w)] [/math].

Обновлять массив [math] ancestor [/math] будем следующим образом:

  • когда мы приходим в новую вершину [math]v[/math] мы должны добавить её в новый класс — [math]ancestor[v] = v[/math]
  • когда просмотрим всё поддерево какого-то ребёнка [math] u [/math] у вершины [math] v [/math], мы должны объединить поддерево ребёнка с классом вершины [math] v [/math] ([math]\mathrm{union}(v, u, v)[/math] — объединить классы вершин [math] v [/math] и [math] u [/math], а наименьшим общим предком представителя нового класса сделать вершину [math] v [/math]). Система непересекающихся множеств сама определит представителя в зависимости от используемой нами эвристики. Нам надо лишь правильно установить значение массива [math] ancestor [/math] у нового представителя.

После того как мы обработали всех детей вершины [math]v[/math], мы можем ответить на все запросы вида [math]\langle v, u \rangle [/math], где [math]u[/math] — уже посещённая вершина. Нетрудно заметить, что [math]lca(v, u) = ancestor[\mathrm{find}(u)][/math]. Для каждого запроса это условие (что одна вершина уже посещена, а другую мы обрабатываем) выполнится только один раз.

Реализация

bool visited[n]  

function union(x : int, y : int, newAncestor : int):
    leader = dsuUnion(x, y)         // объединяем классы вершин [math] x [/math] и [math] y [/math] и получаем нового представителя класса 
    ancestor[leader] = newAncestor  // устанавливаем нового предка представителю множества 
      
// можно запустить от любой вершины дерева.  
function dfs(v : int):
    visited[v] = true                     
    foreach u : (v, u) in G
        if not visited[u]                  
            dfs(u)
            union(v, u, v)
    foreach u : [math]\langle v, u \rangle [/math] — есть такой запрос
        if visited[u]
            запомнить, что ответ для запроса [math]\langle v, u \rangle [/math] = ancestor[find[u]]

Корректность

Случай, когда [math] u [/math] является наименьшим общим предком вершин [math] u [/math] и [math] v [/math] отработает правильно, потому что по алгоритму в этот момент [math] ancestor[\mathrm{find}(u)] = u [/math].

Предположим, что нашли предка, который не является наименьшим, тогда это нас моментально приводит к противоречию, потому что запросмы должны были рассмотреть ранее — на минимальном предке. Если он не минимальный, значит, есть на какой-то большей глубине, то есть такая вершина, которая была посещена раньше и для которой условия на [math]u[/math] и [math]v[/math] выполнялись, значит, тогда должна была найтись эта вершина в качестве [math]LCA[/math].

Оценка сложности

Она состоит из нескольких оценок.

  • Обход в глубину выполняет за [math]O(n)[/math].
  • Операции по объединению множеств, которые в сумме для всех разумных [math]n[/math] затрачивают [math]O (n)[/math] операций. Каждый запрос [math]\langle v, u \rangle [/math] будет рассмотрен дважды — при посещении вершины [math]u[/math] и [math]v[/math], но обработан лишь один раз, поэтому можно считать, что все запросы обработаются суммарно за [math]O (m)[/math].
  • Для каждого запроса проверка условия и определение результата, опять же, для всех разумных [math]n[/math] выполняется за [math]O (1)[/math].

Итоговая асимптотика получается [math]O (n + m)[/math], но при достаточно больших [math]m[/math] ответ за [math]O (1)[/math] на один запрос.

Источники информации