Дискретная математика и теория алгоритмов. Учебное пособие

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

может иметь только конечное число различных остовных деревьев, а значит, среди них всегда можно выбрать дерево с минимальным общим весом.

Описание алгоритма

Алгоритм Крускала решает задачу поиска минимального остовного дерева во взвешенном связном неориентированном графе = , . Алгоритм работает с

множеством рёбер , которое растёт путём добавления к нему рёбер по одному. Перед каждой очередной итерацией является подмножеством некоторого множества , образующего минимальное остовное дерево. Алгоритм определяет такое ребро ( , ), что после его добавления множество {( , )} по-прежнему остаётся подмножеством (вообще говоря, другого) множества ′, тоже образующего мини- мальное остовное дерево. Ребро с таким свойством называется безопасным для .

В любой момент выполнения алгоритма граф = , представляет собой лес, каждый связный компонент которого является деревом. Изначально множествопусто, а лес состоит из | | одноэлементных деревьев. Алгоритм Крускала находит безопасное ребро для добавления в растущий лес в результате поиска вребра ( , ) с минимальным весом среди всех рёбер, соединяющих два дерева в

текущем лесу . Каждая итерация уменьшает количество деревьев в лесу на единицу. Когда в лесу останется только одно дерево, алгоритм завершает работу.

В алгоритме используется разбиение множества на непересекающиеся подмножества, каждое из которых состоит из вершин дерева в текущем лесу. Операция Find_Set( ) однозначно определяет, в каком из подмножеств содержится вершина

. Таким образом, чтобы установить, принадлежат ли две вершины и одному и тому же дереву, достаточно проверить равенство Find_Set( ) и Find_Set( ). Объединение деревьев ребром ( , ) выполняется при помощи процедуры Union( , ).

Алгоритм Крускала имеет следующую реализацию в виде псевдокода.

Kruskal( , )

{Вход: связный неориентированный граф = , , весовая функция : → R.} {Выход: множество такое, что , — минимальное остовное дерево.}

Процедура Kruskal работает следующим образом. В строках 01–03 происходит инициализация множества пустым множеством и создаётся | | деревьев, каждое

из которых содержит по одной вершине. В строке 04 все рёбра графа сортируются согласно их весу в неубывающем порядке. Цикл for в строках 05–08 проверяет для

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

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

Определение. Разрезом неориентированного графа = , называется разбиение , множества на два непересекающихся подмножества и .

Говорят, что ребро ( , ) пересекает разрез , , если одна из вершинили принадлежит множеству , а другая — множеству .

Говорят, что разрез графа согласован с множеством рёбер , если ни одно ребро из не пересекает данный разрез.

Пример. На рисунке проиллюстрирован пример разреза взвешенного связного неориентированного графа. Вершины множества окрашены в серый цвет, вершины

— в белый. Выделенные цветом рёбра образуют множество . Приведённый на рисунке разрез согласован с множеством .

Лемма 19 (свойство разреза). Пусть = , — взвешенный связный неориентированный граф с весовой функцией : → R. Пусть — подмножество , которое входит в некоторое минимальное остовное дерево графа ; , — разрез графа , согласованный с ; а ( , ) — ребро, пересекающее разрез , и имеющее минимальный вес среди всех рёбер, пересекающих данный разрез. Тогда ребро ( , ) является безопасным для .

Доказательство. По условию существует такое, что и , — минимальное остовное дерево. Если ( , ) , то лемма доказана. Поэтому предположим,

вырезания и вставки рёбер.

Поскольку , — остовное дерево для , в нём найдётся путь из вершины к вершине . Ребро ( , ) образует цикл с рёбрами на пути (см. рисунок).

Поскольку и находятся на разных сторонах разреза , , на пути найдётся ребро ( , ) , которое пересекает данный разрез. Ребро ( , ) не принадлежит, т.к. разрез согласован с . По теореме 4 удаление ребра ( , ) из разбивает дерево , на два связных компонента, а добавления ребра ( , ) восстанавливает связность. Следовательно, множество рёбер

′ = ( {( , )}) {( , )}

задаёт на вершинах из связный граф , ′ . Граф , ′ также является ациклическим. Для этого достаточно заметить, что если бы граф , ′ содержал цикл, включающий ребро ( , ), то, заменив ( , ) в цикле на путь , мы получили бы цикл в дереве , , что невозможно. Таким образом, , ′ — остовное дерево для графа .

Докажем, что , ′ — минимальное остовное дерево. Поскольку ребро ( , ) имеет минимальный вес среди всех рёбер, пересекающих разрез , , и ребро ( , ) тоже пересекает данный разрез, заключаем, что ( , ) 6 ( , ). Тогда

( ′) = ( ) − ( , ) + ( , ) 6 ( ).

С другой стороны, в силу минимальности общего веса , имеем ( ) 6 ( ′). Таким образом, ( ′) = ( ) и, значит, множество ′ тоже задаёт минимальное остовное дерево для графа .

Остаётся показать, что ( , ) — безопасное ребро для . Действительно, из усло-

Теорема 20 (о корректности алгоритма Крускала) . Пусть = , — взвешенный связный неориентированный граф с весовой функцией : → R и пусть

— множество рёбер, полученное в результате применения процедуры Kruskal к графу и функции . Тогда граф , является минимальным остовным деревом

для .

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

ном дереве, при этом граф = , является лесом. После инициализации в строке 01 множество пусто. Ясно, что пустое множество рёбер содержится в мини-

мальном остовном дереве, существующем в силу предложения 18. Кроме этого, граф с пустым множеством рёбер, очевидно, является лесом, состоящим из одноэлементных деревьев.

Пусть перед очередной итерацией цикла for (строки 05–08) множество включается в некоторое , образующее минимальное остовное дерево, и пусть на данной итерации в добавляется ребро ( , ). По построению ребро ( , ) соединяет

связный компонент в лесу с некоторым другим связным компонентом. Тогда разрез , согласован с , а ребро ( , ) пересекает этот разрез.

Покажем, что ребро ( , ) имеет минимальный вес среди всех рёбер, пересекающих разрез , . Любое ребро ( , ) с весом ( , ) < ( , ) было рассмотрено на одной из предыдущих итераций. Следовательно, либо ребро ( , ) уже попало в и тогда не пересекает разрез , , либо концы ребра ( , ) в мо-

мент его просмотра лежали в одном связном компоненте. Заметим, что в процессе исполнения процедуры Kruskal связные компоненты могут только объединяться.

Отсюда следует, что если в момент просмотра ребра ( , ) его концы попали в один

связный компонент, то они будут находиться в одном связном компоненте и в момент просмотра ребра ( , ), и значит, ребро ( , ) не может пересекать разрез , .

Таким образом, если какое-то ребро пересекает разрез , , то вес данного ребра не меньше чем ( , ). Следовательно, ( , ) имеет минимальный вес среди всех рёбер, пересекающих указанный разрез. Отсюда, в силу леммы 19, заключаем, что ребро ( , ) является безопасным для текущего множества . Следовательно, множество {( , )} тоже содержится в некотором минимальном остовном дереве, а граф , {( , )} является лесом, поскольку получается путём объединения двух деревьев из леса .

Пусть теперь — итоговое множество рёбер, возвращаемое агоритмом в строке 09. В силу доказанного выше, существует такое, что и граф , является минимальным остовным деревом. Остаётся доказать включение . Допустим, напротив, существует ребро ( , ) такое, что ( , ) / . Следовательно, в момент просмотра ребра ( , ) вершины и лежат в одном связном компоненте растущего леса. Тогда и в итоговом лесу вершины и тоже лежат в одном связном компоненте. Поэтому существует путь по рёбрам из , начинающийся в вершине и заканчивающийся в вершине , причём не совпадает с ребром ( , ), поскольку ( , ) / . Из включения следует, что путь полностью содержится в дереве , . Добавив к пути ребро ( , ) , мы получим в дереве , цикл, что невозможно. Таким образом, = и , является минимальным остовным деревом.

Время работы алгоритма

Инициализация множества в строке 01 занимает время (1). Дальнейшее время работы алгоритма Крускала зависит от выбранного способа сортировки весов рёбер и от реализации структуры разбиения множества вершин на непересекающиеся

подмножества.

Будем использовать быструю сортировку весов рёбер в неубывающем порядке с помощью сортировки слиянием, т.е. применяя процедуру Merge_Sort к массиву

1, . . . , , состоящему из весов рёбер графа , где = | |. Тогда общее время сортировки составляет (| |· log2 | |).

Каждое множество из разбиения на непересекающиеся подмножества мы будем хранить в виде ориентированного дерева. Вершины этого дерева — элементы множества. Для каждой вершины , кроме корня, определён предшественник [ ] в дереве.

Для корня считаем, что [ ] = . Таким образом, ориентированные рёбра имеют вид ( , [ ]), включая петлю на корне . Помимо указателя на предшественника для

каждой вершины определён ранг, который обозначается через [ ] и совпадает с высотой поддерева, растущего из вершины .

Не каждое такое ориентированное дерево может возникнуть в ходе исполнения процедуры Kruskal. Нас интересуют только те ориентированные деревья, которые могу возникнуть в результате применения операций Make_Set и Union.

Процедура, создающая дерево из одной вершины, занимает время (1) и имеет следующий псевдокод:

Make_Set( )

01 [ ] ←

02 [ ] ← 0

Корень дерева можно рассматривать как представитель соответствующего множества. Тогда процедура, определяющая, в каком из подмножеств разбиения содер-

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

Find_Set( )

01 while ̸= [ ]

02 do ← [ ]

03 return

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

Union( , )

Время работы процедуры Union( , ) пропорционально сумме высот объединяемых деревьев.

Пример. На рисунке приведён пример последовательного использования процедур Make_Set и Union. В верхних индексах вершин указаны их ранги.

После применения Union( , ), Union( , ) и Union( , ):

n1? n1? n1? n0?

Итак, все рассматриваемые множества из разбиения на подмножества получа-

ются только путём применения процедур Make_Set и Union. Отсюда следует, что дерево высоты получается только при объединении двух деревьев высоты − 1.

Тогда, используя индукцию по , можно показать, что вершина ранга имеет не менее 2 потомков, включая её саму.

Докажем, что имеется не более | |/2 элементов ранга . Допустим, напротив, количество вершин ранга равно и при этом > | |/2 . Каждая из этих вершин имеет не менее 2 потомков. Следовательно, множество содержит не менее· 2 элементов. В силу нашего предположения, · 2 > (| |/2 ) · 2 = | |, что, очевидно, невозможно. Теперь покажем, что ранг любого элемента не превосходит

Общее количество вершин ранга не превосходит | |/2

соотношений | |/2 < | |/2log2 | | = 1 заключаем, что в множестве вершины рангаотсутствуют.

Итак, ранг любого элемента не превосходит log2 | |. Значит, все ориентированные деревья имеют высоту не более чем log2 | |, откуда следует, что время работы каждой из процедур Find_Set и Union составляет (log2 | |).

Всего в процедуре Kruskal используется | | операций Make_Set, 2·| | операций Find_Set и | | − 1 операций Union. Следовательно, общее время рабо-

ты над непересекающимися множествами составляет (| | + (| | + | |)· log2 | |) = = ((| | + | |)· log2 | |). Поскольку граф связный, имеет место соотношение | | > | | − 1, так что операции над непересекающимися множествами требуют вре-

мя (| |· log2 | |). Добавив к этому времени время, затрачиваемое на сортировку рёбер, получаем (| |· log2 | | + | |· log2 | |). Из неравенства | | 6 | |2 следует, что log2 | | 6 log2 | |2 = 2 log2 | |. Поэтому общее время работы алгоритма Крускала

составляет (| |· log2 | |).