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

Материал из Викиконспекты
Перейти к: навигация, поиск
(Реализация: исправлена бага в псевдокоде)
(не показано 12 промежуточных версий 1 участника)
Строка 1: Строка 1:
Дано дерево и набор запросов: пары вершин <tex>\langle v, u \rangle </tex>, и для каждой пары нужно найти наименьшего общего предка. Считаем, что все запросы известны заранее, поэтому будем решать задачу оффлайн.
+
Дано [[Дерево, эквивалентные определения | дерево]] <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>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>u</tex> находится, когда мы уже посетили вершину <tex>u</tex>, а также посетили всех сыновей вершины <tex>v</tex> и собираемся выйти из неё.
  
 
Зафиксируем момент: мы собираемся выйти из вершины <tex>v</tex> (обработали всех сыновей) и хотим узнать ответ для пары <tex>\langle v</tex>, <tex>u \rangle</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>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]]
 
[[file:mytree.png|500px|разные цвета {{---}} разные классы, а белые вершины ещё не просмотренные в dfs]]
Строка 14: Строка 14:
 
Классы этих вершин не пересекаются, а значит, мы можем их эффективно обрабатывать с помощью [[СНМ (реализация с помощью леса корневых деревьев)|системы непересекающихся множеств]], которую будем хранить в массиве <tex>dsu</tex>.
 
Классы этих вершин не пересекаются, а значит, мы можем их эффективно обрабатывать с помощью [[СНМ (реализация с помощью леса корневых деревьев)|системы непересекающихся множеств]], которую будем хранить в массиве <tex>dsu</tex>.
  
Будем поддерживать также массив <tex>ancestor[1 \dots n]</tex>, где <tex> ancestor[w] </tex> {{---}} наименьший общий предок всех вершин, которые лежат в том же классе, что и <tex> w </tex>. Обновление массива <tex> ancestor </tex> для каждого элемента будет неэффективно. Поэтому зафиксируем в каждом классе какого-то представителя. Функция <tex> \mathrm{find}(w) </tex> вернёт представителя класса, в котором находится вершина <tex> w </tex>. Тогда наименьшим общим предком всех вершин из класса <tex> w </tex> будет вершина <tex> ancestor[\mathrm{find}(w)] </tex>.
+
Будем поддерживать также массив <tex>lcaClass[1 \dots n]</tex>, где <tex> lcaClass[w] </tex> {{---}} наименьший общий предок всех вершин, которые лежат в том же классе, что и <tex> w </tex>. Обновление массива <tex> lcaClass </tex> для каждого элемента будет неэффективно. Поэтому зафиксируем в каждом классе какого-то представителя. Функция <tex> \mathrm{find}(w) </tex> вернёт представителя класса, в котором находится вершина <tex> w </tex>. Тогда наименьшим общим предком всех вершин из класса <tex> w </tex> будет вершина <tex> lcaClass[\mathrm{find}(w)] </tex>.
  
Обновление массива <tex> ancestor </tex> будем производить следующим образом:
+
Обновление массива <tex> lcaClass </tex> будем производить следующим образом:
* когда мы приходим в новую вершину <tex>v</tex> мы должны добавить её в новый класс {{---}} <tex>ancestor[v] = v</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> ancestor </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> lcaClass </tex> у нового представителя.
  
 
После того как мы обработали всех детей вершины <tex>v</tex>, мы можем ответить на все запросы вида <tex>\langle v, u \rangle </tex>, где <tex>u</tex> {{---}} уже посещённая вершина.
 
После того как мы обработали всех детей вершины <tex>v</tex>, мы можем ответить на все запросы вида <tex>\langle v, u \rangle </tex>, где <tex>u</tex> {{---}} уже посещённая вершина.
Нетрудно заметить, что <tex>lca(v, u) = ancestor[\mathrm{find}(u)]</tex>. Для каждого запроса это условие (что одна вершина уже посещена, а другую мы обрабатываем) выполнится только один раз.
+
Нетрудно заметить, что <tex>lca(v, u) = lcaClass[\mathrm{find}(u)]</tex>. Для каждого запроса это условие (что одна вершина уже посещена, а другую мы обрабатываем) выполнится только один раз.
  
 
=== Реализация ===
 
=== Реализация ===
Строка 29: Строка 29:
 
  '''function''' union(x : '''int''', y : '''int''', newAncestor : '''int'''):
 
  '''function''' union(x : '''int''', y : '''int''', newAncestor : '''int'''):
 
     leader = dsuUnion(x, y)        <font color=green> // объединяем классы вершин <tex> x </tex> и <tex> y </tex> и получаем нового представителя класса </font>
 
     leader = dsuUnion(x, y)        <font color=green> // объединяем классы вершин <tex> x </tex> и <tex> y </tex> и получаем нового представителя класса </font>
     ancestor[leader] = newAncestor <font color=green> // устанавливаем нового предка представителю множества </font>
+
     lcaClass[leader] = newAncestor <font color=green> // устанавливаем нового предка представителю множества </font>
 
        
 
        
 
  <font color=green>// можно запустить от любой вершины дерева в самый первый раз</font>   
 
  <font color=green>// можно запустить от любой вершины дерева в самый первый раз</font>   
 
  '''function''' dfs(v : '''int'''):
 
  '''function''' dfs(v : '''int'''):
 
     visited[v] = ''true''
 
     visited[v] = ''true''
     ancestor[v] = v                     
+
     lcaClass[v] = v                     
 
     '''foreach''' u : (v, u) '''in''' G
 
     '''foreach''' u : (v, u) '''in''' G
 
         '''if''' '''not''' visited[u]                   
 
         '''if''' '''not''' visited[u]                   
 
             dfs(u)
 
             dfs(u)
 
             union(v, u, v)
 
             union(v, u, v)
     '''foreach''' u : <tex>\langle v, u \rangle </tex> {{---}} есть такой запрос
+
     '''for''' (u : <tex>\langle v, u \rangle </tex> {{---}} есть такой запрос)
 
         '''if''' visited[u]
 
         '''if''' visited[u]
             запомнить, что ответ для запроса <tex>\langle v, u \rangle </tex> = ancestor[find[u]]
+
             запомнить, что ответ для запроса <tex>\langle v, u \rangle </tex> = lcaClass[find[u]]
  
 
== Корректность ==
 
== Корректность ==
  
Случай, когда <tex> u </tex> является наименьшим общим предком вершин <tex> u </tex> и <tex> v </tex>, обработается правильно, потому что по алгоритму в этот момент <tex> ancestor[\mathrm{find}(u)] = u </tex>.
+
Случай, когда <tex> u </tex> является наименьшим общим предком вершин <tex> u </tex> и <tex> v </tex>, обработается правильно, потому что по алгоритму в этот момент <tex> lcaClass[\mathrm{find}(u)] = u </tex>.
  
Пусть теперь наименьшим общим предком вершин <tex> u </tex> и <tex> v </tex> будет вершина, отличная от этих двух. Во время обработки запроса алгоритм точно вернёт общего предка этих двух вершин, так как он будет предком одной из вершин по массиву <tex> ancestor </tex>, а предком другой из-за обхода в глубину.  
+
Пусть теперь наименьшим общим предком вершин <tex> u </tex> и <tex> v </tex> будет вершина, отличная от этих двух. Во время обработки запроса алгоритм точно вернёт общего предка этих двух вершин, так как он будет предком одной из вершин по массиву <tex> lcaClass </tex>, а предком другой из-за обхода в глубину.  
  
Покажем, что найдём наименьшего предка. Пусть это не так. Тогда существует какая-то вершина <tex> w </tex>, которая тоже является предком вершин <tex> u </tex> и <tex> v </tex> и из которой мы вышли позже во время обхода в глубину. Но тогда ситуация, что одна из вершин посещена, а у другой рассмотрены все дети, должна была выполниться раньше, и в качестве ответа должна была вернуться вершина <tex> w </tex>.
+
Покажем, что найдём наименьшего предка. Пусть это не так. Тогда существует какая-то вершина <tex> w </tex>, которая тоже является предком вершин <tex> u </tex> и <tex> v </tex>, и из которой мы вышли раньше во время обхода в глубину. Но тогда ситуация, что одна из вершин посещена, а у другой рассмотрены все дети, должна была выполниться раньше, и в качестве ответа должна была вернуться вершина <tex> w </tex>.
  
Заметим, что для корректности алгоритма достаточно было бы одного массива <tex> dsu </tex>, а представителем класса всегда выбирать наименьшего общего предка вершин класса. Это несложно сделать, так как мы всегда объединяем ребёнка со своим родителем. Но в таком случае алгорим получился бы менее эффективным, потому что одна только эвристика сжатия путей работает недостаточно быстро.
+
'''Замечание:''' для корректности алгоритма достаточно было бы одного массива <tex> dsu </tex>, а представителем класса всегда выбирать наименьшего общего предка вершин класса. Это несложно сделать, так как мы всегда объединяем ребёнка со своим родителем. Но в таком случае алгорим получился бы менее эффективным, потому что одна только эвристика сжатия путей работает недостаточно быстро.
  
 
== Оценка сложности ==
 
== Оценка сложности ==
Она состоит из нескольких оценок.
+
Она состоит из нескольких частей.
  
*Обход в глубину выполняет за <tex>O(n)</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 (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>n</tex> выполняется за <tex>O (1)</tex>.  
  
Итоговая асимптотика получается <tex>O (n + m)</tex>, но при достаточно больших <tex>m</tex> ответ за <tex>O (1)</tex> на один запрос.
+
Следовательно, итоговая асимптотика {{---}} <tex>O (n + m)</tex>, что при достаточно больших <tex>m</tex> составляет <tex>O (1)</tex> на один запрос.
 +
 
 +
==См. также==
 +
* [[Сведение задачи LCA к задаче RMQ]]
 +
* [[Heavy-light декомпозиция]]
  
 
== Источники информации ==
 
== Источники информации ==

Версия 10:48, 21 апреля 2018

Дано дерево [math] G [/math] и набор запросов: пары вершин [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], для которых он является ответом, в этом классе содержатся все вершины, которые находятся "слева" от этого предка.

На рисунке непосещённые вершины раскрашены в белый цвет, а посещённые разбиты на классы, каждому из которых соответствует свой цвет.

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

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

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

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

  • когда мы приходим в новую вершину [math]v[/math], мы должны добавить её в новый класс — [math]lcaClass[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] lcaClass [/math] у нового представителя.

После того как мы обработали всех детей вершины [math]v[/math], мы можем ответить на все запросы вида [math]\langle v, u \rangle [/math], где [math]u[/math] — уже посещённая вершина. Нетрудно заметить, что [math]lca(v, u) = lcaClass[\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] и получаем нового представителя класса 
    lcaClass[leader] = newAncestor  // устанавливаем нового предка представителю множества 
      
// можно запустить от любой вершины дерева в самый первый раз  
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 (u : [math]\langle v, u \rangle [/math] — есть такой запрос)
        if visited[u]
            запомнить, что ответ для запроса [math]\langle v, u \rangle [/math] = lcaClass[find[u]]

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

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

Пусть теперь наименьшим общим предком вершин [math] u [/math] и [math] v [/math] будет вершина, отличная от этих двух. Во время обработки запроса алгоритм точно вернёт общего предка этих двух вершин, так как он будет предком одной из вершин по массиву [math] lcaClass [/math], а предком другой из-за обхода в глубину.

Покажем, что найдём наименьшего предка. Пусть это не так. Тогда существует какая-то вершина [math] w [/math], которая тоже является предком вершин [math] u [/math] и [math] v [/math], и из которой мы вышли раньше во время обхода в глубину. Но тогда ситуация, что одна из вершин посещена, а у другой рассмотрены все дети, должна была выполниться раньше, и в качестве ответа должна была вернуться вершина [math] w [/math].

Замечание: для корректности алгоритма достаточно было бы одного массива [math] dsu [/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] на один запрос.

См. также

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