Prims algoritm

Den aktuella versionen av sidan har ännu inte granskats av erfarna bidragsgivare och kan skilja sig väsentligt från versionen som granskades den 15 juni 2020; kontroller kräver 11 redigeringar .

Prims algoritm  är en algoritm för att konstruera det minsta spännträdet för en viktad sammankopplad oriktad graf. Algoritmen upptäcktes först 1930 av den tjeckiske matematikern Wojciech Jarnik , senare återupptäckt av Robert Prim 1957, och oberoende av E. Dijkstra 1959.

Beskrivning

Algoritmens ingång är en ansluten oriktad graf. För varje kant fastställs dess kostnad.

Först tas en godtycklig vertex och en kant hittas som är infallande till denna vertex och har den lägsta kostnaden. Den hittade kanten och de två hörnen som är förbundna med den bildar ett träd. Sedan betraktas grafens kanter, vars ena ände är en vertex som redan tillhör trädet, och den andra inte är det; från dessa kanter väljs kanten av lägsta kostnad. Den kant som väljs vid varje steg läggs till i trädet. Trädet växer tills alla hörn i den ursprungliga grafen är uttömda.

Resultatet av algoritmen är en minimikostnad som spänner över trädet.

Exempel

Bild Uppsättningen av valda hörn U Kant (u, v) Uppsättningen av omarkerade hörn V \ U Beskrivning
{} {A,B,C,D,E,F,G} Den ursprungliga viktade grafen. Siffrorna bredvid kanterna visar deras vikter, vilket kan ses som avstånden mellan hörnen.
{D} (D,A) = 5V
(D,B) = 9
(D,E) = 15
(D,F) = 6
{A,B,C,E,F,G} Spetsen D är godtyckligt vald som den initiala . Var och en av hörnen A , B , E och F är ansluten till D med en enda kant. Vertex A  är närmast D , och väljs som andra vertex tillsammans med kant AD .
{A,D} (D,B) = 9
(D,E) = 15
(D,F) = 6V
(A,B) = 7
{B,C,E,F,G} Nästa hörn är den som ligger närmast någon av de valda D- eller A -punkten . B är 9 från D och 7 från A.  Avståndet till E är 15 och till F  är 6. F är närmaste vertex, så det ingår i trädet F tillsammans med kanten DF .
{A,D,F} (D,B) = 9
(D,E) = 15
(A,B) = 7 V
(F,E) = 8
(F,G) = 11
{B,C,E,G} På samma sätt väljs vertex B , som är 7 från A.
{A,B,D,F} (B,C) = 8
(B,E) = 7 V
(D,B) = 9 loop
(D,E) = 15
(F,E) = 8
(F,G) = 11
{C,E,G} I detta fall är det möjligt att välja antingen C , eller E , eller G . C är 8 från B , E är 7 från B och G är 11 från F. E  är närmaste vertex, så E och kant BE väljs .
{A,B,D,E,F} (B,C) = 8
(D,B) = 9 cykler
(D,E) = 15 cykler
(E,C) = 5 V
(E,G) = 9
(F,E) = 8 cykler
(F,G ) ) = 11
{C,G} Endast hörn C och G är tillgängliga här . Avståndet från E till C är 5 och från G  är 9. En vertex C och en kant EC väljs .
{A,B,C,D,E,F} (B,C) = 8 loopar
(D,B) = 9 loopar
(D,E) = 15 loopar
(E,G) = 9 V
(F,E) = 8 loopar
(F,G) = 11
{G} Den enda kvarvarande vertexen är G . Avståndet från F till det är 11, från E  - 9. E är närmare, så vertex G och kanten EG väljs .
{A,B,C,D,E,F,G} (B,C) = 8 cykler
(D,B) = 9 cykler
(D,E) = 15 cykler
(F,E) = 8 cykler
(F,G) = 11 cykler
{} Alla hörn är valda, det minsta spännträdet byggs (markerat i grönt). I det här fallet är dess vikt 39.

Implementering

Notation

Pseudokod

{} För varje vertex Ännu inte tom



För varje vertex som gränsar till If och

Betyg

Algoritmens asymptotik beror på hur grafen lagras och hur de hörn som inte ingår i trädet lagras. Om prioritetskön implementeras som en vanlig array , så tar det , och kostnaden för operationen är . Om representerar en binär pyramid , så minskar kostnaden till och kostnaden ökar till . När du använder Fibonacci-pyramider utförs operationen för , och för .

Sätt att representera prioriterad kö och graf Asymptotika
Array d, angränsande listor (angränsningsmatris)
Binär pyramid, angränsande listor
Fibonacci pyramid, angränsande listor

Se även

Litteratur

Länkar