Алгоритм Голдберга-Тарьяна

Linking Cutting trees

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

1. Нахождение минимума на пути от вершины до корня
2. Прибавление константы на пути ото вершины до корня
3. link. Пусть есть дерево с корнем А, дерево с вершиной В. Операция позволяет "подвесить" первое дерево ко второму, т.е создать ребро из А в В.
4. cut. Для некоторой выбранной вершины обрезать ребро от нее к ее родителю, сделав ее новым корнем. При этом отрезанное поддерево отделяется и существует независимо от исходного дерева.

Пути

Научимся поддерживать эти операции для путей.

1. Нахождение минимума на пути от вершины до конца пути
2. Прибавление константы на пути ото вершины до корня
3. link. Чтобы не образовались деревья, нужно подвешивать путь строго к концу другого пути.
4. cut. По вершине обрезаем ребро. Получатся 2 независимых друг от друга пути.

первые две операции - для поиска удлиняющего пути из S в T.

Пусть нет операций link, cut. Все пути статичные, остаются 2 операции:

1. Минимум на суффиксе
2. Прибавление константы на суффиксе.

Можно использовать дерево отрезков ([math]O(\log(N))[/math])

Для cut и link можно использовать Декартовы деревья или Splay-деревья, операции также за [math]O(\log(N))[/math]. Merge = link, split = cut.

Совместим два концепта. Возьмем декартовы деревья и добавим к ним функциональность деревьев отрезков. Пусть есть массив 0..n, декартово дерево по неявному ключу для него. Давайте хранить в каждой вершине минимум в поддереве, вычисляется как минимум значений в поддеревьях и значения в вершине. Будем поддерживать при split и merge. Легко узнать минимум на суффиксе: делаем сплит по вершине, берем минимум в нем. Если не хотим портить исходное дерево, то можно либо сделать обратно merge или использовать персистентное дерево, создать новое и потом удалить, чтоб сэкономить память. Прибавление константы. Храним модификатор в вершине, который говорит что ко всем узлам в подтерев нужно прибавить константу. ЕГо можно аналогично поддерживать при split и merge. Как прибавляем на суффиксе? Делаем split по вершине, прибавляем модификатор, делаем merge.

Как только в вершине что-то поменялось связанное с детьми, то в ней сразу же пересчитывается все идентификаторы.

Научились делать делать для путей. Обе операции за log(n)

Деревья

Проблема в том, что дерево не путь и его нельзя так просто свести к структурам данных, в силу нелинейности индексов. Но можно дерево нарезать на пути. Рассмотрим корневое дерево, на котором хотим выполнять операции. Забудем про (link), (cut). Только первые 2 операции. Существует подход, который позволяет сделать за log(n)^2.

Heavy-Light Decomposition.

Рассмотрим дерево, каждое ребро объявим легким и тяжелым по следующему критерию: Пусть есть дерево, у него есть размер - количество вершин в поддереве. Среди всех поддеревьев дерева выберем самое большое по размеру и ребро из него объявим тяжелым. Если одинаковые - любое выберем. В каждую вершину кроме листа будет входить ровно одно тяжелое ребро из самого большого поддерева. Тогда несложно заметить.

Лемма. На пути от любой вершины до корня не больше log(N) легких ребер. Потому что каждый раз когда мы идем по легкому ребру, размер поддерева той вершины, в которой мы находимся, размер поддерева увеличивается хотя бы в два раза. Потому что если увеличился меньше, чем в два раза, значит здесь было больше половины потомков следующей вершины, значит это ребро было тяжелым. Значит легких ребер мало, а тяжелых много. Тяжелые ребра образуют разбиение дерева на пути. Чтобы решить наши задачи делаем так:

1. Начинаем в какой-то вершине, берем тот путь к которому она принадлежит (Тот фрагмент от вершины до конца тяжелого пути)
2. Делаем шаг по легкому пути
3. Берем снова часть тяжелого пути
4. и т.д, пока не дойдем до корня.

Тогда запрос на суффиксе пути будет за log(N). Каждый раз, когда меняем путь - проходим по легкому пути. Т.к по лемме их не больше log(N), то суммарное время запроса log(n)^2.

Если добавить link, cut, то тяжело поддерживать, какое ребро легкое какое тяжелое. Жд этого нужно аккуратно следить за деревьями. Потому что при подвешивании дерева, абсолютно любое ребро на пути от вершины до корня может стать легким или тяжелым. Это неудобно. Применим метод как в TANGO-деревьях.

Когда есть запрос для какого-то пути, мы сначала перестроим пути так, чтоб путь от вершины до корня был полностью из жирных (solid) ребер.

Алгоритм Голдберга-Таряна

Алгоритм Голдберга-Тарьяна (англ Goldberg-Tarjan) - алгоритм, решающий задачу нахождения максимального потока в транспортной сети за [math]O(VE \log(VE))[/math].

Идея

Вспомним Алгоритм Диница. Пусть есть сеть [math]G^0_f [/math] — некоторый ациклический граф, S, T — исток и сток соответственно. Схема Алгоритма Диница :

1. При помощи обхода в глубину находим путь из S в T.
2. Находим ребро с минимальной пропускной способностью
3. Вдоль пути увеличиваем поток на минимальную пропускную способность

Попытаемся ускорить процесс поиска пути из S в T. Для этого, для каждой вершины зафиксируем какое-либо, не более, чем одно, исходящее из нее ребро. Граф ацикличен, значит зафиксированные ребра будут образовывать лес корневых деревьев. Корнем каждого дерева будет вершина, у которой нет зафиксированного ребра. В каждой вершине будем дополнительно хранить остаточную пропускную способность исходящего зафиксированного ребра.

Пусть каждое дерево поддерживает следующие операции:

1. Вычислить минимум на пути от вершины до корня
2. Прибавить константу к числам на пути от вершины до корня.
3. Отрезать поддерево по ребру. Отрезанное поддерево отделяется и существует независимо от исходного дерева.
4. Подвесить дерево. Пусть есть дерево с корнем А, дерево с вершиной В. Операция позволяет Создать ребро из A в B и тем самым подвесить дерево к вершине.

Заметим, что если S, T лежат в одном дереве, то можно легко найти путь из S в T (Путь по дереву до корня), а тогда:

1. При помощи (1) запроса можно найти узкое место на этом пути и его пропускную способность.
2. При помощи (2) запроса можно вычесть из всех ребер на этом пути пропускную способность узкого места, а также, прибавить ее к потоку.

Будем отдельно хранить дерево с потоками и дерево с пропускными способностями.

Но, даже если S и T попали в одно дерево, на следующем шаге запрос минимума, очевидно, выдаст 0. Потому что на предыдущем шаге этот минимум был вычтен и при помощи текущего дерева ничего улучшить уже не удастся.

Чтобы решить эту проблему и проблему, когда S и T лежат в разных деревьях, вспомним про (3) и (4) операции и воспользуемся следующим алгоритмом:

Алгоритм

Заметим, что именно эти операции поддерживает Linking-Cutting Tree и умеет их выполнять за [math]O(\log(N))[/math]

Пусть требуется найти путь из S в T, тогда:

1. Делаем запрос (1). Получаем корень и расположение минимума до корня.
   1. Если корень — T, то делаем, как описано выше:
      1. Вычитаем значение минимума из пропускных способностей, прибавляем к потоку.
   2. Иначе
      1. Просматриваем все ненасыщенные исходящие ребра (как и в алгоритме Диница, если просматривали раньше и не подошло, то не рассматриваем больше. Т.е с глобальным итератором, начиная с последнего подошедшего)
      2. Пусть просматриваем какое-то ненасыщеюнное ребро, ведущее в некоторую вершину.
      3. Подвешиваем наше дерево к этому ребру
      4. В бывший корень записываем число, равное остаточной пропускной способности этого ребра. ( Это легко сделать при помощи выполнения (2) операции к самому корню до подвешивания. Пусть было INF, прибавим Value - INF -> PROFIT)

Далее, снова пополняем запрос из S... и ТД, пока не доберемся до T.

Хотим найти путь из S в T. Делаем (1) запрос. Получаем корень, минимум до корня, его расположение. Если корень — T, то делаем как раньше. Иначе: Просматриваем все ненасыщенные исходящие ребра (как и в алгоритме Диница, если просматривали раньше и не подошло, то не рассматриваем больше. Т.е с глобальным итератором, начиная с последнего подошедшего). Пусть просматриваем какое-то ненасыщеюнное ребро, ведущее в некоторую вершину. Подвешиваем наше дерево к этому ребру и в бывший корень записываем число, равное остаточной пропускной способности этого ребра. ( Это легко сделать при помощи выполнения (2) операции к самому корню до подвешивания. Пусть было INF, прибавим Value - INF -> PROFIT).

Далее, снова пополняем запрос из S... и ТД, пока не доберемся до T.

Добрались до T. Делаем операцию улучшения пути, появилось нулевое ребро. Обрезаем его. Продолжаем спрашивать из S. Нулевых ребер может быть несколько, значит нужно предусмотреть и для обычного шага. Если запрос из S до корня дал 0, то нужно это ребро отрезать.

Время работы

Из предположения, что есть структура данных. Просмотров ребра суммарно О(Е), аналогично алгоритму Диница. Переход к следующему, когда смотрим на ребро и оно насыщено, когда ребро разрезаем, когда смотрим на ребро и оно не лежит в сети кратчайших путей. На каждый просмотр тратится не О(1) а О(log), потому что делаем запрос перед тем как посмотреть на следующее ребро. Значит O(E log(V)).

Второй компонент в алг. Диница - сумма длин путей. Была V^2. Почему столько? На каждый путь DFS тратил время, пропорциональное длине этого пути. Но теперь не тратим. Тратим log на каждый путь. Потому что если мы нашли путь, это соответствует тому, что мы дошли до него, т.е одному запросу. Поэтому тратим на каждый путь тоже логарифм. Значит O(E log(V) + V log(V)).