Алгоритм Тарьяна поиска LCA за О(1) в оффлайне
Алгоритм Тарьяна позволяет находить наименьшего общего предка двух вершин в дереве, если все запросы известны заранее (offline). Каждый запрос к дереву - это 2 вершины , для которых нужно найти такую вершину , что -предок вершин и , и имеет максимальную глубину из всех таких вершин. Алгоритм позволяет найти ответы для дерева из n вершин и m запросов за время , т.е при достаточно большом m, за на запрос.
Алгоритм
Подвесим наше дерево за любую вершину, и запустим обход в глубину из её. Ответ на каждый запрос мы найдём в течении этого dfs'a. Ответ для вершин v,u находится, когда мы уже посетели вершины u, а в v обработали всех сыновей и собираемся выйти из неё.
Зафиксируем момент, мы собираемся выйти из вершины v (обработали всех сыновей) и хотим узнать ответ для пары v,u. Тогда заметим что ответ - это либо вершина v, либо какой-то её предок. Значит нам нужно найти предок вершины v, который является предком вершины u с наибольшей глубиной. Заметим, что при фиксированном v каждый из предков вершины v порождает некоторый класс вершин u, для которых он является ответом (в этом классе содержатся все вершины которые находятся "слева" от этого предка).
На рисунке разные цвета-разные классы,а белые вершины ещё не просмотренные в dfs.
Классы этих вершин - не пересекаются,а значит мы их можем эффективно обрабатывать с помощью dsu. Будем поддерживать массив ancestor[v] - представитель множества в котором содержится вершина v. Для каждого класса мы образуем множество, и представителя этого множества. Когда мы приходим в новую вершину v мы должны добавить её в новый класс (ancestor[v] = v),а когда просмотрим всё поддерево какого-то ребёнка, мы должны объеденить это поддерево с нашим классом (операция union), и не забыть установить представителя как вершину v (взависимости от реализации это может быть какая-то другая вершина).
Зафиксируем вершины v, и выделим путь от корня до этой вершины. Теперь все рёбра "левее" этого пути уже добавлены в dsu, все рёбра правее — ещё не обработаны, а все рёбра на пути — обработаны, но в dsu ещё не добавлены, так как в dsu мы добавляем при выходе. Тогда можно заметить, что любая вершина из обработанных в dsu цепляются к какой-то вершине текущего пути, в dfs. К самой первой вершине этого пути, до которой мы доберёмся, если будем просто подниматься. Очевидно, это и есть lca.
После того как мы обработали всех детей вершины v,мы можем ответить на все запросы вида (v,u) где u-уже посещённая вершина. Нетрудно заметить что ответ для lca(v,u) = ancestor(find(u)).Так же можно понять что для каждого запроса это условие(что одна вершина уже посещена, а другую мы обрабатываем) выполнится только один раз.
Реализация
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 (!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(0);
return 0;
}
Оценка сложности
Она состоит из нескольких оценок. Во-первых dfs работает О (n). Во-вторых, операции по объединению множеств, которые в сумме для всех разумных n затрачивают операций. В-третьих, для каждого запроса проверка условия и определение результата, опять же, для всех разумных n выполняется за . Итоговая асимптотика получается , но при достаточно больших m ответ за на один запрос.
