Algoritmiek: Minimum Spanning Trees

Minimum Opspannende Bomen
Algoritmiek
Inhoud
• Het minimum opspannende bomen probleem
• Een principe om een minimum opspannende boom
te laten groeien
• Twee greedy algoritmen + tijd en datastructuren:
– Het algoritme van Kruskal
– Het algoritme van Prim
2
Algoritmiek
Minimum Opspannende Bomen
• Gegeven:
– Ongerichte samenhangende graaf G=(N,A)
– Lengte l(a) voor elke kant a in A.
• Gevraagd:
– Een boom T = (N, F), zodat
• T een deelboom van G is (F  A)
• Elke knoop in G in T zit
• De totale lengte van alle kanten in T zo klein
mogelijk is.
3
Algoritmiek
Voorbeeld
4
e
c
e
3
c
3
a
3
2
11
5
4
a
3
2
1
1
5
4
d
b
d
1
b
17
1
f
Opspannende boom;
Geen minimum opspannende boom
4
4
Algoritmiek
f
Minimum opspannende
boom
Toepassingen
• Verbinden van punten met zo min mogelijk
bekabeling
• Deelroute in andere algoritmen
• …
5
Algoritmiek
Greedy aanpak
• Begin met een woud
zonder kanten T=(N,)
• Herhaal tot T een boom is
– Kies een kant {v,w} en
voeg deze toe aan T,
zodat …
• Output T
6
• Noem T een goed woud
als T er een minimum
opspannende boom van G
bestaat waar T een
deelgraaf van is.
• We willen als invariant
van Greedy algoritme:
– T is een goed woud.
• Initieel geldt de invariant.
Algoritmiek
Goed woud: voorbeelden
4
4
c
e
3
3
3
2
a
d
d
1
b
b
7
3
2
1
1
5
4
5
4
a
c
e
1
f
Algoritmiek
f
Veilige kanten
• Stel T=(N,F) is een goed
woud. Een kant {v,w} is
veilig, als T’ =(N,F{v,w})
ook een goed woud is.
c
e
3
5
4
a
3
2
d
1
b
1
{a,b} is veilig
8
Algoritmiek
f
Greedy algoritme
• Begin met een woud zonder kanten T=(N,)
• Herhaal tot T een boom is
– Kies een veilige kant {v,w} en voeg deze toe
aan T
• Output T
Maar: welke kanten zijn er veilig??
9
Algoritmiek
Termen
• Deelboom in woud
• Een kant verlaat een
deelboom, als de kant
precies 1 eindpunt in de
deelboom heeft.
c
e
3
5
4
a
3
2
d
1
b
Elk van de rode
kanten verlaat de
deelboom met
knopen b en f
10
Algoritmiek
1
f
Stelling
• Stel T is een goed woud. Stel W is een deelboom
uit T. Laat de kant {v,w} deelboom W verlaten, en
minimum gewicht hebben ten opzichte van alle
kanten die W verlaten. Dan is {v,w} veilig.
c
e
3
5
4
a
3
2
{d,f} is veilig
d
1
b
11
1
f
Algoritmiek
Bewijs (1)
• Laat T, W, {v,w} als in stelling.
• Er is een minimum opspannende boom T’ van G
– die T als deelwoud heeft. (Omdat T goed is.)
• Als {v,w} in T’ zit, dan is {v,w} veilig: klaar.
• Stel dat {v,w} niet in T’ zit.
12
Algoritmiek
Bewijs (2)
• T’+{v,w} heeft een cycle.
• Deze cycle bevat zowel knopen
in W als knopen niet in W.
• Er moet nog een kant zijn die
W verlaat op de cycle, zeg a.
• T’+{v,w} – a is een
opspannende boom van G.
• De totale lengte van T’+{v,w} –
a is hooguit de totale lengte van
T’.
– Want l({v,w})  l(a).
• Dus {v,w} is veilig.
13
Algoritmiek
w
v
w
v
a
v
w
Greedy algoritme
• Begin met een woud zonder kanten T=(N,)
• Herhaal tot T een boom is
– Kies een kant {v,w} die minimum gewicht
heeft t.o.v. alle kanten die een deelboom van T
verlaten en voeg deze toe aan T
• Output T
Maar: hoe vind je zo’n kant snel?
14
Algoritmiek
Twee methoden
• Kruskal
– Groeit verschillende boompjes
– Kanten worden in volgorde met stijgende lengte
bekeken
– Test of ze in verschillende deelbomen zitten met unionfind
• Prim
– Groeit 1 boom
– Steeds wordt de goedkoopste uitgaande kant genomen
– Verschillende implementaties
15
Algoritmiek
Kruskal’s algoritme
Sorteer de kanten op niet-dalende lengte, zeg k(1),
… , k(a).
Begin met een woud zonder kanten T=(N,).
for i = 1 to a
do if kant k(i) verbindt twee verschillende boompjes
in T
then voeg kant k(i) toe aan T.
(else: we doen niets met deze kant.)
Output T.
16
Algoritmiek
Kruskal: voorbeeld
5
e
c
13
8
10
a
6
7
d
1
b
3
17
f
Algoritmiek
Implementatie Kruskal
• Gebruik disjuncte verzamelingen datastructuur uit vorige
college.
• Voor elke deelboom van T hebben we een verzameling,
die de knopen in de deelboom bevat.
• Initieel: create(v) voor elke knoop v.
• Testen of kant {v,w} tussen twee verschillende boompjes:
– Kijk of Find(v)  Find(w)
• Bij toevoegen van kant {v,w}.
– Doe: Union (Find(v), Find(w) ).
18
Algoritmiek
Analyse Kruskal
• Sorteren van de kanten kost O(a log a) = O(a log n).
• Acties op disjuncte verzamelingen datastructuur:
– O(n) creates
– O(a) find operaties
– O(n) union operaties
– O(n+a log* n) tijd totaal (eigenlijk: O(a a(n)).)
• Totaal O(a log n) tijd.
• Sneller wanneer we de kanten al gesorteerd hebben.
• Kan wat versneld worden in praktijk door te stoppen zodra
T n – 1 kanten heeft.
19
Algoritmiek
Prim’s algoritme
Kies een knoop s.
B = {s}; T=(N, )
Safe
while (B  N)
do vind kant e = {v,w} die B verlaat met minimum
lengte (v  B, w  N – B)
T = T { e};
B = B { w };
Output T.
20
Algoritmiek
Prim: voorbeeld
5
e
c
13
8
10
a
6
7
d
1
b
3
21
s
Algoritmiek
Prim geeft minimum
opspannende boom
• Steeds is geldig:
– T is goed woud
– Gekozen kant {v,w} is veilig, want heeft
minimum gewicht van alle kanten die een
bepaalde deelboom van T verlaten.
22
Algoritmiek
Idee Implementatie Prim
• Houdt voor elke knoop v
maxint
5
in N – B bij
e
13
– De lengte van de
kortste kant van een
10 8
7 a
knoop in B naar v:
dichtbij[v]
6
7
– De knoop in B die het
b
andere eindpunt is van
3
deze kant
23
Algoritmiek
c 8
9
d 1
1
s
Implementatie Prim
Kies een knoop s.
B = {s}; T = (B, );
for all v do dichtbij[v] = maxint;
for all {s,v}  A do dichtbij[v] = l({s,v}); naarb[v] = s;
while (B  N) (of: doe n – 1 keer)
do best = maxint;
for all v  N-B
do if (dichtbij[v] < best)
then best = dichtbij[v]; besteknoop = v;
T = T {{besteknoop, naarb[besteknoop]}};
B = B {besteknoop};
for all {besteknoop,w}  B
do if (l({besteknoop,w}) < dichtbij[w] )
then dichtbij[w] = l({besteknoop,w}); naarb[w] = besteknoop;
Output T.
24
Algoritmiek
Tijd Prim
•
•
•
•
Hoofdloop wordt n – 1 keer uitgevoerd.
Elke keer O(n) stappen.
Totaal O(n2) tijd.
Voor dichtbij kunnen we een priority queue gebruiken.
– O(n) keer een extract min operatie.
– O(a) keer een update van een waarde.
– Met een heap of gebalanceerde boom: O(a log n) tijd.
• Vergelijk met Kruskal: met heap is tijd vergelijkbaar op
dichte grafen; met queue implementatie sneller op ijle
grafen, maar langzamer op dichte grafen.
25
Algoritmiek
26
Algoritmiek
Uitleiding
• Vergelijk de algoritmen van Prim en Dijkstra
– Algoritmen met soortgelijke opbouw
– Details verschillen
– Probleem dat wordt opgelost verschilt
• Kortste paden vs. min opspannende bomen
• Twee verschillende greedy algoritmen voor minimum
opspannende bomen probleem
– Kruskal groeit veel bomen tegelijk
– Prim groeit een boom
27
Algoritmiek