Heavy-light декомпозиция — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
(Препроцессинг)
(Препроцессинг)
Строка 57: Строка 57:
 
Построим декомпозицию. Для каждой вершины, помимо её предка, будем хранить дополнительно следующие значения:
 
Построим декомпозицию. Для каждой вершины, помимо её предка, будем хранить дополнительно следующие значения:
 
# Расстояние до корня дерева. <br />Вычисляется за <tex>O(1)</tex> с помощью времен входа\выхода в каждую вершину.
 
# Расстояние до корня дерева. <br />Вычисляется за <tex>O(1)</tex> с помощью времен входа\выхода в каждую вершину.
# Номер предка. <br /> Декомпозиция разбивает дерево на пути. Предком назовем ту вершину, которая является начальной в том пути, на котором лежит текущая вершина. Очевидно, что имея разбиение на пути, найти предка можно за <tex>O(1)</tex>.
+
# Номер предка. <br /> Предком назовем ту вершину, которая является начальной в том пути, на котором лежит текущая вершина. Очевидно, что имея разбиение на пути, найти предка можно за <tex>O(1)</tex>.
 
# Номер вершины, в которую выходит первое ребро пути, ведущего из предка в вершину. <br />Аналогично, находится за <tex>O(1)</tex> при построении.
 
# Номер вершины, в которую выходит первое ребро пути, ведущего из предка в вершину. <br />Аналогично, находится за <tex>O(1)</tex> при построении.
  

Версия 19:40, 8 мая 2016

Heavy-light декомпозиция — техника разбиения подвешенного дерева на множество путей для решения задач о запросах на пути в дереве (в том числе с модификациями).

Описание задачи

Задача:
Имеется подвешенное дерево [math]T[/math] c [math]n[/math] вершинами и необходимо проводить операции на нем на пути от вершины [math]v[/math] до вершины [math]u[/math].

Примеры запросов:

  • сумма на пути,
  • максимум на пути,
  • количество рёбер на пути, вес которых больше заданного [math]c[/math].

Примеры модификаций:

  • модификация одного ребра,
  • прибавление к весу всех рёбер на пути,
  • установка веса всех рёбер на пути в заданное [math]c[/math].

Множество подобных запросов делаются за время за полином от логарифма (обычно [math]O(\log^2{n})[/math]) с помощью Heavy-light декомпозиции.

Описание декомпозиции

Пример разбиения. В вершинах указан размер поддерева.

Необходимо составить такую декомпозицию дерева на множество рёберно-непересекающихся путей, что при прохождении от одной вершины до другой произойдет смена не более [math]O(\log{n})[/math] путей из декомпозиции.

Декомпозиция заключается в классификации всех рёбер дерева [math]T[/math] в 2 вида: легкие и тяжёлые. Введём функцию [math]s(v)[/math], которая будет обозначать размер поддерева вершины [math]v[/math].

Тяжёлые ребра (англ. heavy edge) — ребра [math](u, v)[/math] такие, что [math]s(v) \geqslant[/math] [math]\frac{s(u)}{2}[/math].

Лёгкие ребра (англ. light edge) — соответственно все остальные.

Очевидно, что из вершины может выходить как максимум одно тяжёлое ребро, т.к. иначе у нас есть два поддерева по как минимум [math]\frac{s(u)}{2}[/math] вершин, а также сама вершина [math]u[/math]. Итого [math]s(u) + 1[/math] вершин, тогда как у нас всего [math]s(u)[/math] вершин в поддереве.

Теперь рассмотрим вершины, из которых не ведет вниз ни одно тяжёлое ребро. Будем идти от них вверх до корня или пока не пройдем легкое ребро. Получится какое-то множество путей. Утверждается, что полученная таким образом декомпозиция будет являться искомой и корректной.

Утверждение:
Полученная декомпозиция является искомой.
[math]\triangleright[/math]

Докажем по отдельности корректность декомпозиции.

  1. Все рёбра покрыты путями.
    Есть два типа вершин: те, из которых ведёт ровно одно тяжёлое ребро и те, из которых не ведёт ни одного тяжёлого ребра. Для первого типа вершин мы дойдем до них некоторым путём через тяжёлое ребро снизу по определению выбора путей, а лёгкие рёбра ведущие из неё возьмем как последние рёбра в соответствующих путях. Для второго типа вершин мы по определению выбора путей возьмем их как начальные и пойдем вверх.
    Таким образом все рёбра будут покрыты.
  2. Все пути не пересекаются.
    Докажем от противного. Пусть мы взяли какое-то ребро дважды. Это значит, что из какой-то вершины вело более чем одно тяжёлое ребро, чего быть не могло. Получили противоречие.
  3. При прохождении пути от вершины [math]v[/math] до вершины [math]u[/math] произойдет смена не более, чем [math]O(\log{n})[/math] путей.
    Докажем эквивалентный факт, что при пути от любой вершины до корня мы сменим не более, чем [math]O(\log{n})[/math] путей. Рассмотрим лёгкое ребро. Заметим, что проход вниз по такому ребру уменьшает размер поддерева как минимум в 2 раза. Но смена пути может произойти только при переходе по лёгкому ребру. Таким образом мы сменим не более [math]O(\log{n})[/math] путей.
[math]\triangleleft[/math]


Существует вариант Heavy-light декомпозиции на вершинно-непересекающихся путях. Чтобы получить такой путь нужно всего-лишь выкинуть последнее ребро из всех путей в рёберно-непересекающейся декомпозиции. Это может быть удобно при решении задач, где веса находятся не на рёбрах, а на вершинах и соответствующие запросы также делаются на вершинах.

Применение

Сумма на пути

Классическая задача о сумме на пути в дереве с [math]n[/math] вершинами решается с помощью Heavy-light декомпозиции за время [math]O(\log^2{n})[/math]. Возможны модификации веса.

Построим дерево отрезков над каждым путём. Рассмотрим запрос [math]sum(u, v)[/math]. Найдем вершину [math]c[/math], которая является [math]LCA(u, v)[/math] (например с помощью двоичного подъема. Мы разбили запрос на два: [math](u, c)[/math] и [math](c, v)[/math], на каждый из которых можно легко ответить разбив его на множество путей из декомпозиции и ответив на каждый путь из этого множества по отдельности за [math]O(\log{n})[/math] с помощью дерева отрезков на этом пути. Всего таких путей нужно будет рассмотреть [math]O(\log{n})[/math]. Итого мы способны решить эту задачу за время [math]O(\log^2{n})[/math].

Хоть это и не самый эффективный способ для решения этой задачи, но можно заметить, что навесив дерево отрезков на каждый путь мы способны отвечать на любые операции, определяемые на множестве, на котором данная операция ассоциативна, и существует нейтральный элемент относительно этой операции, то есть на моноиде (операции, поддерживаемые деревом отрезков), такие как: сумма на пути, максимум на пути, количество рёбер на пути, удовлетворяющих какому-то свойству.

LCA

Задача о наименьшем общем предке для двух вершин в дереве с [math]n[/math] вершинами решается с помощью heavy-light декомпозиции. Воспользуемся основной идеей: декомпозиция разбивает все вершины дерева на вершинно-непересекающиеся пути так, что поднимаясь от любой вершины до корня дерева придется сменить не более [math]\log{n}[/math] различных путей.

Препроцессинг

Построим декомпозицию. Для каждой вершины, помимо её предка, будем хранить дополнительно следующие значения:

  1. Расстояние до корня дерева.
    Вычисляется за [math]O(1)[/math] с помощью времен входа\выхода в каждую вершину.
  2. Номер предка.
    Предком назовем ту вершину, которая является начальной в том пути, на котором лежит текущая вершина. Очевидно, что имея разбиение на пути, найти предка можно за [math]O(1)[/math].
  3. Номер вершины, в которую выходит первое ребро пути, ведущего из предка в вершину.
    Аналогично, находится за [math]O(1)[/math] при построении.

Вычисление LCA

Будем рекурсивно подниматься в направлении корня. Пусть на данной итерации рассматриваем вершины [math]u[/math], [math]v[/math], пусть [math]s[/math] — предок вершины [math] u[/math], а [math] t[/math] — предок вершины [math]v[/math].

Пусть вершина [math]A[/math] — первая вершина пути из [math]s[/math] в [math]u[/math], а [math]B[/math] — первая вершина пути из [math]t[/math] в [math]v[/math].

Сравним вершины [math]A[/math], [math]B[/math]:

  • [math]A[/math] = [math]B[/math].
    Или [math]u[/math] лежит на пути от корня к [math]v[/math], или наоборот. За LCA примем ту вершину, которая лежит ближе к корню.
  • [math]A[/math] [math]\not=[/math] [math]B[/math].
    Нужно приблизить одну из вершин к корню, выбрав вместо нее её предка. Приближать будем на основании того, какая из вершин останется дальше от корня, после приближения.


Очевидно, что в результате придем или в одну и ту же вершину, или одна из вершин окажется на пути от корня к другой. Тем самым мы найдем LCA.

Псевдокод

 // Находит наименьшего общего предка вершин u и v
 int lca(int u, int v):
   // Проверяем вершины, в которые идут ребра из предков.
   if (turn[u] == turn[v]):
     // Ответ найден, выберем ближайшую к корню.
     if (dist[u] < dist[v]):
       return u
     else:
       return v
   // Приблизимся к корню. Выбираем наиболее удаленную вершину.
   if (dist[last[u]] > dist[last[v]]):
     return lca(last[u], v)
   return lca(last[v], u)

Ассимптотика

  • Память: Для реализации алгоритма требуется [math]O(n)[/math] памяти.
  • Препроцессинг: Heavy-light декомпозиция строится за [math]O(n)[/math].
  • Запросы: По свойству heavy-light декомпозиции, на пути от вершины к корню мы сменим не более [math]\log n[/math] путей. Значит время выполнения запроса также [math]O(\log n)[/math].

Реализация

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

Опущены некоторые детали реализации: построение и дерево отрезков.

  • [math]\mathrm{pathPos}[/math] — функция, позволяющая найти смещение вершины в пути относительно корня пути,
  • [math]\mathrm{getValue(\mathtt{i}, \mathtt{j})}[/math] — функция, позволяющая найти вес [math]\mathtt{j}[/math]-ого ребра в [math]\mathtt{i}[/math]-ом пути.

Пример реализации запроса суммы на пути:

int query(int u, int v):
    int res = 0
    int root = корень пути, в котором находится u
    while root не является предком v // поднимаемся до тех пор, пока наш путь не содержит общего предка u и v
        segmentTree = дерево отрезков, соответствующее пути, в котором лежит u
        res += segmentTree.sum(0, pathPos(u))
        u = предок root               // вырезали нижний путь и подняли нижнюю вершину до нижней вершины следующего пути
        root = корень пути, в котором находится u
    root = корень пути, в котором находится v
    while root не является предком u // аналогично прошлому while, но с другой стороны
        segmentTree = дерево отрезков, соответствующее пути, в котором лежит v
        res += segmentTree.sum(0, pathPos(v))
        v = предок root
        root = корень пути, в котором находится v
    // последний путь (тот, что содержит общего предка) обрезан с двух сторон полученными вершинами
    segmentTree = дерево отрезков, соответствующее пути в котором лежит u
    res += segmentTree.sum(min(pathPos(u), pathPos(v)), max(pathPos(u), pathPos(v)))
    return res

См.также

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