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

Материал из Викиконспекты
Перейти к: навигация, поиск
Строка 62: Строка 62:
 
Каждый запрос <tex>\langle v, u \rangle </tex> будет рассмотрен дважды {{---}} при посещение вершины <tex>u</tex> и <tex>v</tex>, но обработан лишь один раз, поэтому можно считать, что все запросы обработаются суммарно за <tex>O (m)</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> на один запрос.
+
В-третьих, для каждого запроса проверка условия и определение результата, опять же, для всех разумных <tex>n</tex> выполняется за <tex>O (1)</tex>.  
 +
 
 +
Итоговая асимптотика получается <tex>O (n + m)</tex>, но при достаточно больших <tex>m</tex> ответ за <tex>O (1)</tex> на один запрос.
  
 
== Источники информации ==
 
== Источники информации ==

Версия 01:54, 8 июня 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].

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

Будем поддерживать массив [math]ancestor[1 \dots n][/math] — представитель множества в котором содержится вершина [math]v[/math]. Для каждого класса мы образуем множество и представителя этого множества. Когда, мы приходим в новую вершину [math]v[/math] мы должны добавить её в новый класс ([math]ancestor[v] = v[/math]), а когда просмотрим всё поддерево какого-то ребёнка, мы должны объединить это поддерево с нашим классом (операция [math]union[/math]) и не забыть установить представителя как вершину [math]v[/math].

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

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

разные цвета — разные классы, а белые вершины ещё не просмотренные в 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 : int, b : int, newAncestor : int):
       a = dsuGet(a)
       b = dsuGet(b)
       dsu[a] = b
       ancestor[b] = newAncestor
      
// можно запустить от любой вершины дерева.  
function dfs(v : int):
    visited[v] = true                     
    foreach u : (v, u) in G
        if not visited[u]                  
            dfs(u)
            union(v, u, v)
    for i = 0 to query[v].size - 1
        if visited[query[v][i]]
            запомнить, что ответ для запроса [math]\langle v, u \rangle [/math] = ancestor[dsuGet[q[v][i]]]

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

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

Во-первых, обход в глубину выполняет за [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] на один запрос.

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