E038. Minimum spanning tree. Prim's algorithm

Источник: e-maxx.ru/algo, страница PDF 118.

Дан взвешенный неориентированный グラフ

с

vertexми и

рёбрами. it is required find такое под木

этого グラフа, которое бы соединяло все его вершины, и при этом обладало наименьшим возможным весом (т.е. суммой весов рёбер). Под木 — это набор рёбер, соединяющих все вершины, причём из любой вершины можно добраться до любой другой ровно одним простым путём. Такое под木 называется минимальным остовным 木м или просто минимальным остовом.

Легко понять, что любой остов обязательно будет содержать

edge. В естественной постановке эта 問題 звучит следующим образом: есть

городов, и для каждой

пары известна стоимость соединения их дорогой (либо известно, что соединить их нельзя). it is required соединить все города так, чтобы можно было доехать из любого города в другой, а при этом стоимость прокладки дорог была бы минимальной.

Prim's algorithm

Этот アルゴリズム назван в честь американского математика Роберта Прима (Robert Prim), который открыл этот アルゴリズム в 1957 г. Впрочем, ещё в 1930 г. этот アルゴリズム был открыт чешским математиком Войтеком Ярником (Vojtěch Jarník). Кроме того, Эдгар Дейкстра (Edsger Dijkstra) в 1959 г. также изобрёл этот アルゴリズム, независимо от них.

Описание アルゴリズムа

Сам アルゴリズム имеет очень простой вид. Искомый minimum остов строится постепенно, добавлением в него рёбер по одному. Изначально остов полагается состоящим из единственной вершины (её можно выбрать произвольно). Затем выбирается edge минимального веса, исходящее из этой вершины, и добавляется в minimum остов. После этого остов содержит уже две вершины, и теперь ищется и добавляется edge минимального веса, имеющее один конец в одной из двух выбранных вершин, а другой — наоборот, во всех остальных, кроме этих двух. И так далее, т.е. всякий раз ищется минимальное по весу edge, один конец которого — уже взятая в остов vertex, а другой конец — ещё не взятая, и это edge добавляется в остов (если таких рёбер несколько, можно взять любое). Этот процесс повторяется до тех пор, пока остов не станет содержать все

вершины (или, что то же самое,

edge). В итоге будет построен остов, являющийся минимальным. Если グラフ был изначально не связен, то остов найден не

будет (количество выбранных рёбер останется меньше

).

証明

Пусть グラフ

был связным, т.е. ответ существует. Обозначим через

остов, найденный アルゴリズムом Прима, а через

— minimum остов. Очевидно, что

действительно является остовом (т.е. под木м グラフа

). Покажем,

что веса

и

совпадают.

Рассмотрим первый момент времени, когда в

происходило добавление ребра, не 入力ящего в оптимальный остов

. Обозначим это edge через

, концы его — через

и

, а множество 入力ящих на тот момент в остов вершин —

через

(согласно アルゴリズムу,

,

, либо наоборот). В оптимальном остове

вершины

и

соединяются каким-то путём

; найдём в этом пути любое edge

, один конец которого лежит в

, а другой —

нет. Поскольку Prim's algorithm выбрал edge

вместо ребра

, то это значит, что вес ребра

больше либо равен

весу ребра

.

Удалим теперь из

edge

, и добавим edge

. По только что сказанному, вес остова в результате не мог

увеличиться (уменьшиться он тоже не мог, поскольку

было оптимальным). Кроме того,

не перестало быть остовом

(в том, что связность не нарушилась, нетрудно убедиться: мы замкнули путь

в цикл, и потом удалили из этого

цикла одно edge).

Итак, мы показали, что можно выбрать оптимальный остов

таким образом, что он будет включать edge

. Повторяя

эту процедуру необходимое number раз, мы получаем, что можно выбрать оптимальный остов

так, чтобы он совпадал

с

. Следовательно, вес построенного アルゴリズムом Прима

минимален, что и требовалось доказать.

Реализации

実行時間 アルゴリズムа существенно зависит от того, каким образом мы производим поиск очередного минимального ребра среди подходящих рёбер. Здесь могут быть разные подходы, приводящие к разным Asymptotic complexityм и разным 実装м.

Тривиальная 実装: アルゴリズムы за

и

Если искать каждый раз edge простым просмотром среди всех возможных вариантов, то асимптотически

будет требоваться просмотр

рёбер, чтобы find среди всех допустимых edge с наименьшим весом.

Суммарная Asymptotic complexity アルゴリズムа составит в таком случае

, что в худшем случае есть

, —

слишком медленный アルゴリズム. Этот アルゴリズム можно улучшить, если просматривать каждый раз не все рёбра, а только по одному ребру из каждой уже выбранной вершины. Для этого, на例, можно отсортировать рёбра из каждой вершины в порядке возрастания весов, и хранить указатель на первое допустимое edge (напомним, допустимы только те рёбра, которые ведут в множество ещё не выбранных вершин). Тогда, если пересчитывать эти указатели при каждом

добавлении ребра в остов, суммарная Asymptotic complexity アルゴリズムа будет

, но предварительно

поit is required выполнить сортировку всех рёбер за

, что в худшем случае (для плотных グラフов)

даёт асимптотику

. Ниже мы рассмотрим два немного других アルゴリズムа: для плотных и для разреженных グラフов, получив в итоге заметно лучшую асимптотику.

Случай плотных グラフов: アルゴリズム за

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

у каждой не выбранной ещё вершины — Asymptotic complexity составит

. Но теперь при добавлении в остов очередного ребра и вершины эти указатели надо пересчитывать. Заметим, что эти указатели могут только уменьшаться, т.е. у каждой не просмотренной ещё вершины надо либо оставить её указатель без изменения, либо присвоить ему вес ребра в только что добавленную вершину. Следовательно, эту

фазу можно сделать также за

. Таким образом, мы получили вариант アルゴリズムа Прима с асимптотикой . В частности, такая 実装 особенно удобна для решения так называемой евклидовой задачи

о минимальном остове: когда given

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

по стандартной евклидовой метрике, и it is required find остов минимального веса, соединяющий их все (причём добавлять новые вершины где-либо в других местах запрещается). Эта 問題 решается описанным здесь アルゴリズムом

за

времени и

памяти, чего не получится добиться アルゴリズムом Крускала. 実装 アルゴリズムа Прима для グラフа, заданного матрицей смежности :

// 入力ные данные

int n;

vector < vector<int> > g;

const int INF = 1000000000; // значение "бесконечность"

// アルゴリズム

vector<bool> used (n);

vector<int> min_e (n, INF), sel_e (n, -1);

min_e[0] = 0;

for (int i=0; i<n; ++i) {

int v = -1;

for (int j=0; j<n; ++j)

if (!used[j] && (v == -1 || min_e[j] < min_e[v]))

v = j;

if (min_e[v] == INF) {

cout << "No MST!";

exit(0);

}

used[v] = true;

if (sel_e[v] != -1)

cout << v << " " << sel_e[v] << endl;

for (int to=0; to<n; ++to)

if (g[v][to] < min_e[to]) {

min_e[to] = g[v][to];

sel_e[to] = v;

} }

На 入力 подаются number вершин

и матрица

размера

, в которой отмечены веса рёбер, и стоят

числа

, если соответствующее edge отсутствует. アルゴリズム поддерживает три 配列а: флаг

означает, что vertex

включена в остов, величина

хранит вес наименьшего

допустимого ребра из вершины

, а element

содержит конец этого наименьшего ребра (это нужно для

вывода рёбер в ответе). アルゴリズム делает

шагов, на каждом из которых выбирает вершину

с наименьшей

меткой

, помечает её

, и затем просматривает все рёбра из этой вершины, пересчитывая их метки.

Случай разреженных グラフов: アルゴリズム за

В описанном выше アルゴリズムе можно увидеть стандартные операции нахождения минимума в множестве и изменение значений в этом множестве. Эти две операции являются классическими, и выполняются многими структурами данных, на例, реализованным в языке C++ красно-чёрным 木м set. По смыслу アルゴリズム остаётся точно таким же, однако теперь мы можем find минимальное edge за время .

С другой стороны, время на пересчёт

указателей теперь составит

, что хуже, чем в

вышеописанном アルゴリズムе.

Если учесть, что всего будет

пересчётов указателей и

поисков минимального ребра, то

суммарная Asymptotic complexity составит

— для разреженных グラフов это лучше, чем оба

вышеописанных アルゴリズムа, но на плотных グラフах этот アルゴリズム будет медленнее предыдущего. 実装 アルゴリズムа Прима для グラフа, заданного списками смежности :

// 入力ные данные

int n;

vector < vector < pair<int,int> > > g;

const int INF = 1000000000; // значение "бесконечность"

// アルゴリズム

vector<int> min_e (n, INF), sel_e (n, -1);

min_e[0] = 0;

set < pair<int,int> > q;

q.insert (make_pair (0, 0));

for (int i=0; i<n; ++i) {

if (q.empty()) {

cout << "No MST!";

exit(0);

}

int v = q.begin()->second;

q.erase (q.begin());

if (sel_e[v] != -1)

cout << v << " " << sel_e[v] << endl;

for (size_t j=0; j<g[v].size(); ++j) {

int to = g[v][j].first,

cost = g[v][j].second;

if (cost < min_e[to]) {

q.erase (make_pair (min_e[to], to));

min_e[to] = cost;

sel_e[to] = v;

q.insert (make_pair (min_e[to], to));

} } }

На 入力 подаются number вершин

и

списков смежности:

— это список всех рёбер, исходящих из вершины

, в

виде пар (второй конец ребра, вес ребра). アルゴリズム поддерживает два 配列а: величина

хранит

вес наименьшего допустимого ребра из вершины

, а element

содержит конец этого наименьшего ребра

(это нужно для вывода рёбер в ответе). Кроме того, поддерживается очередь

из всех вершин в порядке увеличения

их меток

. アルゴリズム делает

шагов, на каждом из которых выбирает вершину

с наименьшей меткой

(просто извлекая её из начала очереди), и затем просматривает все рёбра из этой вершины, пересчитывая их метки (при пересчёте мы удаляем из очереди старую величину, и затем кладём обратно новую).

Аналогия с アルゴリズムом Дейкстры

В двух описанных только что アルゴリズムах прослеживается вполне чёткая аналогия с アルゴリズムом Дейкстры: он имеет

такую же структуру (

фаза, на каждой из которых сначала выбирается оптимальное edge, добавляется в ответ, а затем пересчитываются значения для всех не выбранных ещё вершин). Более того, Dijkstra's algorithm тоже имеет

два варианта реализации: за

и

(мы, конечно, здесь не учитываем возможность

использования сложных структур данных для достижения ещё меньших асимптотик). Если взглянуть на アルゴリズムы Прима и Дейкстры более формально, то получается, что они вообще идентичны друг другу, за исключением весовой функции вершин: если в アルゴリズムе Дейкстры у каждой вершины поддерживается длина кратчайшего пути (т.е. сумма весов некоторых рёбер), то в アルゴリズムе Прима каждой вершине приписывается только вес минимального ребра, ведущего в множество уже взятых вершин. На уровне реализации это означает, что после добавления очередной вершины

в множество выбранных вершин,

когда мы начинаем просматривать все рёбра

из этой вершины, то в アルゴリズムе Прима указатель

обновляется весом ребра

, а в アルゴリズムе Дейкстры — метка расстояния

обновляется суммой метки

и веса ребра

. В остальном эти два アルゴリズムа можно считать идентичными (хоть они и решают совсем разные задачи).

Свойства минимальных остовов

● maximum остов также можно искать アルゴリズムом Прима (на例, заменив все веса рёбер

на противоположные: アルゴリズム не требует неотрицательности весов рёбер).

● minimum остов единственен, если веса всех рёбер различны. В противном случае, может

существовать несколько минимальных остовов (какой именно будет выбран アルゴリズムом Прима, зависит от порядка просмотра рёбер/вершин с одинаковыми весами/указателями)

● minimum остов также является остовом, минимальным по произведению всех

рёбер (предполагается, что все веса положительны). В самом деле, если мы заменим веса всех рёбер на их логарифмы, то легко заметить, что в работе アルゴリズムа ничего не изменится, и будут найдены те же самые рёбра.

● minimum остов является остовом с минимальным весом самого тяжёлого ребра. Яснее всего

это утверждение понятно, если рассмотреть работу アルゴリズムа Крускала.

● Критерий минимальности остова: остов является минимальным тогда и только тогда, когда для любого

ребра, не принадлежащего остову, цикл, образуемый этим edgeм при добавлении к остову, не содержит рёбер тяжелее этого ребра. В самом деле, если для какого-то ребра оказалось, что оно легче некоторых рёбер образуемого цикла, то можно получить остов с меньшим весом (добавив это edge в остов, и удалив самое тяжелое edge из цикла). Если же это 問題文 не выполнилось ни для одного ребра, то все эти рёбра не улучшают вес остова при их добавлении.

using System;
using System.Collections.Generic;
using System.Linq;

public static class AlgorithmDraft
{
    // Auto-generated C# draft from the original e-maxx C/C++ listing. Review before production use.
    // входные данные
    int n;
    vector < List<int> > g;
    const int INF = 1000000000; // значение "бесконечность"
    // алгоритм
    List<bool> used (n);
    List<int> min_e (n, INF), sel_e (n, -1);
    min_e[0] = 0;
    for (int i=0; i<n; ++i) {
            int v = -1;
            for (int j=0; j<n; ++j)
                    if (!used[j] && (v == -1 || min_e[j] < min_e[v]))
                            v = j;
            if (min_e[v] == INF) {
                    Console.WriteLine( "No MST!";
                    exit(0);
            }
            used[v] = true;
            if (sel_e[v] != -1)
                    Console.WriteLine( v << " " << sel_e[v] << endl;
            for (int to=0; to<n; ++to)
                    if (g[v][to] < min_e[to]) {
                            min_e[to] = g[v][to];
                            sel_e[to] = v;
                    }
    }
    // входные данные
    int n;
    vector < vector < pair<int,int> > > g;
    const int INF = 1000000000; // значение "бесконечность"
    // алгоритм
    List<int> min_e (n, INF), sel_e (n, -1);
    min_e[0] = 0;
    set < pair<int,int> > q;
    q.insert (make_pair (0, 0));
    for (int i=0; i<n; ++i) {
            if (q.empty()) {
                    Console.WriteLine( "No MST!";
                    exit(0);
            }
            int v = q.begin()->second;
            q.erase (q.begin());
            if (sel_e[v] != -1)
                    Console.WriteLine( v << " " << sel_e[v] << endl;
            for (size_t j=0; j<g[v].size(); ++j) {
                    int to = g[v][j].first,
                            cost = g[v][j].second;
                    if (cost < min_e[to]) {
                            q.erase (make_pair (min_e[to], to));
                            min_e[to] = cost;
                            sel_e[to] = v;
                            q.insert (make_pair (min_e[to], to));
                    }
            }
    }
}

// входные данные
int n;
vector < vector<int> > g;
const int INF = 1000000000; // значение "бесконечность"
// алгоритм
vector<bool> used (n);
vector<int> min_e (n, INF), sel_e (n, -1);
min_e[0] = 0;
for (int i=0; i<n; ++i) {
        int v = -1;
        for (int j=0; j<n; ++j)
                if (!used[j] && (v == -1 || min_e[j] < min_e[v]))
                        v = j;
        if (min_e[v] == INF) {
                cout << "No MST!";
                exit(0);
        }
        used[v] = true;
        if (sel_e[v] != -1)
                cout << v << " " << sel_e[v] << endl;
        for (int to=0; to<n; ++to)
                if (g[v][to] < min_e[to]) {
                        min_e[to] = g[v][to];
                        sel_e[to] = v;
                }
}
// входные данные
int n;
vector < vector < pair<int,int> > > g;
const int INF = 1000000000; // значение "бесконечность"
// алгоритм
vector<int> min_e (n, INF), sel_e (n, -1);
min_e[0] = 0;
set < pair<int,int> > q;
q.insert (make_pair (0, 0));
for (int i=0; i<n; ++i) {
        if (q.empty()) {
                cout << "No MST!";
                exit(0);
        }
        int v = q.begin()->second;
        q.erase (q.begin());
        if (sel_e[v] != -1)
                cout << v << " " << sel_e[v] << endl;
        for (size_t j=0; j<g[v].size(); ++j) {
                int to = g[v][j].first,
                        cost = g[v][j].second;
                if (cost < min_e[to]) {
                        q.erase (make_pair (min_e[to], to));
                        min_e[to] = cost;
                        sel_e[to] = v;
                        q.insert (make_pair (min_e[to], to));
                }
        }
}

import java.util.*;
import java.math.*;

public class AlgorithmDraft {
    // Auto-generated Java draft from the original e-maxx C/C++ listing. Review before production use.
    // входные данные
    int n;
    vector < ArrayList<Integer> > g;
    const int INF = 1000000000; // значение "бесконечность"
    // алгоритм
    ArrayList<Boolean> used (n);
    ArrayList<Integer> min_e (n, INF), sel_e (n, -1);
    min_e[0] = 0;
    for (int i=0; i<n; ++i) {
            int v = -1;
            for (int j=0; j<n; ++j)
                    if (!used[j] && (v == -1 || min_e[j] < min_e[v]))
                            v = j;
            if (min_e[v] == INF) {
                    System.out.println( "No MST!";
                    exit(0);
            }
            used[v] = true;
            if (sel_e[v] != -1)
                    System.out.println( v << " " << sel_e[v] << endl;
            for (int to=0; to<n; ++to)
                    if (g[v][to] < min_e[to]) {
                            min_e[to] = g[v][to];
                            sel_e[to] = v;
                    }
    }
    // входные данные
    int n;
    vector < vector < pair<int,int> > > g;
    const int INF = 1000000000; // значение "бесконечность"
    // алгоритм
    ArrayList<Integer> min_e (n, INF), sel_e (n, -1);
    min_e[0] = 0;
    set < pair<int,int> > q;
    q.insert (make_pair (0, 0));
    for (int i=0; i<n; ++i) {
            if (q.empty()) {
                    System.out.println( "No MST!";
                    exit(0);
            }
            int v = q.begin()->second;
            q.erase (q.begin());
            if (sel_e[v] != -1)
                    System.out.println( v << " " << sel_e[v] << endl;
            for (size_t j=0; j<g[v].size(); ++j) {
                    int to = g[v][j].first,
                            cost = g[v][j].second;
                    if (cost < min_e[to]) {
                            q.erase (make_pair (min_e[to], to));
                            min_e[to] = cost;
                            sel_e[to] = v;
                            q.insert (make_pair (min_e[to], to));
                    }
            }
    }
}