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

Материал из Викиконспекты
Перейти к: навигация, поиск
Строка 4: Строка 4:
 
== Алгоритм ==
 
== Алгоритм ==
 
Подвесим наше дерево за любую вершину, и запустим [[Обход в глубину, цвета вершин|обход в глубину]] из её.
 
Подвесим наше дерево за любую вершину, и запустим [[Обход в глубину, цвета вершин|обход в глубину]] из её.
Ответ на каждый запрос мы найдём в течении этого <tex>dfs'a</tex>. Ответ для вершин <tex>v</tex>, <tex>u</tex> находится, когда мы уже посетили вершины <tex>u</tex>, а в <tex>v</tex> обработали всех сыновей и собираемся выйти из неё.
+
Ответ на каждый запрос мы найдём в течение поиска в глубину. Ответ для вершин <tex>v</tex>, <tex>u</tex> находится, когда мы уже посетили вершину <tex>u</tex>, а так же посетили всех сыновей вершины <tex>v</tex>, и собираемся выйти из неё.
  
Зафиксируем момент, мы собираемся выйти из вершины <tex>v</tex> (обработали всех сыновей) и хотим узнать ответ для пары <tex>v</tex>, <tex>u</tex>.
+
Зафиксируем момент: мы собираемся выйти из вершины <tex>v</tex> (обработали всех сыновей) и хотим узнать ответ для пары <tex>v</tex>, <tex>u</tex>.F
Тогда заметим что ответ {{---}} это либо вершина <tex>v</tex>, либо какой-то её предок. Значит нам нужно найти предок вершины <tex>v</tex>, который является предком вершины <tex>u</tex> с наибольшей глубиной. Заметим, что при фиксированном <tex>v</tex> каждый из предков вершины <tex>v</tex> порождает некоторый класс вершин <tex>u</tex>, для которых он является ответом (в этом классе содержатся все вершины которые находятся "слева" от этого предка).
+
Тогда заметим, что ответ {{---}} это либо вершина <tex>v</tex>, либо какой-то её предок. Значит, нам нужно найти предка вершины <tex>v</tex>, который является предком вершины <tex>u</tex> с наибольшей глубиной. Заметим, что при фиксированном <tex>v</tex> каждый из предков вершины <tex>v</tex> порождает некоторый класс вершин <tex>u</tex>, для которых он является ответом, в этом классе содержатся все вершины которые находятся "слева" от этого предка.
  
 
На рисунке разные цвета {{---}} разные классы,а белые вершины ещё не просмотренные в <tex>dfs</tex>.
 
На рисунке разные цвета {{---}} разные классы,а белые вершины ещё не просмотренные в <tex>dfs</tex>.
  
Классы этих вершин {{---}} не пересекаются, а значит мы их можем эффективно обрабатывать с помощью [[СНМ (реализация с помощью леса корневых деревьев)|dsu]].
+
Классы этих вершин не пересекаются, а значит мы их можем эффективно обрабатывать с помощью [[СНМ (реализация с помощью леса корневых деревьев)|dsu]].
  
 
Будем поддерживать массив <tex>ancestor[v]</tex> {{---}} представитель множества в котором содержится вершина <tex>v</tex>.
 
Будем поддерживать массив <tex>ancestor[v]</tex> {{---}} представитель множества в котором содержится вершина <tex>v</tex>.
Строка 17: Строка 17:
 
Когда мы приходим в новую вершину <tex>v</tex> мы должны добавить её в новый класс (<tex>ancestor[v] = v</tex>), а когда просмотрим всё поддерево какого-то ребёнка, мы должны объединить это поддерево с нашим классом (операция <tex>union</tex>), и не забыть установить представителя как вершину <tex>v</tex> (в зависимости от реализации это может быть какая-то другая вершина).
 
Когда мы приходим в новую вершину <tex>v</tex> мы должны добавить её в новый класс (<tex>ancestor[v] = v</tex>), а когда просмотрим всё поддерево какого-то ребёнка, мы должны объединить это поддерево с нашим классом (операция <tex>union</tex>), и не забыть установить представителя как вершину <tex>v</tex> (в зависимости от реализации это может быть какая-то другая вершина).
  
Зафиксируем вершины <tex>v</tex>, и выделим путь от корня до этой вершины. Теперь все рёбра "левее" этого пути уже добавлены в <tex>dsu</tex>, все рёбра правее — ещё не обработаны, а все рёбра на пути — обработаны, но в <tex>dsu</tex> ещё не добавлены, так как в <tex>dsu</tex> мы добавляем при выходе.
+
Зафиксируем вершину <tex>v</tex>, и выделим путь от корня до этой вершины. Теперь все рёбра "левее" этого пути уже добавлены в <tex>dsu</tex>, все рёбра правее — ещё не обработаны, а все рёбра на пути — обработаны, но в <tex>dsu</tex> ещё не добавлены, так как в <tex>dsu</tex> мы добавляем при выходе.
 
Тогда можно заметить, что любая вершина из обработанных в <tex>dsu</tex> цепляются к какой-то вершине текущего пути, в <tex>dfs</tex>.
 
Тогда можно заметить, что любая вершина из обработанных в <tex>dsu</tex> цепляются к какой-то вершине текущего пути, в <tex>dfs</tex>.
 
К самой первой вершине этого пути, до которой мы доберёмся, если будем просто подниматься. Очевидно, это и есть <tex>lca</tex>.
 
К самой первой вершине этого пути, до которой мы доберёмся, если будем просто подниматься. Очевидно, это и есть <tex>lca</tex>.
  
 
После того как мы обработали всех детей вершины <tex>v</tex>, мы можем ответить на все запросы вида (<tex>v</tex>,<tex>u</tex>) где <tex>u</tex> {{---}} уже посещённая вершина.
 
После того как мы обработали всех детей вершины <tex>v</tex>, мы можем ответить на все запросы вида (<tex>v</tex>,<tex>u</tex>) где <tex>u</tex> {{---}} уже посещённая вершина.
Нетрудно заметить что ответ для <tex>lca(v, u) = ancestor(find(u))</tex>.Так же можно понять что для каждого запроса это условие(что одна вершина уже посещена, а другую мы обрабатываем) выполнится только один раз.
+
Нетрудно заметить что ответ для <tex>lca(v, u) = ancestor[find(u)]</tex>.Так же можно понять что для каждого запроса это условие (что одна вершина уже посещена, а другую мы обрабатываем) выполнится только один раз.
  
  
Строка 60: Строка 60:
 
=== Оценка сложности ===
 
=== Оценка сложности ===
 
Она состоит из нескольких оценок.
 
Она состоит из нескольких оценок.
Во-первых <tex>dfs</tex> работает О (n).
+
Во-первых, обход в глубину работает <tex>О (n)</tex>.
 
Во-вторых, операции по объединению множеств, которые в сумме для всех разумных <tex>n</tex> затрачивают <tex>О (n)</tex> операций.  
 
Во-вторых, операции по объединению множеств, которые в сумме для всех разумных <tex>n</tex> затрачивают <tex>О (n)</tex> операций.  
 
В-третьих, для каждого запроса проверка условия и определение результата, опять же, для всех разумных <tex>n</tex> выполняется за <tex>О (1)</tex>. Итоговая асимптотика получается <tex>O (n + m)</tex>, но при достаточно больших <tex>m</tex> ответ за <tex>O (1)</tex> на один запрос.
 
В-третьих, для каждого запроса проверка условия и определение результата, опять же, для всех разумных <tex>n</tex> выполняется за <tex>О (1)</tex>. Итоговая асимптотика получается <tex>O (n + m)</tex>, но при достаточно больших <tex>m</tex> ответ за <tex>O (1)</tex> на один запрос.

Версия 16:39, 6 июня 2014

Алгоритм Тарьяна позволяет находить наименьшего общего предка двух вершин в дереве, если все запросы известны заранее (offline). Каждый запрос к дереву — это </tex>2</tex> вершины [math]v[/math],[math]u[/math] для которых нужно найти такую вершину [math]k[/math], что [math]k[/math]-предок вершин [math]v[/math] и [math]u[/math], и [math]k[/math] имеет максимальную глубину из всех таких вершин. Алгоритм позволяет найти ответы для дерева из n вершин и m запросов за время [math]O (n + m)[/math], т.е при достаточно большом m, за [math]O (1)[/math] на запрос.

Алгоритм

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

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

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

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

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

Зафиксируем вершину [math]v[/math], и выделим путь от корня до этой вершины. Теперь все рёбра "левее" этого пути уже добавлены в [math]dsu[/math], все рёбра правее — ещё не обработаны, а все рёбра на пути — обработаны, но в [math]dsu[/math] ещё не добавлены, так как в [math]dsu[/math] мы добавляем при выходе. Тогда можно заметить, что любая вершина из обработанных в [math]dsu[/math] цепляются к какой-то вершине текущего пути, в [math]dfs[/math]. К самой первой вершине этого пути, до которой мы доберёмся, если будем просто подниматься. Очевидно, это и есть [math]lca[/math].

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


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

Реализация

vector <bool> visited;   
vector <int> query[n]; 

int dsu_get (int v) {
       return v == dsu[v] ? v : dsu[v] = dsu_get (dsu[v]);
}            

unite (int a, int b, int new_ancestor) {
       a = dsu_get (a);
       b = dsu_get (b);
       dsu[a] = b;
       ancestor[b] = new_ancestor;
}       
  
dfs(int v) {
    visited[v] = true;                      
    for (u таких, что (v, u) — ребро в G)   
        if (not visited[u])                  
            dfs(u);
            union(v, u, v);
    for (i = 0; i < query[v].size; i++)
        if (visited[query[v][i]])
            cout << "LCA " << v << " " << u << " = " << ancestor[dsu_get(q[v][i])];
}
  
int main() {
    dfs(1); // можно запускать от любой вершины
}

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

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