Алгоритм масштабирования потока — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
(Оценка времени работы)
м (rollbackEdits.php mass rollback)
 
(не показано 60 промежуточных версий 8 участников)
Строка 1: Строка 1:
{{Определение
 
|definition=
 
'''Алгоритм масштабирования потока''' — алгоритм поиска максимального [[Определение_сети,_потока#.D0.9E.D0.BF.D1.80.D0.B5.D0.B4.D0.B5.D0.BB.D0.B5.D0.BD.D0.B8.D0.B5_.D0.BF.D0.BE.D1.82.D0.BE.D0.BA.D0.B0|потока]], работающий в предположении, что все [[Определение_сети,_потока#.D0.9E.D0.BF.D1.80.D0.B5.D0.B4.D0.B5.D0.BB.D0.B5.D0.BD.D0.B8.D0.B5_.D1.81.D0.B5.D1.82.D0.B8|пропускные способности]] рёбер целые, так как они легко представимы в двоичном виде.
 
}}
 
 
 
== Алгоритм ==
 
== Алгоритм ==
Пусть дан [[Основные_определения_теории_графов|граф]] <tex> G </tex>, все ребра которого имеют целочисленную пропускную способность. Обозначим за <tex> U </tex> максимальную пропускную способность: <tex> U = \max\limits_{(u, v) \in EG} c(u, v) </tex>.
+
Пусть дана [[Определение_сети,_потока#.D0.9E.D0.BF.D1.80.D0.B5.D0.B4.D0.B5.D0.BB.D0.B5.D0.BD.D0.B8.D0.B5_.D1.81.D0.B5.D1.82.D0.B8|сеть]] <tex> G </tex>, все рёбра которой имеют целочисленную [[Определение_сети,_потока#.D0.9E.D0.BF.D1.80.D0.B5.D0.B4.D0.B5.D0.BB.D0.B5.D0.BD.D0.B8.D0.B5_.D1.81.D0.B5.D1.82.D0.B8|пропускную способность]]. Обозначим за <tex> U </tex> максимальную пропускную способность: <tex> U = \max\limits_{(u, v) \in E} c(u, v) </tex>.
  
Если записать пропускную способность любого ребра в двоичном виде, то длина полученной битовой последовательности не будет превышать <tex> \lfloor \log_2 U \rfloor + 1 = n + 1 </tex> бит, а значение пропускной способности определяется формулой:
+
Идея алгоритма заключается в нахождении путей с высокой пропускной способностью в первую очередь, чтобы сразу сильно увеличивать [[Определение_сети,_потока#.D0.9E.D0.BF.D1.80.D0.B5.D0.B4.D0.B5.D0.BB.D0.B5.D0.BD.D0.B8.D0.B5_.D0.BF.D0.BE.D1.82.D0.BE.D0.BA.D0.B0|поток]] по ним, а затем по всем остальным. Для этого воспользуемся масштабом <tex> \Delta </tex>. Изначально положим <tex> \Delta = 2^{\lfloor \log_2 U \rfloor} </tex>.
<tex> c(u, v) = \sum\limits_{i = 0}^n a_i(u, v) \times 2^n, a_i(u, v) \in \{0, 1\} </tex>.
 
  
Идея алгоритма заключается в нахождении путей с высокой пропускной способностью в первую очередь, чтобы сразу сильно увеличивать поток по ним, а затем по всем остальным.
+
На каждой итерации в [[Дополняющая_сеть,_дополняющий_путь|дополняющей сети]] алгоритм находит [[Дополняющая_сеть,_дополняющий_путь|дополняющие пути]] с пропускной способностью не меньшей <tex> \Delta </tex> и увеличивает поток вдоль них.
 +
Уменьшив масштаб <tex> \Delta </tex> в <tex> 2 </tex> раза, переходит к следующей итерации.
  
Методом [[Алгоритм_Форда-Фалкерсона,_реализация_с_помощью_поиска_в_глубину|Форда-Фалкерсона]] находим поток <tex> f_0 </tex> для графа <tex> G_0 </tex> с урезанными пропускными способностями <tex> c_0(u, v) = a_n(u, v) </tex>.
+
Очевидно, что при <tex> \Delta = 1 </tex> алгоритм вырождается в алгоритм [[Алоритм_Эдмондса-Карпа|Эдмондса-Карпа]], вследствие чего является корректным.
Добавим следующий бит и находим следующее приближение для графа <tex> G_1 </tex> с новыми пропускными способностями <tex> c_1(u, v) = 2 a_n(u, v) + a_{n - 1}(u, v) - 2 f_0(u, v) </tex>.
 
  
После <tex> n + 1 </tex> итерации получим ответ к задаче.
+
Количество необходимых увеличений путей, основанных на кратчайших путях, может быть много больше количества увеличений, основанных на путях с высокой пропускной способностью.
 +
{|border="0" cellpadding="5" width=30% align=center
 +
|[[Файл:Flow_scale_1.png|550px|thumb|center|Выбор дополняющих путей в порядке длины]]
 +
|[[Файл:Flow_scale_2.png|550px|thumb|center|Выбор пути с высокой пропускной способностью в первую очередь]]
 +
|}
  
 
== Оценка времени работы ==
 
== Оценка времени работы ==
{{Утверждение
+
{{Лемма
 +
|about=
 +
1
 
|statement=
 
|statement=
Время работы алгоритма — <tex> O(E^2 \log U) </tex>.
+
Максимальный поток в сети <tex> G </tex> ограничен сверху значением <tex> |f_k| + 2^k E </tex>, где <tex> |f_k| </tex> {{---}} значение потока при масштабе <tex> \Delta = 2^k </tex>.
 
|proof=
 
|proof=
Докажем, что время работы каждой итерации — <tex> O(E^2) </tex>.
+
[[Файл:Flow_scale_3.png|530px|thumb|right|Разрез <tex> C_k </tex>]]
 +
 
 +
В конце итерации с масштабом <tex> \Delta = 2^k </tex>, сеть <tex> G_{f_k} </tex> может быть разбита на два непересекающихся множества <tex> A_k </tex> и <tex> \overline{A_k} </tex> так, что остаточная пропускная способность каждого ребра, идущего из <tex> A_k </tex> в <tex> \overline{A_k} </tex>, не превосходит масштаба <tex> \Delta </tex>. То есть образуется [[Разрез,_лемма_о_потоке_через_разрез|разрез]] <tex> C_k = \langle A_k, \overline{A_k} \rangle </tex>.
 +
 
 +
При этом, количество таких рёбер не превосходит <tex> E </tex>.
 +
Значит, значение остаточного потока не может превосходить <tex> \Delta E = 2^k E </tex>.
 +
}}
  
 
{{Лемма
 
{{Лемма
 +
|about=
 +
2
 
|statement=
 
|statement=
Время работы первой итерации алгоритма — <tex> O(E^2) </tex>.
+
Суммарное количество увеличивающих путей {{---}} <tex> O(E \log U) </tex>.
 
|proof=
 
|proof=
На первом шаге ребра имеют пропускную способность <tex> 1 </tex>. Значит, <tex> |f_0| \leq V </tex>. Поиск каждого дополнительного пути требует <tex> O(E) </tex> времени, а их количество не больше <tex> V </tex>. Итоговое время работы первой итерации — <tex> O(VE) \leq O(E^2) </tex>.
+
На некоторой итерации алгоритма каждый дополняющий путь имеет пропускную способность не меньше <tex> 2^k </tex>.
}}
+
Дополняющий поток на предыдущем шаге ограничен значением <tex> 2^{k + 1} E </tex>. Следовательно, на каждой итерации количество дополняющих путей не превосходит <tex> 2E </tex>.}}
 
+
{{Утверждение
{{Лемма
 
 
|statement=
 
|statement=
Время работы второй итерации алгоритма <tex> O(E^2) </tex>.
+
Время работы алгоритма {{---}} <tex> O(E^2 \log U) </tex>.
 
|proof=
 
|proof=
[[Файл:Scaling.jpg|250px|thumb|right|Разрез <tex> \langle A, \overline{A} \rangle </tex>.]]
+
В ходе выполнения алгоритма масштаб <tex> \Delta </tex> принимает следующие значения: <tex> S = \{2^{\lfloor \log_2 U \rfloor}, \ldots, 2^k, \ldots, 2, 1, 0\} </tex>. Тогда <tex> |S| = O(\log U) </tex> {{---}} количество итераций алгоритма.
Пусть вершина <tex> s </tex> — источник графа, вершина <tex> t </tex> — сток.
 
Граф <tex> G_{f_0} </tex> — [[Отношение_связности,_компоненты_связности#.D0.A1.D0.BB.D1.83.D1.87.D0.B0.D0.B9_.D0.BE.D1.80.D0.B8.D0.B5.D0.BD.D1.82.D0.B8.D1.80.D0.BE.D0.B2.D0.B0.D0.BD.D0.BD.D0.BE.D0.B3.D0.BE_.D0.B3.D1.80.D0.B0.D1.84.D0.B0|несвязен]]. Обозначим за <tex> A </tex> компоненту связности графа, содержащую вершину <tex> s </tex>. Тогда <tex> t \notin A </tex>. Источник и сток лежат в разных компонентах связности, значит <tex> c_{0_{f_0}}(A, \overline{A}) = c_0(A, \overline{A}) - f_0(A, \overline{A}) = 0 </tex>.
 
  
Значит, в графе с пропускными способностями <tex> c_1 </tex>:
+
Количество итераций алгоритма {{---}} <tex> O(\log U) </tex>, значит, суммарное количество увеличивающих путей {{---}} <tex> O(E \log U) </tex>.
<tex> \forall u \in A, v \in \overline{A} \colon c_1(u, v) \leq 1 </tex>.
 
  
Рассмотрим максимальный поток <tex> f'_1 </tex> в графе <tex> G_1 </tex>.
+
Алгоритм [[Обход_в_ширину|обхода в ширину]] находит каждый дополняющий путь за время <tex> O(E) </tex>. Следовательно, суммарное время работы алгоритма {{---}} <tex> O(E^2 \log U) </tex>.}}
<tex> \langle A, \overline{A} \rangle </tex> — [[Разрез,_лемма_о_потоке_через_разрез|разрез]], значит:
+
 
<tex> |f'_1| = f'_1(A, \overline{A}) \leq c(A, \overline{A}) \leq E, f_1 = f_0 + f'_1 </tex>.
+
== Псевдокод ==
Пропускная способность каждого дополняющего пути не меньше <tex> 1 </tex>, а поиск каждого занимает <tex> O(E) </tex> времени. Значит, итоговое время работы — <tex> O(E^2) </tex>.
+
'''function''' maxFlowByScaling(G: '''graph''', s: '''int''', t: '''int'''): '''int'''
}}
+
    '''int''' flow = 0                                        <font color=darkgreen> // поток в сети </font>
 +
    '''int''' scale = <tex>2^{\lfloor\log_2U\rfloor}</tex>                                 <font color=darkgreen> // текущий минимальный размер потока, который пытаемся пустить </font>
 +
    '''while''' scale <tex> \geqslant </tex> 1
 +
        '''while''' в <tex> G_f </tex> существует увеличивающий путь <tex> p </tex> с пропускной способностью не меньше, чем scale
 +
            '''int''' minCapacity = <tex>\min\{c(u, v) \colon(u, v) \in p\} </tex>     <font color=darkgreen> // минимальная пропускная способность в увеличивающем пути </font>
 +
            увеличить поток по рёбрам <tex> p </tex> на minCapacity
 +
            обновить <tex> G_f </tex>
 +
            flow = flow + minCapacity
 +
        scale = scale / 2
 +
    '''return''' flow
  
Оценка времени работы остальных итераций доказывается аналогично второму случаю. Количество итераций — <tex> O(\log U) </tex>. Значит, общее время работы алгоритма — <tex> O(E^2 \log U) </tex>.
+
== См. также ==
}}
+
* [[Определение_сети,_потока|Определение сети, потока]]
 +
* [[Алоритм_Эдмондса-Карпа|Алоритм Эдмондса-Карпа]]
 +
* [[Алгоритм_Форда-Фалкерсона,_реализация_с_помощью_поиска_в_глубину|Алгоритм Форда-Фалкерсона]]
  
== Литература ==
+
== Источники информации ==
 
* [http://www.csd.uwo.ca/~yuri/Papers/iccv07_cap_scaling.pdf ''Olivier Juan, Yuri Boikov'': Capacity Scaling for Graph Cuts in Vision]
 
* [http://www.csd.uwo.ca/~yuri/Papers/iccv07_cap_scaling.pdf ''Olivier Juan, Yuri Boikov'': Capacity Scaling for Graph Cuts in Vision]
 
* [http://www.topcoder.com/tc?module=Static&d1=tutorials&d2=maxFlowRevisited Algorithm Tutorials. Maximum Flow: Augmenting Path Algorithms Comparison]
 
* [http://www.topcoder.com/tc?module=Static&d1=tutorials&d2=maxFlowRevisited Algorithm Tutorials. Maximum Flow: Augmenting Path Algorithms Comparison]
* [http://www.cs-seminar.spb.ru/reports/34.pdf ''Андрей Станкевич'': Задача о максимальном потоке]
+
* [http://logic.pdmi.ras.ru/ics/talks/21stream.pdf ''Андрей Станкевич'': Задача о максимальном потоке]
 +
* [https://youtu.be/sEwp5ZAJJps?t=18m9s ''Андрей Станкевич'': Лекториум, дополнительные главы алгоритмов, лекция 12]
  
 
[[Категория: Алгоритмы и структуры данных]]
 
[[Категория: Алгоритмы и структуры данных]]
 
[[Категория: Задача о максимальном потоке]]
 
[[Категория: Задача о максимальном потоке]]

Текущая версия на 19:21, 4 сентября 2022

Алгоритм

Пусть дана сеть [math] G [/math], все рёбра которой имеют целочисленную пропускную способность. Обозначим за [math] U [/math] максимальную пропускную способность: [math] U = \max\limits_{(u, v) \in E} c(u, v) [/math].

Идея алгоритма заключается в нахождении путей с высокой пропускной способностью в первую очередь, чтобы сразу сильно увеличивать поток по ним, а затем по всем остальным. Для этого воспользуемся масштабом [math] \Delta [/math]. Изначально положим [math] \Delta = 2^{\lfloor \log_2 U \rfloor} [/math].

На каждой итерации в дополняющей сети алгоритм находит дополняющие пути с пропускной способностью не меньшей [math] \Delta [/math] и увеличивает поток вдоль них. Уменьшив масштаб [math] \Delta [/math] в [math] 2 [/math] раза, переходит к следующей итерации.

Очевидно, что при [math] \Delta = 1 [/math] алгоритм вырождается в алгоритм Эдмондса-Карпа, вследствие чего является корректным.

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

Выбор дополняющих путей в порядке длины
Выбор пути с высокой пропускной способностью в первую очередь

Оценка времени работы

Лемма (1):
Максимальный поток в сети [math] G [/math] ограничен сверху значением [math] |f_k| + 2^k E [/math], где [math] |f_k| [/math] — значение потока при масштабе [math] \Delta = 2^k [/math].
Доказательство:
[math]\triangleright[/math]
Разрез [math] C_k [/math]

В конце итерации с масштабом [math] \Delta = 2^k [/math], сеть [math] G_{f_k} [/math] может быть разбита на два непересекающихся множества [math] A_k [/math] и [math] \overline{A_k} [/math] так, что остаточная пропускная способность каждого ребра, идущего из [math] A_k [/math] в [math] \overline{A_k} [/math], не превосходит масштаба [math] \Delta [/math]. То есть образуется разрез [math] C_k = \langle A_k, \overline{A_k} \rangle [/math].

При этом, количество таких рёбер не превосходит [math] E [/math].

Значит, значение остаточного потока не может превосходить [math] \Delta E = 2^k E [/math].
[math]\triangleleft[/math]
Лемма (2):
Суммарное количество увеличивающих путей — [math] O(E \log U) [/math].
Доказательство:
[math]\triangleright[/math]

На некоторой итерации алгоритма каждый дополняющий путь имеет пропускную способность не меньше [math] 2^k [/math].

Дополняющий поток на предыдущем шаге ограничен значением [math] 2^{k + 1} E [/math]. Следовательно, на каждой итерации количество дополняющих путей не превосходит [math] 2E [/math].
[math]\triangleleft[/math]
Утверждение:
Время работы алгоритма — [math] O(E^2 \log U) [/math].
[math]\triangleright[/math]

В ходе выполнения алгоритма масштаб [math] \Delta [/math] принимает следующие значения: [math] S = \{2^{\lfloor \log_2 U \rfloor}, \ldots, 2^k, \ldots, 2, 1, 0\} [/math]. Тогда [math] |S| = O(\log U) [/math] — количество итераций алгоритма.

Количество итераций алгоритма — [math] O(\log U) [/math], значит, суммарное количество увеличивающих путей — [math] O(E \log U) [/math].

Алгоритм обхода в ширину находит каждый дополняющий путь за время [math] O(E) [/math]. Следовательно, суммарное время работы алгоритма — [math] O(E^2 \log U) [/math].
[math]\triangleleft[/math]

Псевдокод

function maxFlowByScaling(G: graph, s: int, t: int): int
    int flow = 0                                          // поток в сети 
    int scale = [math]2^{\lfloor\log_2U\rfloor}[/math]                                   // текущий минимальный размер потока, который пытаемся пустить 
    while scale [math] \geqslant [/math] 1
        while в [math] G_f [/math] существует увеличивающий путь [math] p [/math] с пропускной способностью не меньше, чем scale
            int minCapacity = [math]\min\{c(u, v) \colon(u, v) \in p\} [/math]      // минимальная пропускная способность в увеличивающем пути 
            увеличить поток по рёбрам [math] p [/math] на minCapacity
            обновить [math] G_f [/math]
            flow = flow + minCapacity
        scale = scale / 2
    return flow

См. также

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