Алговики - Вклад [ru]

Участник:Anastasy/Алгоритм Диница

2017-11-30T09:12:45Z

Anastasy: /* Масштабируемость алгоритма и его реализации */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref name="Dinic">Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(n^2m)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>.
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.
* Можно показать, что после каждой итерации расстояние между стоком и истоком строго увеличивается<ref name="Dinic"/> (то есть <math>{\rm level'}[t] > {\rm level}[t]</math>, где <math>{\rm level'}[t]</math> — расстояние до стока, полученное на следующей итерации). Так как длина кратчайшего <math>s-t</math> пути не может превосходить <math>n - 1</math>, то и количество фаз алгоритма не превосходит <math>n - 1</math>. Таким образом, весь алгоритм Диница выполняется за <math>O(n^2m)</math>.

=== Информационный граф ===
<div><ul>
<li style="display: inline-block;"> [[File:dinic.png|thumb|none|500px|Рисунок 1. Информационный граф алгоритма Диница]] </li>
<li style="display: inline-block;"> [[File:bfs.png|thumb|none|650px|Рисунок 2. Информационный граф поиска в ширину]] </li>
</ul></div>
Для алгоритма Диница:
# Инициализация переменных
# Вызов функции поиска в ширину
# (3.1 - 3.k) выполнение функции поиска в глубину, итеративно увеличивается поток
# Вызов функции поиска в ширину. В случае существования пути до стока, переход на следующую итерацию (начиная с поиска в глубину), иначе вывод вычисленной величины потока.
Для поиска в ширину
# Инициализация расстояния до истока (<math>d[s] = 0</math>) и текущего уровня нулю (<math>level = 0</math>).
# Извлечение очередной вершины из множества вершин, соответствующего процессу (<math>v \in V_{node}</math>). Вершина обрабатывается, если расстояние до нее равно текущему уровню (<math>d[v] == level </math>)
# Обход соседей вершин. В случае если вершина <math>u </math> принадлежит <math>V_{node}</math>, значение пути до этой вершины инициализируется <math>d[u] = level + 1</math>. Иначе она помечается для дальнейшей обработки другим процессом.
# Слияние информации по помеченным вершинам (в общем массиве помечаются все вершины, которые были помечены хотя бы один раз)
# Для всех помеченных необработанных (<math>d[v] == -1 </math>) вершин, принадлежащих <math>V_{node}</math>, расстояние принимается равным <math>level + 1</math>
# Если было обновлено расстояние хотя бы до одной вершины, переход на следующую итерацию, иначе выход из цикла

=== Ресурс параллелизма алгоритма ===
В приведенном варианте алгоритма поиска в ширину граф обходится по слоям, то есть на каждой итерации обрабатывается множество вершин, расстояние до которых одинаково. Число слоев не превосходит <math>n - 1</math>, таким образом, высота ярусно-параллельной формы алгоритма поиска в ширину равна <math>O(n)</math>.

Так как поиск блокирующего потока производится последовательно, его высота ярусно-параллельной формы алгоритма совпадает с его последовательной сложностью <math>O(nm)</math>.

Так как число шагов алгоритма не превосходит <math>n</math>, высота ЯПФ алгоритма Диница равна <math>O(n^2m)</math>.

В описанном алгоритме поиска в ширину вершины разделяются между процессами поровну, поэтому ширина ЯПФ поиска в ширину и алгоритма Диница равна <math>n</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': Граф <math>G(V, E)</math>. <math>n</math> вершин <math>v_i</math> и <math>m</math> ребер <math>e_j = (v_j^{(1)}, v_j^{(2)}) </math> с заданной пропускной способностью <math>c_j</math>, а также исток <math>s</math> и сток <math>t</math>.

'''Объем входных данных''': <math>O(m + n)</math>.

'''Выходные данные''': величина максимального потока.

'''Объем выходных данных''': <math>O(1)</math>.

=== Свойства алгоритма ===
В зависимости от порядка обработки ребер графа, вычисленные блокирующие потоки на соответствующих итерациях могут быть различны, кроме того, может поменяться количество итераций алгоритма Диница.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
Набор и границы значений изменяемых параметров запуска реализации алгоритма:

* число процессоров <math>[2^k, k = 0, 1, ...7]</math>;
* число вершин графа [5 000:20 000] с шагом 5000. Количество ребер одинаково для всех графов и равно 2 500 000.
На графике, приведенном ниже, показана зависимость производительности (количество обработанных ребер в единицу времени) от количества процессов и количества вершин графа. Время алгоритма сильно зависит от структуры графа (она влияет на количество итераций алгоритма Диница), поэтому время выполнения алгоритма в общем случае не пропорционально размеру графа.

График зависимости ускорения от количества процессов и количества вершин графа (рис. 4) более нагляден, так как количество итераций в алгоритме не зависит от количества процессов и время выполнения пропорционально числу итераций. По этому графику видно, что ускорение падает с увеличением размера графа.
<div><ul>
<li style="display: inline-block;"> [[File:Dinic scalability.png|thumb|none|600px|Рисунок 3. График зависимости производительности от количества процессов и количества вершин графа]] </li>
<li style="display: inline-block;"> [[File:speedup_dinic.png|thumb|none|600px|Рисунок 3. График зависимости производительности от количества процессов и количества вершин графа]] </li>
</ul></div>

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
* Python: [https://networkx.github.io NetworkX] (функция <code>[https://networkx.github.io/documentation/stable/reference/algorithms/generated/networkx.algorithms.flow.dinitz.html dinitz]</code>): алгоритм Диница

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-30T09:10:13Z

Anastasy: /* Масштабируемость алгоритма и его реализации */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref name="Dinic">Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(n^2m)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>.
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.
* Можно показать, что после каждой итерации расстояние между стоком и истоком строго увеличивается<ref name="Dinic"/> (то есть <math>{\rm level'}[t] > {\rm level}[t]</math>, где <math>{\rm level'}[t]</math> — расстояние до стока, полученное на следующей итерации). Так как длина кратчайшего <math>s-t</math> пути не может превосходить <math>n - 1</math>, то и количество фаз алгоритма не превосходит <math>n - 1</math>. Таким образом, весь алгоритм Диница выполняется за <math>O(n^2m)</math>.

=== Информационный граф ===
<div><ul>
<li style="display: inline-block;"> [[File:dinic.png|thumb|none|500px|Рисунок 1. Информационный граф алгоритма Диница]] </li>
<li style="display: inline-block;"> [[File:bfs.png|thumb|none|650px|Рисунок 2. Информационный граф поиска в ширину]] </li>
</ul></div>
Для алгоритма Диница:
# Инициализация переменных
# Вызов функции поиска в ширину
# (3.1 - 3.k) выполнение функции поиска в глубину, итеративно увеличивается поток
# Вызов функции поиска в ширину. В случае существования пути до стока, переход на следующую итерацию (начиная с поиска в глубину), иначе вывод вычисленной величины потока.
Для поиска в ширину
# Инициализация расстояния до истока (<math>d[s] = 0</math>) и текущего уровня нулю (<math>level = 0</math>).
# Извлечение очередной вершины из множества вершин, соответствующего процессу (<math>v \in V_{node}</math>). Вершина обрабатывается, если расстояние до нее равно текущему уровню (<math>d[v] == level </math>)
# Обход соседей вершин. В случае если вершина <math>u </math> принадлежит <math>V_{node}</math>, значение пути до этой вершины инициализируется <math>d[u] = level + 1</math>. Иначе она помечается для дальнейшей обработки другим процессом.
# Слияние информации по помеченным вершинам (в общем массиве помечаются все вершины, которые были помечены хотя бы один раз)
# Для всех помеченных необработанных (<math>d[v] == -1 </math>) вершин, принадлежащих <math>V_{node}</math>, расстояние принимается равным <math>level + 1</math>
# Если было обновлено расстояние хотя бы до одной вершины, переход на следующую итерацию, иначе выход из цикла

=== Ресурс параллелизма алгоритма ===
В приведенном варианте алгоритма поиска в ширину граф обходится по слоям, то есть на каждой итерации обрабатывается множество вершин, расстояние до которых одинаково. Число слоев не превосходит <math>n - 1</math>, таким образом, высота ярусно-параллельной формы алгоритма поиска в ширину равна <math>O(n)</math>.

Так как поиск блокирующего потока производится последовательно, его высота ярусно-параллельной формы алгоритма совпадает с его последовательной сложностью <math>O(nm)</math>.

Так как число шагов алгоритма не превосходит <math>n</math>, высота ЯПФ алгоритма Диница равна <math>O(n^2m)</math>.

В описанном алгоритме поиска в ширину вершины разделяются между процессами поровну, поэтому ширина ЯПФ поиска в ширину и алгоритма Диница равна <math>n</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': Граф <math>G(V, E)</math>. <math>n</math> вершин <math>v_i</math> и <math>m</math> ребер <math>e_j = (v_j^{(1)}, v_j^{(2)}) </math> с заданной пропускной способностью <math>c_j</math>, а также исток <math>s</math> и сток <math>t</math>.

'''Объем входных данных''': <math>O(m + n)</math>.

'''Выходные данные''': величина максимального потока.

'''Объем выходных данных''': <math>O(1)</math>.

=== Свойства алгоритма ===
В зависимости от порядка обработки ребер графа, вычисленные блокирующие потоки на соответствующих итерациях могут быть различны, кроме того, может поменяться количество итераций алгоритма Диница.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
Набор и границы значений изменяемых параметров запуска реализации алгоритма:

* число процессоров <math>[2^k, k = 0, 1, ...7]</math>;
* число вершин графа [5 000:20 000] с шагом 5000. Количество ребер одинаково для всех графов и равно 2 500 000.
На графике, приведенном ниже, показана зависимость производительности (количество обработанных ребер в единицу времени) от количества процессов и количества вершин графа. Время алгоритма сильно зависит от структуры графа (она влияет на количество итераций алгоритма Диница), поэтому время выполнения алгоритма в общем случае не пропорционально размеру графа.

График зависимости ускорения от количества процессов и количества вершин графа (рис. 4) более нагляден, так как количество итераций в алгоритме не зависит от количества процессов и время выполнения пропорционально числу итераций. По этому графику видно, что ускорение падает с увеличением размера графа.
<div><ul>
<li style="display: inline-block;"> [[File:Dinic scalability.png|thumb|none|600px|Рисунок 3. График зависимости производительности от количества процессов и количества вершин графа]] </li>
</ul></div>

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
* Python: [https://networkx.github.io NetworkX] (функция <code>[https://networkx.github.io/documentation/stable/reference/algorithms/generated/networkx.algorithms.flow.dinitz.html dinitz]</code>): алгоритм Диница

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-30T08:44:46Z

Anastasy: /* Масштабируемость алгоритма и его реализации */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref name="Dinic">Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(n^2m)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>.
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.
* Можно показать, что после каждой итерации расстояние между стоком и истоком строго увеличивается<ref name="Dinic"/> (то есть <math>{\rm level'}[t] > {\rm level}[t]</math>, где <math>{\rm level'}[t]</math> — расстояние до стока, полученное на следующей итерации). Так как длина кратчайшего <math>s-t</math> пути не может превосходить <math>n - 1</math>, то и количество фаз алгоритма не превосходит <math>n - 1</math>. Таким образом, весь алгоритм Диница выполняется за <math>O(n^2m)</math>.

=== Информационный граф ===
<div><ul>
<li style="display: inline-block;"> [[File:dinic.png|thumb|none|500px|Рисунок 1. Информационный граф алгоритма Диница]] </li>
<li style="display: inline-block;"> [[File:bfs.png|thumb|none|650px|Рисунок 2. Информационный граф поиска в ширину]] </li>
</ul></div>
Для алгоритма Диница:
# Инициализация переменных
# Вызов функции поиска в ширину
# (3.1 - 3.k) выполнение функции поиска в глубину, итеративно увеличивается поток
# Вызов функции поиска в ширину. В случае существования пути до стока, переход на следующую итерацию (начиная с поиска в глубину), иначе вывод вычисленной величины потока.
Для поиска в ширину
# Инициализация расстояния до истока (<math>d[s] = 0</math>) и текущего уровня нулю (<math>level = 0</math>).
# Извлечение очередной вершины из множества вершин, соответствующего процессу (<math>v \in V_{node}</math>). Вершина обрабатывается, если расстояние до нее равно текущему уровню (<math>d[v] == level </math>)
# Обход соседей вершин. В случае если вершина <math>u </math> принадлежит <math>V_{node}</math>, значение пути до этой вершины инициализируется <math>d[u] = level + 1</math>. Иначе она помечается для дальнейшей обработки другим процессом.
# Слияние информации по помеченным вершинам (в общем массиве помечаются все вершины, которые были помечены хотя бы один раз)
# Для всех помеченных необработанных (<math>d[v] == -1 </math>) вершин, принадлежащих <math>V_{node}</math>, расстояние принимается равным <math>level + 1</math>
# Если было обновлено расстояние хотя бы до одной вершины, переход на следующую итерацию, иначе выход из цикла

=== Ресурс параллелизма алгоритма ===
В приведенном варианте алгоритма поиска в ширину граф обходится по слоям, то есть на каждой итерации обрабатывается множество вершин, расстояние до которых одинаково. Число слоев не превосходит <math>n - 1</math>, таким образом, высота ярусно-параллельной формы алгоритма поиска в ширину равна <math>O(n)</math>.

Так как поиск блокирующего потока производится последовательно, его высота ярусно-параллельной формы алгоритма совпадает с его последовательной сложностью <math>O(nm)</math>.

Так как число шагов алгоритма не превосходит <math>n</math>, высота ЯПФ алгоритма Диница равна <math>O(n^2m)</math>.

В описанном алгоритме поиска в ширину вершины разделяются между процессами поровну, поэтому ширина ЯПФ поиска в ширину и алгоритма Диница равна <math>n</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': Граф <math>G(V, E)</math>. <math>n</math> вершин <math>v_i</math> и <math>m</math> ребер <math>e_j = (v_j^{(1)}, v_j^{(2)}) </math> с заданной пропускной способностью <math>c_j</math>, а также исток <math>s</math> и сток <math>t</math>.

'''Объем входных данных''': <math>O(m + n)</math>.

'''Выходные данные''': величина максимального потока.

'''Объем выходных данных''': <math>O(1)</math>.

=== Свойства алгоритма ===
В зависимости от порядка обработки ребер графа, вычисленные блокирующие потоки на соответствующих итерациях могут быть различны, кроме того, может поменяться количество итераций алгоритма Диница.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
Набор и границы значений изменяемых параметров запуска реализации алгоритма:

* число процессоров <math>[2^k, k = 0, 1, ...7]</math>;
* число вершин графа [5 000:20 000] с шагом 5000. Количество ребер одинаково для всех графов и равно 2 500 000.
На графике, приведенном ниже, показана зависимость производительности (количество обработанных ребер в единицу времени) от количества процессов и количества вершин графа. Время алгоритма сильно зависит от структуры графа (она влияет на количество итераций алгоритма Диница), поэтому время выполнения алгоритма в общем случае не пропорционально размеру графа.

Для большей наглядности на рисунке 4 приведен график зависимости ускорения от количества процессов и количества вершин графа. Так как
<div><ul>
<li style="display: inline-block;"> [[File:Dinic scalability.png|thumb|none|600px|Рисунок 3. График зависимости производительности от количества процессов и количества вершин графа]] </li>
</ul></div>

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
* Python: [https://networkx.github.io NetworkX] (функция <code>[https://networkx.github.io/documentation/stable/reference/algorithms/generated/networkx.algorithms.flow.dinitz.html dinitz]</code>): алгоритм Диница

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-29T18:52:34Z

Anastasy: /* Существующие реализации алгоритма */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref name="Dinic">Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(n^2m)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>.
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.
* Можно показать, что после каждой итерации расстояние между стоком и истоком строго увеличивается<ref name="Dinic"/> (то есть <math>{\rm level'}[t] > {\rm level}[t]</math>, где <math>{\rm level'}[t]</math> — расстояние до стока, полученное на следующей итерации). Так как длина кратчайшего <math>s-t</math> пути не может превосходить <math>n - 1</math>, то и количество фаз алгоритма не превосходит <math>n - 1</math>. Таким образом, весь алгоритм Диница выполняется за <math>O(n^2m)</math>.

=== Информационный граф ===
<div><ul>
<li style="display: inline-block;"> [[File:dinic.png|thumb|none|500px|Рисунок 1. Информационный граф алгоритма Диница]] </li>
<li style="display: inline-block;"> [[File:bfs.png|thumb|none|650px|Рисунок 2. Информационный граф поиска в ширину]] </li>
</ul></div>
Для алгоритма Диница:
# Инициализация переменных
# Вызов функции поиска в ширину
# (3.1 - 3.k) выполнение функции поиска в глубину, итеративно увеличивается поток
# Вызов функции поиска в ширину. В случае существования пути до стока, переход на следующую итерацию (начиная с поиска в глубину), иначе вывод вычисленной величины потока.
Для поиска в ширину
# Инициализация расстояния до истока (<math>d[s] = 0</math>) и текущего уровня нулю (<math>level = 0</math>).
# Извлечение очередной вершины из множества вершин, соответствующего процессу (<math>v \in V_{node}</math>). Вершина обрабатывается, если расстояние до нее равно текущему уровню (<math>d[v] == level </math>)
# Обход соседей вершин. В случае если вершина <math>u </math> принадлежит <math>V_{node}</math>, значение пути до этой вершины инициализируется <math>d[u] = level + 1</math>. Иначе она помечается для дальнейшей обработки другим процессом.
# Слияние информации по помеченным вершинам (в общем массиве помечаются все вершины, которые были помечены хотя бы один раз)
# Для всех помеченных необработанных (<math>d[v] == -1 </math>) вершин, принадлежащих <math>V_{node}</math>, расстояние принимается равным <math>level + 1</math>
# Если было обновлено расстояние хотя бы до одной вершины, переход на следующую итерацию, иначе выход из цикла

=== Ресурс параллелизма алгоритма ===
В приведенном варианте алгоритма поиска в ширину граф обходится по слоям, то есть на каждой итерации обрабатывается множество вершин, расстояние до которых одинаково. Число слоев не превосходит <math>n - 1</math>, таким образом, высота ярусно-параллельной формы алгоритма поиска в ширину равна <math>O(n)</math>.

Так как поиск блокирующего потока производится последовательно, его высота ярусно-параллельной формы алгоритма совпадает с его последовательной сложностью <math>O(nm)</math>.

Так как число шагов алгоритма не превосходит <math>n</math>, высота ЯПФ алгоритма Диница равна <math>O(n^2m)</math>.

В описанном алгоритме поиска в ширину вершины разделяются между процессами поровну, поэтому ширина ЯПФ поиска в ширину и алгоритма Диница равна <math>n</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': Граф <math>G(V, E)</math>. <math>n</math> вершин <math>v_i</math> и <math>m</math> ребер <math>e_j = (v_j^{(1)}, v_j^{(2)}) </math> с заданной пропускной способностью <math>c_j</math>, а также исток <math>s</math> и сток <math>t</math>.

'''Объем входных данных''': <math>O(m + n)</math>.

'''Выходные данные''': величина максимального потока.

'''Объем выходных данных''': <math>O(1)</math>.

=== Свойства алгоритма ===
В зависимости от порядка обработки ребер графа, вычисленные блокирующие потоки на соответствующих итерациях могут быть различны, кроме того, может поменяться количество итераций алгоритма Диница.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
Набор и границы значений изменяемых параметров запуска реализации алгоритма:

* число процессоров <math>[2^k, k = 0, 1, ...7]</math>;
* число вершин графа [5 000:20 000] с шагом 5000. Количество ребер одинаково для всех графов и равно 2 500 000.
На графике, приведенном ниже, показана зависимость производительности (количество обработанных ребер в единицу времени) от количества процессов и количества вершин графа. Время алгоритма сильно зависит от структуры графа (она влияет на количество итераций алгоритма Диница), поэтому время выполнения алгоритма в общем случае не пропорционально размеру графа.

[[File:Dinic scalability.png|600px]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
* Python: [https://networkx.github.io NetworkX] (функция <code>[https://networkx.github.io/documentation/stable/reference/algorithms/generated/networkx.algorithms.flow.dinitz.html dinitz]</code>): алгоритм Диница

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-29T18:00:16Z

Anastasy: /* Информационный граф */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref name="Dinic">Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(n^2m)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>.
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.
* Можно показать, что после каждой итерации расстояние между стоком и истоком строго увеличивается<ref name="Dinic"/> (то есть <math>{\rm level'}[t] > {\rm level}[t]</math>, где <math>{\rm level'}[t]</math> — расстояние до стока, полученное на следующей итерации). Так как длина кратчайшего <math>s-t</math> пути не может превосходить <math>n - 1</math>, то и количество фаз алгоритма не превосходит <math>n - 1</math>. Таким образом, весь алгоритм Диница выполняется за <math>O(n^2m)</math>.

=== Информационный граф ===
<div><ul>
<li style="display: inline-block;"> [[File:dinic.png|thumb|none|500px|Рисунок 1. Информационный граф алгоритма Диница]] </li>
<li style="display: inline-block;"> [[File:bfs.png|thumb|none|650px|Рисунок 2. Информационный граф поиска в ширину]] </li>
</ul></div>
Для алгоритма Диница:
# Инициализация переменных
# Вызов функции поиска в ширину
# (3.1 - 3.k) выполнение функции поиска в глубину, итеративно увеличивается поток
# Вызов функции поиска в ширину. В случае существования пути до стока, переход на следующую итерацию (начиная с поиска в глубину), иначе вывод вычисленной величины потока.
Для поиска в ширину
# Инициализация расстояния до истока (<math>d[s] = 0</math>) и текущего уровня нулю (<math>level = 0</math>).
# Извлечение очередной вершины из множества вершин, соответствующего процессу (<math>v \in V_{node}</math>). Вершина обрабатывается, если расстояние до нее равно текущему уровню (<math>d[v] == level </math>)
# Обход соседей вершин. В случае если вершина <math>u </math> принадлежит <math>V_{node}</math>, значение пути до этой вершины инициализируется <math>d[u] = level + 1</math>. Иначе она помечается для дальнейшей обработки другим процессом.
# Слияние информации по помеченным вершинам (в общем массиве помечаются все вершины, которые были помечены хотя бы один раз)
# Для всех помеченных необработанных (<math>d[v] == -1 </math>) вершин, принадлежащих <math>V_{node}</math>, расстояние принимается равным <math>level + 1</math>
# Если было обновлено расстояние хотя бы до одной вершины, переход на следующую итерацию, иначе выход из цикла

=== Ресурс параллелизма алгоритма ===
В приведенном варианте алгоритма поиска в ширину граф обходится по слоям, то есть на каждой итерации обрабатывается множество вершин, расстояние до которых одинаково. Число слоев не превосходит <math>n - 1</math>, таким образом, высота ярусно-параллельной формы алгоритма поиска в ширину равна <math>O(n)</math>.

Так как поиск блокирующего потока производится последовательно, его высота ярусно-параллельной формы алгоритма совпадает с его последовательной сложностью <math>O(nm)</math>.

Так как число шагов алгоритма не превосходит <math>n</math>, высота ЯПФ алгоритма Диница равна <math>O(n^2m)</math>.

В описанном алгоритме поиска в ширину вершины разделяются между процессами поровну, поэтому ширина ЯПФ поиска в ширину и алгоритма Диница равна <math>n</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': Граф <math>G(V, E)</math>. <math>n</math> вершин <math>v_i</math> и <math>m</math> ребер <math>e_j = (v_j^{(1)}, v_j^{(2)}) </math> с заданной пропускной способностью <math>c_j</math>, а также исток <math>s</math> и сток <math>t</math>.

'''Объем входных данных''': <math>O(m + n)</math>.

'''Выходные данные''': величина максимального потока.

'''Объем выходных данных''': <math>O(1)</math>.

=== Свойства алгоритма ===
В зависимости от порядка обработки ребер графа, вычисленные блокирующие потоки на соответствующих итерациях могут быть различны, кроме того, может поменяться количество итераций алгоритма Диница.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
Набор и границы значений изменяемых параметров запуска реализации алгоритма:

* число процессоров <math>[2^k, k = 0, 1, ...7]</math>;
* число вершин графа [5 000:20 000] с шагом 5000. Количество ребер одинаково для всех графов и равно 2 500 000.
На графике, приведенном ниже, показана зависимость производительности (количество обработанных ребер в единицу времени) от количества процессов и количества вершин графа. Время алгоритма сильно зависит от структуры графа (она влияет на количество итераций алгоритма Диница), поэтому время выполнения алгоритма в общем случае не пропорционально размеру графа.

[[File:Dinic scalability.png|600px]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-29T17:59:22Z

Anastasy: /* Масштабируемость алгоритма и его реализации */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref name="Dinic">Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(n^2m)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>.
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.
* Можно показать, что после каждой итерации расстояние между стоком и истоком строго увеличивается<ref name="Dinic"/> (то есть <math>{\rm level'}[t] > {\rm level}[t]</math>, где <math>{\rm level'}[t]</math> — расстояние до стока, полученное на следующей итерации). Так как длина кратчайшего <math>s-t</math> пути не может превосходить <math>n - 1</math>, то и количество фаз алгоритма не превосходит <math>n - 1</math>. Таким образом, весь алгоритм Диница выполняется за <math>O(n^2m)</math>.

=== Информационный граф ===
<div><ul>
<li style="display: inline-block;"> [[File:dinic.png|thumb|none|500px|Информационный граф алгоритма Диница]] </li>
<li style="display: inline-block;"> [[File:bfs.png|thumb|none|650px|Информационный граф поиска в ширину]] </li>
</ul></div>
Для алгоритма Диница:
# Инициализация переменных
# Вызов функции поиска в ширину
# (3.1 - 3.k) выполнение функции поиска в глубину, итеративно увеличивается поток
# Вызов функции поиска в ширину. В случае существования пути до стока, переход на следующую итерацию (начиная с поиска в глубину), иначе вывод вычисленной величины потока.
Для поиска в ширину
# Инициализация расстояния до истока (<math>d[s] = 0</math>) и текущего уровня нулю (<math>level = 0</math>).
# Извлечение очередной вершины из множества вершин, соответствующего процессу (<math>v \in V_{node}</math>). Вершина обрабатывается, если расстояние до нее равно текущему уровню (<math>d[v] == level </math>)
# Обход соседей вершин. В случае если вершина <math>u </math> принадлежит <math>V_{node}</math>, значение пути до этой вершины инициализируется <math>d[u] = level + 1</math>. Иначе она помечается для дальнейшей обработки другим процессом.
# Слияние информации по помеченным вершинам (в общем массиве помечаются все вершины, которые были помечены хотя бы один раз)
# Для всех помеченных необработанных (<math>d[v] == -1 </math>) вершин, принадлежащих <math>V_{node}</math>, расстояние принимается равным <math>level + 1</math>
# Если было обновлено расстояние хотя бы до одной вершины, переход на следующую итерацию, иначе выход из цикла

=== Ресурс параллелизма алгоритма ===
В приведенном варианте алгоритма поиска в ширину граф обходится по слоям, то есть на каждой итерации обрабатывается множество вершин, расстояние до которых одинаково. Число слоев не превосходит <math>n - 1</math>, таким образом, высота ярусно-параллельной формы алгоритма поиска в ширину равна <math>O(n)</math>.

Так как поиск блокирующего потока производится последовательно, его высота ярусно-параллельной формы алгоритма совпадает с его последовательной сложностью <math>O(nm)</math>.

Так как число шагов алгоритма не превосходит <math>n</math>, высота ЯПФ алгоритма Диница равна <math>O(n^2m)</math>.

В описанном алгоритме поиска в ширину вершины разделяются между процессами поровну, поэтому ширина ЯПФ поиска в ширину и алгоритма Диница равна <math>n</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': Граф <math>G(V, E)</math>. <math>n</math> вершин <math>v_i</math> и <math>m</math> ребер <math>e_j = (v_j^{(1)}, v_j^{(2)}) </math> с заданной пропускной способностью <math>c_j</math>, а также исток <math>s</math> и сток <math>t</math>.

'''Объем входных данных''': <math>O(m + n)</math>.

'''Выходные данные''': величина максимального потока.

'''Объем выходных данных''': <math>O(1)</math>.

=== Свойства алгоритма ===
В зависимости от порядка обработки ребер графа, вычисленные блокирующие потоки на соответствующих итерациях могут быть различны, кроме того, может поменяться количество итераций алгоритма Диница.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
Набор и границы значений изменяемых параметров запуска реализации алгоритма:

* число процессоров <math>[2^k, k = 0, 1, ...7]</math>;
* число вершин графа [5 000:20 000] с шагом 5000. Количество ребер одинаково для всех графов и равно 2 500 000.
На графике, приведенном ниже, показана зависимость производительности (количество обработанных ребер в единицу времени) от количества процессов и количества вершин графа. Время алгоритма сильно зависит от структуры графа (она влияет на количество итераций алгоритма Диница), поэтому время выполнения алгоритма в общем случае не пропорционально размеру графа.

[[File:Dinic scalability.png|600px]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-29T16:09:24Z

Anastasy: /* Общее описание алгоритма */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref name="Dinic">Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(n^2m)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>.
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.
* Можно показать, что после каждой итерации расстояние между стоком и истоком строго увеличивается<ref name="Dinic"/> (то есть <math>{\rm level'}[t] > {\rm level}[t]</math>, где <math>{\rm level'}[t]</math> — расстояние до стока, полученное на следующей итерации). Так как длина кратчайшего <math>s-t</math> пути не может превосходить <math>n - 1</math>, то и количество фаз алгоритма не превосходит <math>n - 1</math>. Таким образом, весь алгоритм Диница выполняется за <math>O(n^2m)</math>.

=== Информационный граф ===
<div><ul>
<li style="display: inline-block;"> [[File:dinic.png|thumb|none|500px|Информационный граф алгоритма Диница]] </li>
<li style="display: inline-block;"> [[File:bfs.png|thumb|none|650px|Информационный граф поиска в ширину]] </li>
</ul></div>
Для алгоритма Диница:
# Инициализация переменных
# Вызов функции поиска в ширину
# (3.1 - 3.k) выполнение функции поиска в глубину, итеративно увеличивается поток
# Вызов функции поиска в ширину. В случае существования пути до стока, переход на следующую итерацию (начиная с поиска в глубину), иначе вывод вычисленной величины потока.
Для поиска в ширину
# Инициализация расстояния до истока (<math>d[s] = 0</math>) и текущего уровня нулю (<math>level = 0</math>).
# Извлечение очередной вершины из множества вершин, соответствующего процессу (<math>v \in V_{node}</math>). Вершина обрабатывается, если расстояние до нее равно текущему уровню (<math>d[v] == level </math>)
# Обход соседей вершин. В случае если вершина <math>u </math> принадлежит <math>V_{node}</math>, значение пути до этой вершины инициализируется <math>d[u] = level + 1</math>. Иначе она помечается для дальнейшей обработки другим процессом.
# Слияние информации по помеченным вершинам (в общем массиве помечаются все вершины, которые были помечены хотя бы один раз)
# Для всех помеченных необработанных (<math>d[v] == -1 </math>) вершин, принадлежащих <math>V_{node}</math>, расстояние принимается равным <math>level + 1</math>
# Если было обновлено расстояние хотя бы до одной вершины, переход на следующую итерацию, иначе выход из цикла

=== Ресурс параллелизма алгоритма ===
В приведенном варианте алгоритма поиска в ширину граф обходится по слоям, то есть на каждой итерации обрабатывается множество вершин, расстояние до которых одинаково. Число слоев не превосходит <math>n - 1</math>, таким образом, высота ярусно-параллельной формы алгоритма поиска в ширину равна <math>O(n)</math>.

Так как поиск блокирующего потока производится последовательно, его высота ярусно-параллельной формы алгоритма совпадает с его последовательной сложностью <math>O(nm)</math>.

Так как число шагов алгоритма не превосходит <math>n</math>, высота ЯПФ алгоритма Диница равна <math>O(n^2m)</math>.

В описанном алгоритме поиска в ширину вершины разделяются между процессами поровну, поэтому ширина ЯПФ поиска в ширину и алгоритма Диница равна <math>n</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': Граф <math>G(V, E)</math>. <math>n</math> вершин <math>v_i</math> и <math>m</math> ребер <math>e_j = (v_j^{(1)}, v_j^{(2)}) </math> с заданной пропускной способностью <math>c_j</math>, а также исток <math>s</math> и сток <math>t</math>.

'''Объем входных данных''': <math>O(m + n)</math>.

'''Выходные данные''': величина максимального потока.

'''Объем выходных данных''': <math>O(1)</math>.

=== Свойства алгоритма ===
В зависимости от порядка обработки ребер графа, вычисленные блокирующие потоки на соответствующих итерациях могут быть различны, кроме того, может поменяться количество итераций алгоритма Диница.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
Набор и границы значений изменяемых параметров запуска реализации алгоритма:

* число процессоров <math>[2^k, k = 0, 1, ...7]</math>;
* число вершин графа [5 000:20 000] с шагом 5000. Количество ребер одинаково для всех графов и равно 2 500 000.

[[File:Dinic scalability.png|600px]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-28T11:44:56Z

Anastasy: /* Масштабируемость алгоритма и его реализации */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref name="Dinic">Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>.
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.
* Можно показать, что после каждой итерации расстояние между стоком и истоком строго увеличивается<ref name="Dinic"/> (то есть <math>{\rm level'}[t] > {\rm level}[t]</math>, где <math>{\rm level'}[t]</math> — расстояние до стока, полученное на следующей итерации). Так как длина кратчайшего <math>s-t</math> пути не может превосходить <math>n - 1</math>, то и количество фаз алгоритма не превосходит <math>n - 1</math>. Таким образом, весь алгоритм Диница выполняется за <math>O(n^2m)</math>.

=== Информационный граф ===
<div><ul>
<li style="display: inline-block;"> [[File:dinic.png|thumb|none|500px|Информационный граф алгоритма Диница]] </li>
<li style="display: inline-block;"> [[File:bfs.png|thumb|none|650px|Информационный граф поиска в ширину]] </li>
</ul></div>
Для алгоритма Диница:
# Инициализация переменных
# Вызов функции поиска в ширину
# (3.1 - 3.k) выполнение функции поиска в глубину, итеративно увеличивается поток
# Вызов функции поиска в ширину. В случае существования пути до стока, переход на следующую итерацию (начиная с поиска в глубину), иначе вывод вычисленной величины потока.
Для поиска в ширину
# Инициализация расстояния до истока (<math>d[s] = 0</math>) и текущего уровня нулю (<math>level = 0</math>).
# Извлечение очередной вершины из множества вершин, соответствующего процессу (<math>v \in V_{node}</math>). Вершина обрабатывается, если расстояние до нее равно текущему уровню (<math>d[v] == level </math>)
# Обход соседей вершин. В случае если вершина <math>u </math> принадлежит <math>V_{node}</math>, значение пути до этой вершины инициализируется <math>d[u] = level + 1</math>. Иначе она помечается для дальнейшей обработки другим процессом.
# Слияние информации по помеченным вершинам (в общем массиве помечаются все вершины, которые были помечены хотя бы один раз)
# Для всех помеченных необработанных (<math>d[v] == -1 </math>) вершин, принадлежащих <math>V_{node}</math>, расстояние принимается равным <math>level + 1</math>
# Если было обновлено расстояние хотя бы до одной вершины, переход на следующую итерацию, иначе выход из цикла

=== Ресурс параллелизма алгоритма ===
В приведенном варианте алгоритма поиска в ширину граф обходится по слоям, то есть на каждой итерации обрабатывается множество вершин, расстояние до которых одинаково. Число слоев не превосходит <math>n - 1</math>, таким образом, высота ярусно-параллельной формы алгоритма поиска в ширину равна <math>O(n)</math>.

Так как поиск блокирующего потока производится последовательно, его высота ярусно-параллельной формы алгоритма совпадает с его последовательной сложностью <math>O(nm)</math>.

Так как число шагов алгоритма не превосходит <math>n</math>, высота ЯПФ алгоритма Диница равна <math>O(n^2m)</math>.

В описанном алгоритме поиска в ширину вершины разделяются между процессами поровну, поэтому ширина ЯПФ поиска в ширину и алгоритма Диница равна <math>n</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': Граф <math>G(V, E)</math>. <math>n</math> вершин <math>v_i</math> и <math>m</math> ребер <math>e_j = (v_j^{(1)}, v_j^{(2)}) </math> с заданной пропускной способностью <math>c_j</math>, а также исток <math>s</math> и сток <math>t</math>.

'''Объем входных данных''': <math>O(m + n)</math>.

'''Выходные данные''': величина максимального потока.

'''Объем выходных данных''': <math>O(1)</math>.

=== Свойства алгоритма ===
В зависимости от порядка обработки ребер графа, вычисленные блокирующие потоки на соответствующих итерациях могут быть различны, кроме того, может поменяться количество итераций алгоритма Диница.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
Набор и границы значений изменяемых параметров запуска реализации алгоритма:

* число процессоров <math>[2^k, k = 0, 1, ...7]</math>;
* число вершин графа [5 000:20 000] с шагом 5000. Количество ребер одинаково для всех графов и равно 2 500 000.

[[File:Dinic scalability.png|600px]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-28T11:44:37Z

Anastasy: /* Масштабируемость алгоритма и его реализации */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref name="Dinic">Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>.
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.
* Можно показать, что после каждой итерации расстояние между стоком и истоком строго увеличивается<ref name="Dinic"/> (то есть <math>{\rm level'}[t] > {\rm level}[t]</math>, где <math>{\rm level'}[t]</math> — расстояние до стока, полученное на следующей итерации). Так как длина кратчайшего <math>s-t</math> пути не может превосходить <math>n - 1</math>, то и количество фаз алгоритма не превосходит <math>n - 1</math>. Таким образом, весь алгоритм Диница выполняется за <math>O(n^2m)</math>.

=== Информационный граф ===
<div><ul>
<li style="display: inline-block;"> [[File:dinic.png|thumb|none|500px|Информационный граф алгоритма Диница]] </li>
<li style="display: inline-block;"> [[File:bfs.png|thumb|none|650px|Информационный граф поиска в ширину]] </li>
</ul></div>
Для алгоритма Диница:
# Инициализация переменных
# Вызов функции поиска в ширину
# (3.1 - 3.k) выполнение функции поиска в глубину, итеративно увеличивается поток
# Вызов функции поиска в ширину. В случае существования пути до стока, переход на следующую итерацию (начиная с поиска в глубину), иначе вывод вычисленной величины потока.
Для поиска в ширину
# Инициализация расстояния до истока (<math>d[s] = 0</math>) и текущего уровня нулю (<math>level = 0</math>).
# Извлечение очередной вершины из множества вершин, соответствующего процессу (<math>v \in V_{node}</math>). Вершина обрабатывается, если расстояние до нее равно текущему уровню (<math>d[v] == level </math>)
# Обход соседей вершин. В случае если вершина <math>u </math> принадлежит <math>V_{node}</math>, значение пути до этой вершины инициализируется <math>d[u] = level + 1</math>. Иначе она помечается для дальнейшей обработки другим процессом.
# Слияние информации по помеченным вершинам (в общем массиве помечаются все вершины, которые были помечены хотя бы один раз)
# Для всех помеченных необработанных (<math>d[v] == -1 </math>) вершин, принадлежащих <math>V_{node}</math>, расстояние принимается равным <math>level + 1</math>
# Если было обновлено расстояние хотя бы до одной вершины, переход на следующую итерацию, иначе выход из цикла

=== Ресурс параллелизма алгоритма ===
В приведенном варианте алгоритма поиска в ширину граф обходится по слоям, то есть на каждой итерации обрабатывается множество вершин, расстояние до которых одинаково. Число слоев не превосходит <math>n - 1</math>, таким образом, высота ярусно-параллельной формы алгоритма поиска в ширину равна <math>O(n)</math>.

Так как поиск блокирующего потока производится последовательно, его высота ярусно-параллельной формы алгоритма совпадает с его последовательной сложностью <math>O(nm)</math>.

Так как число шагов алгоритма не превосходит <math>n</math>, высота ЯПФ алгоритма Диница равна <math>O(n^2m)</math>.

В описанном алгоритме поиска в ширину вершины разделяются между процессами поровну, поэтому ширина ЯПФ поиска в ширину и алгоритма Диница равна <math>n</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': Граф <math>G(V, E)</math>. <math>n</math> вершин <math>v_i</math> и <math>m</math> ребер <math>e_j = (v_j^{(1)}, v_j^{(2)}) </math> с заданной пропускной способностью <math>c_j</math>, а также исток <math>s</math> и сток <math>t</math>.

'''Объем входных данных''': <math>O(m + n)</math>.

'''Выходные данные''': величина максимального потока.

'''Объем выходных данных''': <math>O(1)</math>.

=== Свойства алгоритма ===
В зависимости от порядка обработки ребер графа, вычисленные блокирующие потоки на соответствующих итерациях могут быть различны, кроме того, может поменяться количество итераций алгоритма Диница.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
Набор и границы значений изменяемых параметров запуска реализации алгоритма:

* число процессоров <math>[2^k, k = 0, 1, ...7]</math>;
* число вершин графа [5000:20000] с шагом 5000. Количество ребер одинаково для всех графов и равно 2500000.

[[File:Dinic scalability.png|600px]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-28T11:36:39Z

Anastasy: /* Свойства алгоритма */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref name="Dinic">Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>.
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.
* Можно показать, что после каждой итерации расстояние между стоком и истоком строго увеличивается<ref name="Dinic"/> (то есть <math>{\rm level'}[t] > {\rm level}[t]</math>, где <math>{\rm level'}[t]</math> — расстояние до стока, полученное на следующей итерации). Так как длина кратчайшего <math>s-t</math> пути не может превосходить <math>n - 1</math>, то и количество фаз алгоритма не превосходит <math>n - 1</math>. Таким образом, весь алгоритм Диница выполняется за <math>O(n^2m)</math>.

=== Информационный граф ===
<div><ul>
<li style="display: inline-block;"> [[File:dinic.png|thumb|none|500px|Информационный граф алгоритма Диница]] </li>
<li style="display: inline-block;"> [[File:bfs.png|thumb|none|650px|Информационный граф поиска в ширину]] </li>
</ul></div>
Для алгоритма Диница:
# Инициализация переменных
# Вызов функции поиска в ширину
# (3.1 - 3.k) выполнение функции поиска в глубину, итеративно увеличивается поток
# Вызов функции поиска в ширину. В случае существования пути до стока, переход на следующую итерацию (начиная с поиска в глубину), иначе вывод вычисленной величины потока.
Для поиска в ширину
# Инициализация расстояния до истока (<math>d[s] = 0</math>) и текущего уровня нулю (<math>level = 0</math>).
# Извлечение очередной вершины из множества вершин, соответствующего процессу (<math>v \in V_{node}</math>). Вершина обрабатывается, если расстояние до нее равно текущему уровню (<math>d[v] == level </math>)
# Обход соседей вершин. В случае если вершина <math>u </math> принадлежит <math>V_{node}</math>, значение пути до этой вершины инициализируется <math>d[u] = level + 1</math>. Иначе она помечается для дальнейшей обработки другим процессом.
# Слияние информации по помеченным вершинам (в общем массиве помечаются все вершины, которые были помечены хотя бы один раз)
# Для всех помеченных необработанных (<math>d[v] == -1 </math>) вершин, принадлежащих <math>V_{node}</math>, расстояние принимается равным <math>level + 1</math>
# Если было обновлено расстояние хотя бы до одной вершины, переход на следующую итерацию, иначе выход из цикла

=== Ресурс параллелизма алгоритма ===
В приведенном варианте алгоритма поиска в ширину граф обходится по слоям, то есть на каждой итерации обрабатывается множество вершин, расстояние до которых одинаково. Число слоев не превосходит <math>n - 1</math>, таким образом, высота ярусно-параллельной формы алгоритма поиска в ширину равна <math>O(n)</math>.

Так как поиск блокирующего потока производится последовательно, его высота ярусно-параллельной формы алгоритма совпадает с его последовательной сложностью <math>O(nm)</math>.

Так как число шагов алгоритма не превосходит <math>n</math>, высота ЯПФ алгоритма Диница равна <math>O(n^2m)</math>.

В описанном алгоритме поиска в ширину вершины разделяются между процессами поровну, поэтому ширина ЯПФ поиска в ширину и алгоритма Диница равна <math>n</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': Граф <math>G(V, E)</math>. <math>n</math> вершин <math>v_i</math> и <math>m</math> ребер <math>e_j = (v_j^{(1)}, v_j^{(2)}) </math> с заданной пропускной способностью <math>c_j</math>, а также исток <math>s</math> и сток <math>t</math>.

'''Объем входных данных''': <math>O(m + n)</math>.

'''Выходные данные''': величина максимального потока.

'''Объем выходных данных''': <math>O(1)</math>.

=== Свойства алгоритма ===
В зависимости от порядка обработки ребер графа, вычисленные блокирующие потоки на соответствующих итерациях могут быть различны, кроме того, может поменяться количество итераций алгоритма Диница.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-28T11:23:24Z

Anastasy: /* Ресурс параллелизма алгоритма */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref name="Dinic">Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>.
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.
* Можно показать, что после каждой итерации расстояние между стоком и истоком строго увеличивается<ref name="Dinic"/> (то есть <math>{\rm level'}[t] > {\rm level}[t]</math>, где <math>{\rm level'}[t]</math> — расстояние до стока, полученное на следующей итерации). Так как длина кратчайшего <math>s-t</math> пути не может превосходить <math>n - 1</math>, то и количество фаз алгоритма не превосходит <math>n - 1</math>. Таким образом, весь алгоритм Диница выполняется за <math>O(n^2m)</math>.

=== Информационный граф ===
<div><ul>
<li style="display: inline-block;"> [[File:dinic.png|thumb|none|500px|Информационный граф алгоритма Диница]] </li>
<li style="display: inline-block;"> [[File:bfs.png|thumb|none|650px|Информационный граф поиска в ширину]] </li>
</ul></div>
Для алгоритма Диница:
# Инициализация переменных
# Вызов функции поиска в ширину
# (3.1 - 3.k) выполнение функции поиска в глубину, итеративно увеличивается поток
# Вызов функции поиска в ширину. В случае существования пути до стока, переход на следующую итерацию (начиная с поиска в глубину), иначе вывод вычисленной величины потока.
Для поиска в ширину
# Инициализация расстояния до истока (<math>d[s] = 0</math>) и текущего уровня нулю (<math>level = 0</math>).
# Извлечение очередной вершины из множества вершин, соответствующего процессу (<math>v \in V_{node}</math>). Вершина обрабатывается, если расстояние до нее равно текущему уровню (<math>d[v] == level </math>)
# Обход соседей вершин. В случае если вершина <math>u </math> принадлежит <math>V_{node}</math>, значение пути до этой вершины инициализируется <math>d[u] = level + 1</math>. Иначе она помечается для дальнейшей обработки другим процессом.
# Слияние информации по помеченным вершинам (в общем массиве помечаются все вершины, которые были помечены хотя бы один раз)
# Для всех помеченных необработанных (<math>d[v] == -1 </math>) вершин, принадлежащих <math>V_{node}</math>, расстояние принимается равным <math>level + 1</math>
# Если было обновлено расстояние хотя бы до одной вершины, переход на следующую итерацию, иначе выход из цикла

=== Ресурс параллелизма алгоритма ===
В приведенном варианте алгоритма поиска в ширину граф обходится по слоям, то есть на каждой итерации обрабатывается множество вершин, расстояние до которых одинаково. Число слоев не превосходит <math>n - 1</math>, таким образом, высота ярусно-параллельной формы алгоритма поиска в ширину равна <math>O(n)</math>.

Так как поиск блокирующего потока производится последовательно, его высота ярусно-параллельной формы алгоритма совпадает с его последовательной сложностью <math>O(nm)</math>.

Так как число шагов алгоритма не превосходит <math>n</math>, высота ЯПФ алгоритма Диница равна <math>O(n^2m)</math>.

В описанном алгоритме поиска в ширину вершины разделяются между процессами поровну, поэтому ширина ЯПФ поиска в ширину и алгоритма Диница равна <math>n</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': Граф <math>G(V, E)</math>. <math>n</math> вершин <math>v_i</math> и <math>m</math> ребер <math>e_j = (v_j^{(1)}, v_j^{(2)}) </math> с заданной пропускной способностью <math>c_j</math>, а также исток <math>s</math> и сток <math>t</math>.

'''Объем входных данных''': <math>O(m + n)</math>.

'''Выходные данные''': величина максимального потока.

'''Объем выходных данных''': <math>O(1)</math>.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-28T11:23:12Z

Anastasy: /* Ресурс параллелизма алгоритма */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref name="Dinic">Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>.
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.
* Можно показать, что после каждой итерации расстояние между стоком и истоком строго увеличивается<ref name="Dinic"/> (то есть <math>{\rm level'}[t] > {\rm level}[t]</math>, где <math>{\rm level'}[t]</math> — расстояние до стока, полученное на следующей итерации). Так как длина кратчайшего <math>s-t</math> пути не может превосходить <math>n - 1</math>, то и количество фаз алгоритма не превосходит <math>n - 1</math>. Таким образом, весь алгоритм Диница выполняется за <math>O(n^2m)</math>.

=== Информационный граф ===
<div><ul>
<li style="display: inline-block;"> [[File:dinic.png|thumb|none|500px|Информационный граф алгоритма Диница]] </li>
<li style="display: inline-block;"> [[File:bfs.png|thumb|none|650px|Информационный граф поиска в ширину]] </li>
</ul></div>
Для алгоритма Диница:
# Инициализация переменных
# Вызов функции поиска в ширину
# (3.1 - 3.k) выполнение функции поиска в глубину, итеративно увеличивается поток
# Вызов функции поиска в ширину. В случае существования пути до стока, переход на следующую итерацию (начиная с поиска в глубину), иначе вывод вычисленной величины потока.
Для поиска в ширину
# Инициализация расстояния до истока (<math>d[s] = 0</math>) и текущего уровня нулю (<math>level = 0</math>).
# Извлечение очередной вершины из множества вершин, соответствующего процессу (<math>v \in V_{node}</math>). Вершина обрабатывается, если расстояние до нее равно текущему уровню (<math>d[v] == level </math>)
# Обход соседей вершин. В случае если вершина <math>u </math> принадлежит <math>V_{node}</math>, значение пути до этой вершины инициализируется <math>d[u] = level + 1</math>. Иначе она помечается для дальнейшей обработки другим процессом.
# Слияние информации по помеченным вершинам (в общем массиве помечаются все вершины, которые были помечены хотя бы один раз)
# Для всех помеченных необработанных (<math>d[v] == -1 </math>) вершин, принадлежащих <math>V_{node}</math>, расстояние принимается равным <math>level + 1</math>
# Если было обновлено расстояние хотя бы до одной вершины, переход на следующую итерацию, иначе выход из цикла

=== Ресурс параллелизма алгоритма ===
В приведенном варианте алгоритма поиска в ширину, граф обходится по слоям, то есть на каждой итерации обрабатывается множество вершин, расстояние до которых одинаково. Число слоев не превосходит <math>n - 1</math>, таким образом, высота ярусно-параллельной формы алгоритма поиска в ширину равна <math>O(n)</math>.

Так как поиск блокирующего потока производится последовательно, его высота ярусно-параллельной формы алгоритма совпадает с его последовательной сложностью <math>O(nm)</math>.

Так как число шагов алгоритма не превосходит <math>n</math>, высота ЯПФ алгоритма Диница равна <math>O(n^2m)</math>.

В описанном алгоритме поиска в ширину вершины разделяются между процессами поровну, поэтому ширина ЯПФ поиска в ширину и алгоритма Диница равна <math>n</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': Граф <math>G(V, E)</math>. <math>n</math> вершин <math>v_i</math> и <math>m</math> ребер <math>e_j = (v_j^{(1)}, v_j^{(2)}) </math> с заданной пропускной способностью <math>c_j</math>, а также исток <math>s</math> и сток <math>t</math>.

'''Объем входных данных''': <math>O(m + n)</math>.

'''Выходные данные''': величина максимального потока.

'''Объем выходных данных''': <math>O(1)</math>.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-28T11:00:38Z

Anastasy: /* Информационный граф */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref name="Dinic">Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>.
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.
* Можно показать, что после каждой итерации расстояние между стоком и истоком строго увеличивается<ref name="Dinic"/> (то есть <math>{\rm level'}[t] > {\rm level}[t]</math>, где <math>{\rm level'}[t]</math> — расстояние до стока, полученное на следующей итерации). Так как длина кратчайшего <math>s-t</math> пути не может превосходить <math>n - 1</math>, то и количество фаз алгоритма не превосходит <math>n - 1</math>. Таким образом, весь алгоритм Диница выполняется за <math>O(n^2m)</math>.

=== Информационный граф ===
<div><ul>
<li style="display: inline-block;"> [[File:dinic.png|thumb|none|500px|Информационный граф алгоритма Диница]] </li>
<li style="display: inline-block;"> [[File:bfs.png|thumb|none|650px|Информационный граф поиска в ширину]] </li>
</ul></div>
Для алгоритма Диница:
# Инициализация переменных
# Вызов функции поиска в ширину
# (3.1 - 3.k) выполнение функции поиска в глубину, итеративно увеличивается поток
# Вызов функции поиска в ширину. В случае существования пути до стока, переход на следующую итерацию (начиная с поиска в глубину), иначе вывод вычисленной величины потока.
Для поиска в ширину
# Инициализация расстояния до истока (<math>d[s] = 0</math>) и текущего уровня нулю (<math>level = 0</math>).
# Извлечение очередной вершины из множества вершин, соответствующего процессу (<math>v \in V_{node}</math>). Вершина обрабатывается, если расстояние до нее равно текущему уровню (<math>d[v] == level </math>)
# Обход соседей вершин. В случае если вершина <math>u </math> принадлежит <math>V_{node}</math>, значение пути до этой вершины инициализируется <math>d[u] = level + 1</math>. Иначе она помечается для дальнейшей обработки другим процессом.
# Слияние информации по помеченным вершинам (в общем массиве помечаются все вершины, которые были помечены хотя бы один раз)
# Для всех помеченных необработанных (<math>d[v] == -1 </math>) вершин, принадлежащих <math>V_{node}</math>, расстояние принимается равным <math>level + 1</math>
# Если было обновлено расстояние хотя бы до одной вершины, переход на следующую итерацию, иначе выход из цикла

=== Ресурс параллелизма алгоритма ===
=== Входные и выходные данные алгоритма ===
'''Входные данные''': Граф <math>G(V, E)</math>. <math>n</math> вершин <math>v_i</math> и <math>m</math> ребер <math>e_j = (v_j^{(1)}, v_j^{(2)}) </math> с заданной пропускной способностью <math>c_j</math>, а также исток <math>s</math> и сток <math>t</math>.

'''Объем входных данных''': <math>O(m + n)</math>.

'''Выходные данные''': величина максимального потока.

'''Объем выходных данных''': <math>O(1)</math>.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-28T10:46:02Z

Anastasy: /* Информационный граф */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref name="Dinic">Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>.
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.
* Можно показать, что после каждой итерации расстояние между стоком и истоком строго увеличивается<ref name="Dinic"/> (то есть <math>{\rm level'}[t] > {\rm level}[t]</math>, где <math>{\rm level'}[t]</math> — расстояние до стока, полученное на следующей итерации). Так как длина кратчайшего <math>s-t</math> пути не может превосходить <math>n - 1</math>, то и количество фаз алгоритма не превосходит <math>n - 1</math>. Таким образом, весь алгоритм Диница выполняется за <math>O(n^2m)</math>.

=== Информационный граф ===
<div><ul>
<li style="display: inline-block;"> [[File:dinic.png|thumb|none|500px|Информационный граф алгоритма Диница]] </li>
<li style="display: inline-block;"> [[File:bfs.png|thumb|none|650px|Информационный граф поиска в ширину]] </li>
</ul></div>
Для алгоритма Диница:
# Инициализация переменных
# Вызов функции поиска в ширину
# (3.1 - 3.k) выполнение функции поиска в глубину, итеративно увеличивается поток
# Вызов функции поиска в ширину. В случае существования пути до стока, переход на следующую итерацию (начиная с поиска в глубину), иначе вывод вычисленной величины потока.
Для поиска в ширину
# Инициализация расстояния до истока (<math>d[s] = 0</math>).
# Проверка равенства расстояния до вершины из множества вершин, соответствующего процессу (<math>v \in V_{node}</math>), текущему уровню (вершина обрабатывается, если <math>d[v] == level </math>)
# Обход соседей вершин. В случае если вершина <math>u </math> принадлежит <math>V_{node}</math>, значение пути до этой вершины инициализируется <math>d[u] = level + 1</math>. Иначе она помечается для дальнейшей обработки другим процессом.
# Слияние информации по помеченным вершинам (в общем массиве помечаются все вершины, которые были помечены хотя бы один раз)
# Для всех помеченных вершин, принадлежащих <math>V_{node}</math>, расстояние принимается равным <math>level + 1</math>
# Если было обновлено расстояние хотя бы до одной вершины, переход на следующую итерацию, иначе выход из цикла

=== Ресурс параллелизма алгоритма ===
=== Входные и выходные данные алгоритма ===
'''Входные данные''': Граф <math>G(V, E)</math>. <math>n</math> вершин <math>v_i</math> и <math>m</math> ребер <math>e_j = (v_j^{(1)}, v_j^{(2)}) </math> с заданной пропускной способностью <math>c_j</math>, а также исток <math>s</math> и сток <math>t</math>.

'''Объем входных данных''': <math>O(m + n)</math>.

'''Выходные данные''': величина максимального потока.

'''Объем выходных данных''': <math>O(1)</math>.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-28T10:43:17Z

Anastasy: /* Информационный граф */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref name="Dinic">Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>.
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.
* Можно показать, что после каждой итерации расстояние между стоком и истоком строго увеличивается<ref name="Dinic"/> (то есть <math>{\rm level'}[t] > {\rm level}[t]</math>, где <math>{\rm level'}[t]</math> — расстояние до стока, полученное на следующей итерации). Так как длина кратчайшего <math>s-t</math> пути не может превосходить <math>n - 1</math>, то и количество фаз алгоритма не превосходит <math>n - 1</math>. Таким образом, весь алгоритм Диница выполняется за <math>O(n^2m)</math>.

=== Информационный граф ===
<div><ul>
<li style="display: inline-block;"> [[File:dinic.png|thumb|none|500px|Информационный граф алгоритма Диница]] </li>
<li style="display: inline-block;"> [[File:bfs.png|thumb|none|650px|Информационный граф поиска в ширину]] </li>
</ul></div>
Для алгоритма Диница:
# Инициализация переменных
# Вызов функции поиска в ширину
# (3.1 - 3.k) выполнение функции поиска в глубину, итеративно увеличивается поток
# Вызов функции поиска в ширину. В случае существования пути до стока, переход на следующую итерацию (начиная с поиска в глубину), иначе вывод вычисленной величины потока.
Для поиска в ширину
# Передача данных по изменению ребер графа (удаляются насыщенные потоком ребра и добавляются те, в которых поток отрицателен)
# Проверка равенства расстояния до вершины из множества вершин, соответствующего процессу (<math>v \in V_{node}</math>), текущему уровню (вершина обрабатывается, если <math>d[v] == level </math>)
# Обход соседей вершин. В случае если вершина <math>u </math> принадлежит <math>V_{node}</math>, значение пути до этой вершины инициализируется <math>d[u] = level + 1</math>. Иначе она помечается для дальнейшей обработки другим процессом.
# Слияние информации по помеченным вершинам (в общем массиве помечаются все вершины, которые были помечены хотя бы один раз)
# Для всех помеченных вершин, принадлежащих <math>V_{node}</math>, расстояние принимается равным <math>level + 1</math>
# Если было обновлено расстояние хотя бы до одной вершины, переход на следующую итерацию, иначе выход из цикла

=== Ресурс параллелизма алгоритма ===
=== Входные и выходные данные алгоритма ===
'''Входные данные''': Граф <math>G(V, E)</math>. <math>n</math> вершин <math>v_i</math> и <math>m</math> ребер <math>e_j = (v_j^{(1)}, v_j^{(2)}) </math> с заданной пропускной способностью <math>c_j</math>, а также исток <math>s</math> и сток <math>t</math>.

'''Объем входных данных''': <math>O(m + n)</math>.

'''Выходные данные''': величина максимального потока.

'''Объем выходных данных''': <math>O(1)</math>.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-27T20:19:26Z

Anastasy: /* Информационный граф */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref name="Dinic">Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>.
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.
* Можно показать, что после каждой итерации расстояние между стоком и истоком строго увеличивается<ref name="Dinic"/> (то есть <math>{\rm level'}[t] > {\rm level}[t]</math>, где <math>{\rm level'}[t]</math> — расстояние до стока, полученное на следующей итерации). Так как длина кратчайшего <math>s-t</math> пути не может превосходить <math>n - 1</math>, то и количество фаз алгоритма не превосходит <math>n - 1</math>. Таким образом, весь алгоритм Диница выполняется за <math>O(n^2m)</math>.

=== Информационный граф ===
<div><ul>
<li style="display: inline-block;"> [[File:dinic.png|thumb|none|500px|Информационный граф для алгоритма Диница]] </li>
<li style="display: inline-block;"> [[File:bfs.png|thumb|none|650px|Информационный граф для параллельной реализации поиска в ширину]] </li>
</ul></div>
Для алгоритма Диница:
# Инициализация переменных
# Вызов функции поиска в ширину
# (3.1 - 3.k) выполнение функции поиска в глубину, итеративно увеличивается поток
# Вызов функции поиска в ширину. В случае существования пути до стока, переход на следующую итерацию (начиная с поиска в глубину), иначе вывод вычисленной величины потока.
Для параллельной реализации поиска в ширину
# Передача данных по изменению ребер графа (удаляются насыщенные потоком ребра и добавляются те, в которых поток отрицателен)
# Проверка равенства расстояния до вершины из множества вершин, соответствующего процессу (<math>v \in V.this\_node</math>), текущему уровню (вершина обрабатывается, если <math>d[v] == level </math>)
# Обход соседей вершин. В случае если вершина <math>to </math> принадлежит <math>V.this\_node</math>, значение пути до этой вершины инициализируется <math>d[to] == level + 1</math>. Иначе она помечается для дальнейшей обработки другим процессом.

=== Ресурс параллелизма алгоритма ===
=== Входные и выходные данные алгоритма ===
'''Входные данные''': Граф <math>G(V, E)</math>. <math>n</math> вершин <math>v_i</math> и <math>m</math> ребер <math>e_j = (v_j^{(1)}, v_j^{(2)}) </math> с заданной пропускной способностью <math>c_j</math>, а также исток <math>s</math> и сток <math>t</math>.

'''Объем входных данных''': <math>O(m + n)</math>.

'''Выходные данные''': величина максимального потока.

'''Объем выходных данных''': <math>O(1)</math>.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-27T18:57:58Z

Anastasy: /* Информационный граф */

Участник:Anastasy/Алгоритм Диница

2017-11-27T18:40:05Z

Anastasy: /* Информационный граф */

Участник:Anastasy/Алгоритм Диница

2017-11-22T15:18:45Z

Anastasy: /* Входные и выходные данные алгоритма */

Участник:Anastasy/Алгоритм Диница

2017-11-22T15:17:29Z

Anastasy: /* Входные и выходные данные алгоритма */

Участник:Anastasy/Алгоритм Диница

2017-11-22T15:16:46Z

Anastasy: /* Входные и выходные данные алгоритма */

Участник:Anastasy/Алгоритм Диница

2017-11-09T16:52:57Z

Anastasy: /* Постановка задачи */

Участник:Anastasy/Алгоритм Диница

2017-11-09T16:50:13Z

Anastasy: /* Постановка задачи */

Участник:Anastasy/Алгоритм Диница

2017-11-09T16:46:57Z

Anastasy: /* Постановка задачи */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>.
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.
* Можно показать, что после каждой итерации расстояние между стоком и истоком строго увеличивается<ref>Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref>, тогда так как длина кратчайшего <math>s-t</math> пути не может превосходить <math>n - 1</math>, то и количество фаз алгоритма не превосходит <math>n - 1</math>. Таким образом, весь алгоритм Диница выполняется за <math>O(n^2m)</math>.

=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===
=== Входные и выходные данные алгоритма ===
=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-09T16:43:17Z

Anastasy: /* Последовательная сложность алгоритма */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>.
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.
* Можно показать, что каждый раз количество рёбер в блокирующем потоке увеличивается хотя бы на одно,

=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===
=== Входные и выходные данные алгоритма ===
=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-09T16:22:33Z

Anastasy: /* Последовательная сложность алгоритма */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
* С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>
* Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается <math>O(mn)</math>.

=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===
=== Входные и выходные данные алгоритма ===
=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-09T16:21:38Z

Anastasy: /* Постановка задачи */

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
# С помощью поиска в ширину слоистая сеть строится за время <math>O(m)</math>
# Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Таким образом, один запуск обхода в глубину работает за <math>O(n + k)</math>, где <math>k</math> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного блокирующего потока будет <math>O(p)</math>, где <math>p</math> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <math>O(pn + \sum\limits_i{k_i})</math>. Учитывая, что все указатели в сумме прошли расстояние <math>O(m)</math>, это дает асимптотику <math>O(pn + pk)</math>. В худшем случае, когда блокирующий поток насыщает все рёбра, асимптотика получается O(VE).
=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===
=== Входные и выходные данные алгоритма ===
=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-03T19:51:04Z

Anastasy:

Алгоритм Диница

Автор: Киреева Анастасия, группа 416

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===
=== Входные и выходные данные алгоритма ===
=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-03T19:49:53Z

Anastasy: /* Постановка задачи */

Алгоритм Диница

Автор: Анастасия Киреева

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===
=== Входные и выходные данные алгоритма ===
=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-11-03T19:49:14Z

Anastasy: /* Постановка задачи */

Алгоритм Диница
Автор: Анастасия Киреева

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===
=== Входные и выходные данные алгоритма ===
=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-20T14:42:27Z

Anastasy: /* Программная реализация алгоритма */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

=== Последовательная сложность алгоритма ===
=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===
=== Входные и выходные данные алгоритма ===
=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-20T14:40:50Z

Anastasy: /* Постановка задачи */

Участник:Anastasy/Алгоритм Диница

2017-10-20T14:28:55Z

Anastasy: /* Постановка задачи */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* [[Поиск в ширину (BFS)|поиск в ширину]] (для построения слоистой сети)
* [[Поиск в глубину (DFS)|обход в глубину]] (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

== Программная реализация алгоритма ==
== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-20T14:27:27Z

Anastasy: /* Математическое описание алгоритма */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока <math>s</math> до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* поиск в ширину (для построения слоистой сети)
* обход в глубину (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

== Программная реализация алгоритма ==
== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-20T14:26:26Z

Anastasy: /* Математическое описание алгоритма */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока s до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, для которых верно <math>{\rm level}[u] + 1 = {\rm level}[v]</math>.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* поиск в ширину (для построения слоистой сети)
* обход в глубину (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

== Программная реализация алгоритма ==
== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-20T14:25:20Z

Anastasy: /* Общее описание алгоритма */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Диниц, Е. А. “Алгоритм решения задачи о максимальном потоке в сети со степенной оценкой.” Доклады АН СССР 194, no. 4 (1970): 754–57</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока s до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, которые ведут с одного уровня на какой-либо другой, более поздний, уровень, т.е. <math>{\rm level}[u] + 1 = {\rm level}[v]</math> (разница расстояний не может превосходить единицы, это следует из свойства кратчайших расстояний). Таким образом, удаляются все рёбра, расположенные целиком внутри уровней, а также рёбра, ведущие назад, к предыдущим уровням.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* поиск в ширину (для построения слоистой сети)
* обход в глубину (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

== Программная реализация алгоритма ==
== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-20T14:23:59Z

Anastasy: /* Общее описание алгоритма */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Yefim Dinitz (1970). "Algorithm for solution of a problem of maximum flow in a network with power estimation". Доклады Академии наук СССР.</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока s до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, которые ведут с одного уровня на какой-либо другой, более поздний, уровень, т.е. <math>{\rm level}[u] + 1 = {\rm level}[v]</math> (разница расстояний не может превосходить единицы, это следует из свойства кратчайших расстояний). Таким образом, удаляются все рёбра, расположенные целиком внутри уровней, а также рёбра, ведущие назад, к предыдущим уровням.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* поиск в ширину (для построения слоистой сети)
* обход в глубину (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

== Программная реализация алгоритма ==
== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-20T14:23:05Z

Anastasy: /* Схема реализации последовательного алгоритма */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Yefim Dinitz (1970). "Algorithm for solution of a problem of maximum flow in a network with power estimation". Doklady Akademii nauk SSSR.</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока s до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, которые ведут с одного уровня на какой-либо другой, более поздний, уровень, т.е. <math>{\rm level}[u] + 1 = {\rm level}[v]</math> (разница расстояний не может превосходить единицы, это следует из свойства кратчайших расстояний). Таким образом, удаляются все рёбра, расположенные целиком внутри уровней, а также рёбра, ведущие назад, к предыдущим уровням.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* поиск в ширину (для построения слоистой сети)
* обход в глубину (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Затем строим слоистую сеть <math>G^L</math> по отношению к сети <math>G^R</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

== Программная реализация алгоритма ==
== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-20T14:18:10Z

Anastasy: /* Постановка задачи */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Yefim Dinitz (1970). "Algorithm for solution of a problem of maximum flow in a network with power estimation". Doklady Akademii nauk SSSR.</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока s до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, которые ведут с одного уровня на какой-либо другой, более поздний, уровень, т.е. <math>{\rm level}[u] + 1 = {\rm level}[v]</math> (разница расстояний не может превосходить единицы, это следует из свойства кратчайших расстояний). Таким образом, удаляются все рёбра, расположенные целиком внутри уровней, а также рёбра, ведущие назад, к предыдущим уровням.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* поиск в ширину (для построения слоистой сети)
* обход в глубину (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.

Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Если <math>{\rm level}[t]=∞</math>, алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

== Программная реализация алгоритма ==
== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-20T14:17:34Z

Anastasy: /* Постановка задачи */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Yefim Dinitz (1970). "Algorithm for solution of a problem of maximum flow in a network with power estimation". Doklady Akademii nauk SSSR.</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока s до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, которые ведут с одного уровня на какой-либо другой, более поздний, уровень, т.е. <math>{\rm level}[u] + 1 = {\rm level}[v]</math> (разница расстояний не может превосходить единицы, это следует из свойства кратчайших расстояний). Таким образом, удаляются все рёбра, расположенные целиком внутри уровней, а также рёбра, ведущие назад, к предыдущим уровням.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* поиск в ширину (для построения слоистой сети)
* обход в глубину (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Одним из важных шагов алгоритма является поиск блокирующего потока. Опишем, каким образом это можно сделать.
Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

=== Схема реализации последовательного алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Если <math>{\rm level}[t]=∞</math> алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

== Программная реализация алгоритма ==
== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-20T08:11:30Z

Anastasy: /* Макроструктура алгоритма */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Yefim Dinitz (1970). "Algorithm for solution of a problem of maximum flow in a network with power estimation". Doklady Akademii nauk SSSR.</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока s до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, которые ведут с одного уровня на какой-либо другой, более поздний, уровень, т.е. <math>{\rm level}[u] + 1 = {\rm level}[v]</math> (разница расстояний не может превосходить единицы, это следует из свойства кратчайших расстояний). Таким образом, удаляются все рёбра, расположенные целиком внутри уровней, а также рёбра, ведущие назад, к предыдущим уровням.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* поиск в ширину (для построения слоистой сети)
* обход в глубину (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Если <math>{\rm level}[t]=∞</math> алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

==== Поиск блокирующего потока ====
Ищем <math>s-t</math> пути по одному обходом в глубину, пока такие пути находятся, при этом удаляем те ребра, вдоль которых невозможно дойти до стока. Для этого достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое неудалённое ребро, и увеличивать этот указатель в цикле внутри обхода в глубину.

== Программная реализация алгоритма ==
== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-20T08:02:59Z

Anastasy: /* Макроструктура алгоритма */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Yefim Dinitz (1970). "Algorithm for solution of a problem of maximum flow in a network with power estimation". Doklady Akademii nauk SSSR.</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока s до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, которые ведут с одного уровня на какой-либо другой, более поздний, уровень, т.е. <math>{\rm level}[u] + 1 = {\rm level}[v]</math> (разница расстояний не может превосходить единицы, это следует из свойства кратчайших расстояний). Таким образом, удаляются все рёбра, расположенные целиком внутри уровней, а также рёбра, ведущие назад, к предыдущим уровням.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* поиск в ширину (для построения слоистой сети)
* обход в глубину (для построения блокирующего потока)

=== Макроструктура алгоритма ===
Структуру алгоритма можно описать следующим образом:
# Для всех ребер <math>(u, v) \in E</math> сети <math>G</math> присвоим <math>f_{uv}=0</math>.
# Построим остаточную сеть <math>G^R</math> по отношению к сети <math>G</math> и потоку <math>f</math>. Если <math>{\rm level}[t]=∞</math> алгоритм завершает работу и выводит поток <math>f</math>.
# Ищем блокирующий поток <math>f'</math> в сети <math>G^R</math>
# Прибавим <math>f'</math> к потоку <math>f</math> и переходим к шагу 2.

== Программная реализация алгоритма ==
== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-19T15:23:45Z

Anastasy: /* Вычислительное ядро алгоритма */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Yefim Dinitz (1970). "Algorithm for solution of a problem of maximum flow in a network with power estimation". Doklady Akademii nauk SSSR.</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока s до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, которые ведут с одного уровня на какой-либо другой, более поздний, уровень, т.е. <math>{\rm level}[u] + 1 = {\rm level}[v]</math> (разница расстояний не может превосходить единицы, это следует из свойства кратчайших расстояний). Таким образом, удаляются все рёбра, расположенные целиком внутри уровней, а также рёбра, ведущие назад, к предыдущим уровням.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* поиск в ширину (для построения слоистой сети)
* обход в глубину (для построения блокирующего потока)

=== Макроструктура алгоритма ===

== Программная реализация алгоритма ==
== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-19T15:23:31Z

Anastasy: /* Вычислительное ядро алгоритма */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Yefim Dinitz (1970). "Algorithm for solution of a problem of maximum flow in a network with power estimation". Doklady Akademii nauk SSSR.</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока s до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, которые ведут с одного уровня на какой-либо другой, более поздний, уровень, т.е. <math>{\rm level}[u] + 1 = {\rm level}[v]</math> (разница расстояний не может превосходить единицы, это следует из свойства кратчайших расстояний). Таким образом, удаляются все рёбра, расположенные целиком внутри уровней, а также рёбра, ведущие назад, к предыдущим уровням.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на:
* поиск в ширину (для построения слоистой сети)
* обход в глубину (для построеия блокирующего потока)

=== Макроструктура алгоритма ===

== Программная реализация алгоритма ==
== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-19T15:22:59Z

Anastasy: /* Постановка задачи */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Yefim Dinitz (1970). "Algorithm for solution of a problem of maximum flow in a network with power estimation". Doklady Akademii nauk SSSR.</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока s до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, которые ведут с одного уровня на какой-либо другой, более поздний, уровень, т.е. <math>{\rm level}[u] + 1 = {\rm level}[v]</math> (разница расстояний не может превосходить единицы, это следует из свойства кратчайших расстояний). Таким образом, удаляются все рёбра, расположенные целиком внутри уровней, а также рёбра, ведущие назад, к предыдущим уровням.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

=== Вычислительное ядро алгоритма ===
Наибольший объем вычислений приходится на
* поиск в ширину (для построения слоистой сети)
* обход в глубину (для построеия блокирующего потока)
=== Макроструктура алгоритма ===

== Программная реализация алгоритма ==
== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-19T15:14:13Z

Anastasy: /* Математическое описание алгоритма */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Yefim Dinitz (1970). "Algorithm for solution of a problem of maximum flow in a network with power estimation". Doklady Akademii nauk SSSR.</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>). Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока s до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, которые ведут с одного уровня на какой-либо другой, более поздний, уровень, т.е. <math>{\rm level}[u] + 1 = {\rm level}[v]</math> (разница расстояний не может превосходить единицы, это следует из свойства кратчайших расстояний). Таким образом, удаляются все рёбра, расположенные целиком внутри уровней, а также рёбра, ведущие назад, к предыдущим уровням.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

== Программная реализация алгоритма ==
== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-19T15:12:21Z

Anastasy: /* Математическое описание алгоритма */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Yefim Dinitz (1970). "Algorithm for solution of a problem of maximum flow in a network with power estimation". Doklady Akademii nauk SSSR.</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G=(V, E)</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in E</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро (то есть <math>c_{uv} = f_{uv}</math> для некоторых <math>u,v \in V</math>. Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока s до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, которые ведут с одного уровня на какой-либо другой, более поздний, уровень, т.е. <math>{\rm level}[u] + 1 = {\rm level}[v]</math> (разница расстояний не может превосходить единицы, это следует из свойства кратчайших расстояний). Таким образом, удаляются все рёбра, расположенные целиком внутри уровней, а также рёбра, ведущие назад, к предыдущим уровням.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

== Программная реализация алгоритма ==
== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-19T15:08:03Z

Anastasy: /* Общее описание алгоритма */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Yefim Dinitz (1970). "Algorithm for solution of a problem of maximum flow in a network with power estimation". Doklady Akademii nauk SSSR.</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in G</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро. Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока s до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, которые ведут с одного уровня на какой-либо другой, более поздний, уровень, т.е. <math>{\rm level}[u] + 1 = {\rm level}[v]</math> (разница расстояний не может превосходить единицы, это следует из свойства кратчайших расстояний). Таким образом, удаляются все рёбра, расположенные целиком внутри уровней, а также рёбра, ведущие назад, к предыдущим уровням.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

== Программная реализация алгоритма ==
== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-19T15:06:29Z

Anastasy: /* Общее описание алгоритма */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Yefim Dinitz (1970). "Algorithm for solution of a problem of maximum flow in a network with power estimation" (PDF). Doklady Akademii nauk SSSR.</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>, где <math>m</math> — число ребер, а <math>n</math> — число вершин.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей.

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in G</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро. Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока s до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, которые ведут с одного уровня на какой-либо другой, более поздний, уровень, т.е. <math>{\rm level}[u] + 1 = {\rm level}[v]</math> (разница расстояний не может превосходить единицы, это следует из свойства кратчайших расстояний). Таким образом, удаляются все рёбра, расположенные целиком внутри уровней, а также рёбра, ведущие назад, к предыдущим уровням.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

== Программная реализация алгоритма ==
== Литература ==
<references />

Участник:Anastasy/Алгоритм Диница

2017-10-19T15:04:59Z

Anastasy: /* Математическое описание алгоритма */

== Постановка задачи ==
=== Общее описание алгоритма ===
Алгоритм Диница <ref>Yefim Dinitz (1970). "Algorithm for solution of a problem of maximum flow in a network with power estimation" (PDF). Doklady Akademii nauk SSSR.</ref> — полиномиальный алгоритм, предназначенный для поиска [[Поиск максимального потока в транспортной сети| максимального потока в транспортной сети]]. Он был предложен советским учёным Ефимом Диницем в 1970 году. Временная сложность алгоритма <math>O(nm^2)</math>. Достижение этой оценки стало возможно благодаря введению понятий блокирующего потока и слоистой сети.

Основная идея алгоритма состоит в том, чтобы итеративно увеличивать величину потока вдоль некоторых путей из истока в сток.
Алгоритм Диница схож с алгоритмом Эдмондса-Карпа<ref>Edmonds, Jack; Karp, Richard M. (1972). "Theoretical improvements in algorithmic efficiency for network flow problems". Journal of the ACM. Association for Computing Machinery</ref>, но основное отличие можно понимать так: на каждой итерации поток увеличивается не вдоль одного кратчайшего пути из истока в сток, а вдоль целого набора таких путей (ведь именно такими путями и являются пути в блокирующем потоке слоистой сети).

=== Математическое описание алгоритма ===
Математическая постановка задачи приведена в статье "[[Поиск максимального потока в транспортной сети]]", мы будем использовать введённые в ней обозначения.

Введём необходимые определения.

'''Остаточной сетью''' <math>G^R</math> по отношению к сети <math>G</math> и некоторому потоку <math>f</math> в ней называется сеть, в которой каждому ребру <math>(u,v) \in G</math> с пропускной способностью <math>c_{uv}</math> и потоком <math>f_{uv}</math> соответствуют два ребра:

* <math>(u,v)</math> с пропускной способностью <math>c_{uv}^R = c_{uv} - f_{uv}</math>
* <math>(v,u)</math> с пропускной способностью <math>c_{vu}^R = f_{uv}</math>
Стоит отметить, что при таком определении в остаточной сети могут появляться кратные рёбра: если в исходной сети было как ребро <math>(u,v)</math>, так и <math>(v,u)</math>.

'''Блокирующим потоком''' в данной сети называется такой поток, что любой путь из истока <math>s</math> в сток <math>t</math> содержит насыщенное этим потоком ребро. Иными словами, в данной сети не найдётся такого пути из истока в сток, вдоль которого можно беспрепятственно увеличить поток.

Блокирующий поток не обязательно максимален. Согласно теореме Форда-Фалкерсона поток будет максимальным тогда и только тогда, когда в остаточной сети <math>G^R</math> не найдётся <math>s-t</math> пути; в блокирующем же потоке ничего не утверждается о существовании пути по рёбрам, появляющимся в остаточной сети.

'''Слоистая сеть''' для данной сети строится следующим образом. Сначала определяются длины кратчайших путей из истока s до всех остальных вершин; назовём уровнем <math>{\rm level}[v]</math> вершины её расстояние от истока. Тогда в слоистую сеть включают все те рёбра <math>(u,v)</math> исходной сети, которые ведут с одного уровня на какой-либо другой, более поздний, уровень, т.е. <math>{\rm level}[u] + 1 = {\rm level}[v]</math> (разница расстояний не может превосходить единицы, это следует из свойства кратчайших расстояний). Таким образом, удаляются все рёбра, расположенные целиком внутри уровней, а также рёбра, ведущие назад, к предыдущим уровням.

Слоистая сеть ациклична. Кроме того, любой <math>s-t</math> путь в слоистой сети является кратчайшим путём в исходной сети.

Алгоритм представляет собой несколько фаз. На каждой фазе сначала строится остаточная сеть, затем по отношению к ней строится слоистая сеть (обходом в ширину), а в ней ищется произвольный блокирующий поток. Найденный блокирующий поток прибавляется к текущему потоку, и на этом очередная итерация заканчивается. Алгоритм заканчивает свою работу, когда в построенной на некоторой итерации остаточной сети не найдётся <math>s-t</math> пути.

== Программная реализация алгоритма ==
== Литература ==
<references />