Алгоритм Каргера для нахождения минимального разреза — различия между версиями
м (rollbackEdits.php mass rollback) |
|||
(не показано 10 промежуточных версий 5 участников) | |||
Строка 1: | Строка 1: | ||
− | '''Алгоритм Каргера''' {{---}} рандомизированный алгоритм для нахождения минимального разреза в связном графе. Он был разработан Дэвидом Каргером (англ. ''David Karger'') в 1993 году. | + | '''Алгоритм Каргера''' (англ. ''Karger's algorithm'') {{---}} рандомизированный алгоритм для нахождения минимального разреза в связном графе. Он был разработан Дэвидом Каргером (англ. ''David Karger'') в 1993 году. |
== Основные определения == | == Основные определения == | ||
− | Пусть <tex>G</tex> {{---}} неориентированный мультиграф с множеством вершин <tex>V</tex> и множеством ребер <tex>E</tex>, и <tex>|V| = n</tex>, <tex>|E| = m</tex>. | + | Пусть <tex>G</tex> {{---}} неориентированный [[Основные_определения_теории_графов#def1 | мультиграф]] с множеством вершин <tex>V</tex> и множеством ребер <tex>E</tex>, и <tex>|V| = n</tex>, <tex>|E| = m</tex>. |
{{Определение | {{Определение | ||
|definition= | |definition= | ||
'''Стягиванием''' (англ. ''contraction'') ребра <tex>uv</tex> назовем следующую последовательность действий: | '''Стягиванием''' (англ. ''contraction'') ребра <tex>uv</tex> назовем следующую последовательность действий: | ||
# Добавляем новую вершину <tex>w</tex>. | # Добавляем новую вершину <tex>w</tex>. | ||
− | # Для всех ребер <tex>xu</tex> и <tex>xv</tex> (где <tex>x \in V, x \neq v, x \neq u</tex>) добавляем новые ребра <tex>xw</tex>. При этом, если получаются кратные ребра - оставляем их. | + | # Для всех ребер <tex>xu</tex> и <tex>xv</tex> (где <tex>x \in V, x \neq v, x \neq u</tex>) добавляем новые ребра <tex>xw</tex>. При этом, если получаются кратные ребра {{---}} оставляем их. |
# Удаляем вершины <tex>u</tex> и <tex>v</tex> и все инцидентные им ребра. | # Удаляем вершины <tex>u</tex> и <tex>v</tex> и все инцидентные им ребра. | ||
}} | }} | ||
Строка 24: | Строка 24: | ||
|definition= | |definition= | ||
'''Разрезом''' (англ. ''cut'') <tex>\langle A, B \rangle</tex> называется разбиение множества <tex>V</tex> на два множества <tex>A</tex> и <tex>B</tex>, удовлетворяющее следующим условиям: | '''Разрезом''' (англ. ''cut'') <tex>\langle A, B \rangle</tex> называется разбиение множества <tex>V</tex> на два множества <tex>A</tex> и <tex>B</tex>, удовлетворяющее следующим условиям: | ||
− | * <tex>A, B \subset V</tex> | + | * <tex>A, B \subset V</tex>, |
− | * <tex>A, B \neq \emptyset</tex> | + | * <tex>A, B \neq \emptyset</tex>, |
− | * <tex>A \cap B = \emptyset</tex> | + | * <tex>A \cap B = \emptyset</tex>, |
* <tex>A \cup B = V</tex>. | * <tex>A \cup B = V</tex>. | ||
}} | }} | ||
Строка 41: | Строка 41: | ||
== Алгоритм == | == Алгоритм == | ||
− | Пусть нам дан граф <tex>G = \{V, E\}</tex>. | + | Пусть нам дан граф <tex>G = \{V, E\}</tex>. |
− | minCut(): | + | <code> |
− | answer = | + | '''int''' minCut(G): |
− | for i = 1 | + | answer = <tex>\infty</tex> |
− | curCut = getCut() | + | '''for''' i = 1 '''to''' count |
− | if curCut < answer | + | curCut = getCut(G) |
− | answer = curCut | + | '''if''' curCut < answer |
− | return answer | + | answer = curCut |
− | Так как алгоритм вероятностный и функция <tex>getCut</tex> возвращает вес случайного потока, а не минимального, то для того, чтобы наверняка найти вес минимального, необходим вызвать эту функцию <tex> | + | '''return''' answer |
− | Реализация функции <tex>getCut</tex> {{---}} это и есть основа алгоритма. Будем действовать следующим образом: пока вершин больше двух, будем выбирать случайное ребро и стягивать его. Когда в графе останется две вершины, то количество ребер между этими вершинами будет равно весу некоторого разреза исходного графа. | + | </code> |
− | getCut(): | + | Так как алгоритм вероятностный и функция <tex>\mathrm{getCut}</tex> возвращает вес случайного потока, а не минимального, то для того, чтобы наверняка найти вес минимального, необходим вызвать эту функцию <tex>count</tex> раз. Какое конкретное значение <tex>count</tex> выбрать будет описано ниже. |
− | + | Реализация функции <tex>\mathrm{getCut}</tex> {{---}} это и есть основа алгоритма. Будем действовать следующим образом: пока вершин больше двух, будем выбирать случайное ребро и стягивать его. Когда в графе останется две вершины, то количество ребер между этими вершинами будет равно весу некоторого разреза исходного графа. | |
− | while | + | <code> |
− | + | '''int''' getCut(graph): | |
− | contract( | + | G = graph |
− | + | vertexCount = количество вершин в G | |
− | + | '''while''' vertexCount > 2 | |
− | return | + | edge = случайное ребро из G |
− | + | contract(edge) <font color="darkgreen">//стягиваем ребро edge</font> | |
+ | vertexCount-- | ||
+ | edgeCount = количество ребер в G | ||
+ | '''return''' edgeCount | ||
+ | </code> | ||
== Корректность алгоритма == | == Корректность алгоритма == | ||
− | Докажем корректность алгоритма. Для удобства доказательства и оценок вероятностей, будем считать, что мы ищем не просто вес минимального разреза, а величину конкретного минимального разреза. То есть зафиксируем какой-то один из минимальных разрезов, и если функция <tex>getCut</tex> вернет правильный вес, но посчитает его на другом минимальном разрезе, то будем считать, что ответ получен неверный. Это условие не ухудшает оценки вероятностей и время работы алгоритма. | + | Докажем корректность алгоритма. Для удобства доказательства и оценок вероятностей, будем считать, что мы ищем не просто вес минимального разреза, а величину конкретного минимального разреза. То есть зафиксируем какой-то один из минимальных разрезов, и если функция <tex>\mathrm{getCut}</tex> вернет правильный вес, но посчитает его на другом минимальном разрезе, то будем считать, что ответ получен неверный. Это условие не ухудшает оценки вероятностей и время работы алгоритма. |
{{Лемма | {{Лемма | ||
|about = 1 | |about = 1 | ||
Строка 68: | Строка 72: | ||
|proof = | |proof = | ||
− | Рассмотрим подграф <tex>G'</tex> исходного графа <tex>G</tex> в который входят все ребра, которые были стянуты в вершину <tex>w</tex>. Очевидно, что <tex>G'</tex> связен, а значит в нем существует путь между его любыми двумя | + | Рассмотрим подграф <tex>G'</tex> исходного графа <tex>G</tex> в который входят все ребра, которые были стянуты в вершину <tex>w</tex>. Очевидно, что <tex>G'</tex> связен, а значит в нем существует путь между его любыми двумя вершинами. Следовательно, существует путь между <tex>u</tex> и <tex>v</tex>, состоящий из стянутых ребер. Лемма доказана. |
}} | }} | ||
Строка 85: | Строка 89: | ||
|about = 3 | |about = 3 | ||
|id = Лемма3 | |id = Лемма3 | ||
− | |statement = Пусть <tex>c</tex> {{---}} вес минимального потока в графе <tex>G</tex>. Тогда <tex>m \ | + | |statement = Пусть <tex>c</tex> {{---}} вес минимального потока в графе <tex>G</tex>. Тогда <tex>m \geqslant nc/2</tex>. |
|proof = | |proof = | ||
− | Заметим, что, чтобы выполнялось условие, степень каждой вершины должна быть не менее, чем <tex>c</tex>. Действительно, пусть <tex>deg(v) < c</tex> для некоторой вершины <tex>v \in V</tex>. Тогда <tex>w(v, G \setminus v) = deg(v) < c</tex>, что противоречит условию. Далее, по [[Лемма_о_рукопожатиях|лемме о рукопожатиях]] имеем, что <tex>m \ | + | Заметим, что, чтобы выполнялось условие, степень каждой вершины должна быть не менее, чем <tex>c</tex>. Действительно, пусть <tex>\deg(v) < c</tex> для некоторой вершины <tex>v \in V</tex>. Тогда <tex>w(v, G \setminus v) = \deg(v) < c</tex>, что противоречит условию. Далее, по [[Лемма_о_рукопожатиях|лемме о рукопожатиях]] имеем, что <tex>m \geqslant nc/2</tex>. Лемма доказана. |
}} | }} | ||
Строка 95: | Строка 99: | ||
|about = 4 | |about = 4 | ||
|id = Лемма4 | |id = Лемма4 | ||
− | |statement = Функция <tex>getCut</tex> после своего выполнения получит стянутый граф <tex>G'</tex> соответствующий конкретному разрезу <tex>\langle A, B \rangle</tex> исходного графа <tex>G</tex> тогда и только тогда, когда ни одно ребро, принадлежащее разрезу <tex>\langle A, B \rangle</tex>, не будет стянуто. | + | |statement = Функция <tex>\mathrm{getCut}</tex> после своего выполнения получит стянутый граф <tex>G'</tex> соответствующий конкретному разрезу <tex>\langle A, B \rangle</tex> исходного графа <tex>G</tex> тогда и только тогда, когда ни одно ребро, принадлежащее разрезу <tex>\langle A, B \rangle</tex>, не будет стянуто. |
|proof = | |proof = | ||
Строка 106: | Строка 110: | ||
{{Теорема | {{Теорема | ||
|statement = | |statement = | ||
− | Для вероятности <tex>p</tex> того, что функция <tex>getCut</tex> после своего выполнения получит стянутый граф <tex>G'</tex> соответствующий конкретному разрезу <tex>\langle A, B \rangle</tex> исходного графа <tex>G</tex> верна следующая оценка снизу {{---}} <tex>p(\langle A, B \rangle) \ | + | Для вероятности <tex>p</tex> того, что функция <tex>\mathrm{getCut}</tex> после своего выполнения получит стянутый граф <tex>G'</tex> соответствующий конкретному разрезу <tex>\langle A, B \rangle</tex> исходного графа <tex>G</tex> верна следующая оценка снизу {{---}} <tex>p(\langle A, B \rangle) \geqslant</tex> <tex dpi="150">\frac{2}{n^2}</tex>. |
|proof = | |proof = | ||
− | По [[#Лемма4|лемме 4]] искомый стянутый граф будет получен тогда и только тогда, когда ни одно из ребер разреза не будет стянуто. Так как на каждой итерации алгоритма мы случайно выбираем ребро для стягивания, то можно оценить вероятность того, что ни одно из ребер разреза не будет стянуто. Каждое стягивание уменьшает количество ребер на <tex>1</tex>. Таким образом после <tex>i</tex>-ой итерации алгоритма количество вершин в текущем графе будет равно <tex>n - i + 1</tex>. Рассчитаем вероятность того, что на <tex>i</tex>-ой итерации будет стянуто ребро из разреза <tex>\langle A, B \rangle</tex>. Пусть <tex>w = w(A, B)</tex>. По [[#Лемма2|лемме 2]] величина минимального потока в текущем графе будет | + | По [[#Лемма4|лемме 4]] искомый стянутый граф будет получен тогда и только тогда, когда ни одно из ребер разреза не будет стянуто. Так как на каждой итерации алгоритма мы случайно выбираем ребро для стягивания, то можно оценить вероятность того, что ни одно из ребер разреза не будет стянуто. Каждое стягивание уменьшает количество ребер на <tex>1</tex>. Таким образом после <tex>i</tex>-ой итерации алгоритма количество вершин в текущем графе будет равно <tex>n - i + 1</tex>. Рассчитаем вероятность того, что на <tex>i</tex>-ой итерации будет стянуто ребро из разреза <tex>\langle A, B \rangle</tex>. Пусть <tex>w = w(A, B)</tex>. По [[#Лемма2|лемме 2]] величина минимального потока в текущем графе будет не меньше, чем <tex>w</tex>, и в нем будет не менее <tex dpi="150">\frac{w(n-i+1)}{2}</tex> вершин по [[#Лемма3|лемме 3]]. Тогда вероятность того, что будет стянуто ребро из разреза <tex>\langle A, B \rangle</tex>, при условии, что до этого не было стянуто ни одно из ребер разреза, будет не более |
<tex dpi="150">\frac{2\cdot w(A,B)}{w\cdot (n-i+1)}=\frac{2}{n-i+1}.</tex> | <tex dpi="150">\frac{2\cdot w(A,B)}{w\cdot (n-i+1)}=\frac{2}{n-i+1}.</tex> | ||
Строка 114: | Строка 118: | ||
Обозначим за <tex>\xi_i</tex> событие, что на <tex>i</tex>-ой итерации случайным образом будет выбрано ребро из разреза <tex>\langle A, B \rangle</tex>. Тогда мы только что установили, что | Обозначим за <tex>\xi_i</tex> событие, что на <tex>i</tex>-ой итерации случайным образом будет выбрано ребро из разреза <tex>\langle A, B \rangle</tex>. Тогда мы только что установили, что | ||
− | <tex dpi="140">p(\xi_i | \overline{\xi_1} \wedge \ldots \wedge \overline{\xi_{i-1}}) \ | + | <tex dpi="140">p(\xi_i | \overline{\xi_1} \wedge \ldots \wedge \overline{\xi_{i-1}}) \leqslant \frac{2}{n-i+1}.</tex> |
− | <tex dpi="140">p(\overline{\xi_i} | \overline{\xi_1} \wedge \ldots \wedge \overline{\xi_{i-1}}) = 1 - p(\xi_i | \overline{\xi_1} \wedge \ldots \wedge \overline{\xi_{i-1}}) \ | + | <tex dpi="140">p(\overline{\xi_i} | \overline{\xi_1} \wedge \ldots \wedge \overline{\xi_{i-1}}) = 1 - p(\xi_i | \overline{\xi_1} \wedge \ldots \wedge \overline{\xi_{i-1}}) \geqslant 1 - \frac{2}{n-i+1} = \frac{n-i-1}{n-i+1}.</tex> |
Тогда вероятность того, что во время работы функции не будет стянуто ни одно ребро оценивается следующим образом: | Тогда вероятность того, что во время работы функции не будет стянуто ни одно ребро оценивается следующим образом: | ||
− | <tex dpi="140">p(\overline{\xi_1} \wedge \ldots \wedge \overline{\xi_{n-2}}) = \prod\limits_{i=1}^{n-2} p(\overline{\xi_i} | \overline{\xi_1} \wedge \ldots \wedge \overline{\xi_{i-1}}) \ | + | <tex dpi="140">p(\overline{\xi_1} \wedge \ldots \wedge \overline{\xi_{n-2}}) = \prod\limits_{i=1}^{n-2} p(\overline{\xi_i} | \overline{\xi_1} \wedge \ldots \wedge \overline{\xi_{i-1}}) \geqslant </tex> |
− | <tex dpi="140">\ | + | <tex dpi="140">\geqslant \prod\limits_{i=1}^{n-2} \frac{n-i-1}{n-i+1} = \frac{n - 2}{n} \cdot \frac{n-3}{n-1} \cdot \frac{n-4}{n-2} \cdot \ldots \cdot \frac{2}{4} \cdot \frac{1}{3} = \frac{2}{n(n-1)} \geqslant \frac{2}{n^2}.</tex> |
Теорема доказана. | Теорема доказана. | ||
}} | }} | ||
− | Таким образом, мы видим, что вероятность получить правильный ответ после единичного запуска функции <tex>getCut</tex> очень мала. Однако, вызвав эту функцию <tex> | + | Таким образом, мы видим, что вероятность получить правильный ответ после единичного запуска функции <tex>\mathrm{getCut}</tex> очень мала. Однако, вызвав эту функцию <tex>count</tex> раз мы увеличим эту вероятность. Рассчитаем значение <tex>count</tex> такое, чтобы вероятность успеха была близка к <tex>1</tex>. |
Для этого воспользуемся следующим неравенством: | Для этого воспользуемся следующим неравенством: | ||
− | <tex> e^x \ | + | <tex> e^x \geqslant 1 + x</tex> для любого вещественного <tex>x</tex>. |
− | Вероятность того, что мы не получим правильный ответ после <tex> | + | Вероятность того, что мы не получим правильный ответ после <tex>count</tex> независимых запусков равна |
<tex dpi="140">(1-\frac{2}{n^2})^c</tex>. | <tex dpi="140">(1-\frac{2}{n^2})^c</tex>. | ||
− | Пусть <tex> | + | Пусть <tex>count = n^2\ln(n)</tex>. Тогда в силу указанного выше неравенства: |
− | <tex dpi="140">(1-\frac{2}{n^2})^ | + | <tex dpi="140">(1-\frac{2}{n^2})^{count} \leqslant e^{count \cdot (-\frac{2}{n^2})} = e^{-2 \ln(n)} = \frac{1}{n^2}</tex>. |
− | То есть, если вызвать функцию <tex>getCut</tex> <tex>n^2\ln(n)</tex> раз, и после каждой итерации запоминать минимум, то вероятность того, что найденный ответ будет неверен <tex> \ | + | То есть, если вызвать функцию <tex>\mathrm{getCut}</tex> <tex>n^2\ln(n)</tex> раз, и после каждой итерации запоминать минимум, то вероятность того, что найденный ответ будет неверен <tex> \leqslant \frac{1}{n^2}</tex>. Даже при небольших значениях <tex>n</tex> алгоритм практически гарантированно выдает правильный ответ. |
== Оценка времени работы алгоритма == | == Оценка времени работы алгоритма == | ||
− | Время работы функции <tex>getCut</tex> {{---}} <tex>O(n^2)</tex>. Функция работает <tex>O(n^2\log(n))</tex> раз. Итоговое время работы {{---}} <tex>O(n^4 \log(n))</tex>. | + | Время работы функции <tex>\mathrm{getCut}</tex> {{---}} <tex>O(n^2)</tex>. Функция работает <tex>O(n^2\log(n))</tex> раз. Итоговое время работы {{---}} <tex>O(n^4 \log(n))</tex>. |
== Оптимизация алгоритма == | == Оптимизация алгоритма == | ||
− | Каргер совместно со Штейном (англ. ''Stein'') придумали оптимизацию алгоритма Каргера, значительно ускоряющую время его работы. Новый алгоритм называется в честь обоих создателей {{---}} алгоритм Каргера-Штейна (англ. ''Karger-Stein algorithm''). Его суть заключается в следуюшем. Заметим, что вероятность стягивания вершины, принадлежащей минимальному разрезу, в начале выполнения функции <tex>getCut</tex> | + | Каргер совместно со Штейном (англ. ''Stein'') придумали оптимизацию алгоритма Каргера, значительно ускоряющую время его работы. Новый алгоритм называется в честь обоих создателей {{---}} алгоритм Каргера-Штейна (англ. ''Karger-Stein algorithm''). Его суть заключается в следуюшем. Заметим, что вероятность стягивания вершины, принадлежащей минимальному разрезу, в начале выполнения функции <tex>\mathrm{getCut}</tex> довольно мала, в то время, как вероятность стянуть ребро, которое не следует стягивать, ближе к концу работы функции существенно возрастает. Тогда будем использовать следующую рекурсивную версию алгоритма: |
− | # Запускаем функцию <tex>getCut</tex> и стягиваем ребра до тех пор, пока не останется <tex>\frac{n}{\sqrt{2}}</tex> вершин. | + | # Запускаем функцию <tex>\mathrm{getCut}</tex> и стягиваем ребра до тех пор, пока не останется <tex>\frac{n}{\sqrt{2}}</tex> вершин. |
# Запускаем независимо эту же функцию для получившегося графа дважды и возвращаем минимальный из ответов. | # Запускаем независимо эту же функцию для получившегося графа дважды и возвращаем минимальный из ответов. | ||
− | Такая модификация алгоритма выдает правильный ответ с точностью, не менее <tex>\frac{1}{\log(n)}</tex>. Время работы функции <tex>getCut</tex> вычисляется рекурсивной функцией: | + | Такая модификация алгоритма выдает правильный ответ с точностью, не менее <tex>\frac{1}{\log(n)}</tex>. Время работы функции <tex>\mathrm{getCut}</tex> вычисляется рекурсивной функцией: |
− | <tex>T(n) = O(n^2) + T(n/\sqrt{2}) = O(n^2\log(n))</tex>. | + | <tex>T(n) = O(n^2) + 2 * T(n/\sqrt{2}) = O(n^2\log(n))</tex>. |
− | Это медленнее, чем оригинальный алгоритм, однако вероятность нахождения разреза минимального веса экспоненциально выше. Достаточно запустить алгоритм <tex>c\log^2(n)</tex>, где <tex>c</tex> - некоторая константа. Действительно, рассчитаем вероятность неправильного ответа также, как раньше: | + | Это медленнее, чем оригинальный алгоритм, однако вероятность нахождения разреза минимального веса экспоненциально выше. Достаточно запустить алгоритм <tex>c\log^2(n)</tex> раз, где <tex>c</tex> - некоторая константа. Действительно, рассчитаем вероятность неправильного ответа также, как раньше: |
− | <tex dpi="160">(1-\frac{1}{log(n)})^{c\log^2(n)} \ | + | <tex dpi="160">(1-\frac{1}{log(n)})^{c\log^2(n)} \leqslant e^{c\log^2(n) \cdot -\frac{1}{log(n)}} = \frac{1}{n^c}.</tex> |
Итоговое время работы {{---}} <tex> O(n^2\log(n)) \cdot c\log^2(n) = O(n^2\log^3(n))</tex>. | Итоговое время работы {{---}} <tex> O(n^2\log(n)) \cdot c\log^2(n) = O(n^2\log^3(n))</tex>. |
Текущая версия на 19:07, 4 сентября 2022
Алгоритм Каргера (англ. Karger's algorithm) — рандомизированный алгоритм для нахождения минимального разреза в связном графе. Он был разработан Дэвидом Каргером (англ. David Karger) в 1993 году.
Основные определения
Пусть мультиграф с множеством вершин и множеством ребер , и , .
— неориентированныйОпределение: |
Стягиванием (англ. contraction) ребра
| назовем следующую последовательность действий:
Определение: |
Мультивершиной (англ. supervertex) называется вершина, полученная из двух вершин стягиванием ребра между ними, каждая из которых, в свою очередь, может быть также мультивершиной. |
Определение: |
Стянутым графом (англ. contracted graph) называется граф, состоящий из двух мультивершин или одной мультивершины и одной обычной вершины (которую, чтобы избежать оговорок в дальнейшем, также будем называть мультивершиной), полученный из исходного графа последовательным стягиванием произвольных ребер. |
Определение: |
Разрезом (англ. cut)
| называется разбиение множества на два множества и , удовлетворяющее следующим условиям:
Такой разрез часто называют также глобальным разрезом, чтобы отличать его от . -разреза
Определение: |
Вес разреза
| обозначается и вычисляется по формуле:
Задача поиска разреза минимальной веса (англ. min-cut problem) заключается в поиске разреза минимального веса среди всех возможных разрезов исходного графа. Эту задачу можно решить с помощью любого из алгоритмов поиска максимального потока, зафиксировав произвольную вершину в качестве истока и запуская его раз для всех возможных стоков. Если использовать быстрый алгоритм поиска максимального потока, работающий за , то время работы такого алгоритма поиска минимального разреза будет . Ниже описан более простой в реализации и сравнимый по скорости алгоритм Каргера. При некоторых оптимизациях, этот алгоритм работает значительно быстрее, чем использование алгоритмов поиска максимального потока.
Алгоритм
Пусть нам дан граф
int minCut(G):
answer =
for i = 1 to count
curCut = getCut(G)
if curCut < answer
answer = curCut
return answer
Так как алгоритм вероятностный и функция
int getCut(graph): G = graph vertexCount = количество вершин в G while vertexCount > 2 edge = случайное ребро из G contract(edge) //стягиваем ребро edge vertexCount-- edgeCount = количество ребер в G return edgeCount
Корректность алгоритма
Докажем корректность алгоритма. Для удобства доказательства и оценок вероятностей, будем считать, что мы ищем не просто вес минимального разреза, а величину конкретного минимального разреза. То есть зафиксируем какой-то один из минимальных разрезов, и если функция
вернет правильный вес, но посчитает его на другом минимальном разрезе, то будем считать, что ответ получен неверный. Это условие не ухудшает оценки вероятностей и время работы алгоритма.Лемма (1): |
Пусть — некоторая мультивершина, и - какие-то две из вершин, которые были стянуты в вершину . Тогда существует такой путь в исходном графе между вершинами и , что ко всем ребрам этого пути была применена операция стягивания. |
Доказательство: |
Рассмотрим подграф | исходного графа в который входят все ребра, которые были стянуты в вершину . Очевидно, что связен, а значит в нем существует путь между его любыми двумя вершинами. Следовательно, существует путь между и , состоящий из стянутых ребер. Лемма доказана.
Лемма (2): |
Если стянуть некоторое ребро в графе G, то вес минимального разреза в графе будет не меньше чем вес минимального разреза в исходном графе . |
Доказательство: |
Составим биекцию между ребрами графов | и , не рассматривая ребра между вершинами и в графе . Очевидно, что это возможно, исходя из следующих соображений. Все ребра в , не инцидентные вершинам и , остались без изменений, а всем ребрам, инцидентным этим вершинам, по определению стягивания можно сопоставить новое ребро в . Пусть — минимальный разрез в графе , и, не уменьшая общности, . Рассмотрим разрез в графе . Исходя из биекции между ребрами и тем, что все ребра вида не пересекают разрез (так как ), то . Тогда если разрез в графе — минимален, вес минимального разреза в совпадает с весом минимального размера в . Если в существует разрез меньшего веса, то вес минимального разреза в больше чем в . Лемма доказана.
Лемма (3): |
Пусть — вес минимального потока в графе . Тогда . |
Доказательство: |
Заметим, что, чтобы выполнялось условие, степень каждой вершины должна быть не менее, чем лемме о рукопожатиях имеем, что . Лемма доказана. | . Действительно, пусть для некоторой вершины . Тогда , что противоречит условию. Далее, по
Лемма (4): |
Функция после своего выполнения получит стянутый граф соответствующий конкретному разрезу исходного графа тогда и только тогда, когда ни одно ребро, принадлежащее разрезу , не будет стянуто. |
Доказательство: |
Необходимость. От противного. Если некоторое ребро Достаточность. Пусть ни одно ребро, принадлежащее разрезу , принадлежащее разрезу в будет стянуто, то обе вершины и будут принадлежать одной мультивершине, а значит не соответствует разрезу . Противоречие. не было стянуто. Рассмотрим произвольную пару вершин и в графе . Если алгоритм стянул и в одну мультивершину в , тогда по лемме 1 существует путь между вершинами и , и все ребра этого пути были стянуты. Но пересекает разрез , что противоречит предположению, что ни одно ребро не было стянуто. Значит, вершины из любой пары , и были стянуты в разные мультивершины. А так, как стянутый граф состоит только из двух мультивершин, значит одна из них была получена стягиванием всех вершин из , а другая — из . Лемма доказана. |
Теорема: |
Для вероятности того, что функция после своего выполнения получит стянутый граф соответствующий конкретному разрезу исходного графа верна следующая оценка снизу — . |
Доказательство: |
По лемме 4 искомый стянутый граф будет получен тогда и только тогда, когда ни одно из ребер разреза не будет стянуто. Так как на каждой итерации алгоритма мы случайно выбираем ребро для стягивания, то можно оценить вероятность того, что ни одно из ребер разреза не будет стянуто. Каждое стягивание уменьшает количество ребер на . Таким образом после -ой итерации алгоритма количество вершин в текущем графе будет равно . Рассчитаем вероятность того, что на -ой итерации будет стянуто ребро из разреза . Пусть . По лемме 2 величина минимального потока в текущем графе будет не меньше, чем , и в нем будет не менее вершин по лемме 3. Тогда вероятность того, что будет стянуто ребро из разреза , при условии, что до этого не было стянуто ни одно из ребер разреза, будет не более
Обозначим за событие, что на -ой итерации случайным образом будет выбрано ребро из разреза . Тогда мы только что установили, что
Тогда вероятность того, что во время работы функции не будет стянуто ни одно ребро оценивается следующим образом:
Теорема доказана. |
Таким образом, мы видим, что вероятность получить правильный ответ после единичного запуска функции
очень мала. Однако, вызвав эту функцию раз мы увеличим эту вероятность. Рассчитаем значение такое, чтобы вероятность успеха была близка к .Для этого воспользуемся следующим неравенством:
для любого вещественного .
Вероятность того, что мы не получим правильный ответ после
независимых запусков равна.
Пусть
. Тогда в силу указанного выше неравенства:.
То есть, если вызвать функцию
раз, и после каждой итерации запоминать минимум, то вероятность того, что найденный ответ будет неверен . Даже при небольших значениях алгоритм практически гарантированно выдает правильный ответ.Оценка времени работы алгоритма
Время работы функции
— . Функция работает раз. Итоговое время работы — .Оптимизация алгоритма
Каргер совместно со Штейном (англ. Stein) придумали оптимизацию алгоритма Каргера, значительно ускоряющую время его работы. Новый алгоритм называется в честь обоих создателей — алгоритм Каргера-Штейна (англ. Karger-Stein algorithm). Его суть заключается в следуюшем. Заметим, что вероятность стягивания вершины, принадлежащей минимальному разрезу, в начале выполнения функции
довольно мала, в то время, как вероятность стянуть ребро, которое не следует стягивать, ближе к концу работы функции существенно возрастает. Тогда будем использовать следующую рекурсивную версию алгоритма:- Запускаем функцию и стягиваем ребра до тех пор, пока не останется вершин.
- Запускаем независимо эту же функцию для получившегося графа дважды и возвращаем минимальный из ответов.
Такая модификация алгоритма выдает правильный ответ с точностью, не менее
. Время работы функции вычисляется рекурсивной функцией:.
Это медленнее, чем оригинальный алгоритм, однако вероятность нахождения разреза минимального веса экспоненциально выше. Достаточно запустить алгоритм
раз, где - некоторая константа. Действительно, рассчитаем вероятность неправильного ответа также, как раньше:
Итоговое время работы —
.Источники
- Jon Kleinberg, Éva Tardos. Algorithm Design, section 13.2. Min-Cut and Randomization.
- Karger's algorithm — Wikipedia
- Lecture notes for CPSC 536N "Randomized Algorithms"