Minimum Opspannende Bomen Algoritmiek

2 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

Algoritmiek3 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.

Algoritmiek4 Voorbeeld e d f a b c e d f a b c Opspannende boom; Geen minimum opspannende boom Minimum opspannende boom 17 11

Algoritmiek5 Toepassingen Verbinden van punten met zo min mogelijk bekabeling Deelroute in andere algoritmen …

Algoritmiek6 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 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.

Algoritmiek7 Goed woud: voorbeelden e d f a b c e d f a b c

Algoritmiek8 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. e d f a b c {a,b} is veilig

Algoritmiek9 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??

Algoritmiek10 Termen Deelboom in woud Een kant verlaat een deelboom, als de kant precies 1 eindpunt in de deelboom heeft. e d f a b c Elk van de rode kanten verlaat de deelboom met knopen b en f

Algoritmiek11 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. e d f a b c {d,f} is veilig

Algoritmiek12 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.

Algoritmiek13 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. v w v w v w a

Algoritmiek14 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?

Algoritmiek15 Twee methoden Kruskal –Groeit verschillende boompjes –Kanten worden in volgorde met stijgende lengte bekeken –Test of ze in verschillende deelbomen zitten met union- find Prim –Groeit 1 boom –Steeds wordt de goedkoopste uitgaande kant genomen –Verschillende implementaties

Algoritmiek16 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.

Algoritmiek17 Kruskal: voorbeeld e d f a b c

Algoritmiek18 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) ).

Algoritmiek19 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  (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.

Algoritmiek20 Prim’s algoritme Kies een knoop s. B = {s}; T=(N,  ) 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. Safe

Algoritmiek21 Prim: voorbeeld e d s a b c

Algoritmiek22 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.

Algoritmiek23 Idee Implementatie Prim Houdt voor elke knoop v in N – B bij –De lengte van de kortste kant van een knoop in B naar v: dichtbij[v] –De knoop in B die het andere eindpunt is van deze kant e d s a b c maxint

Algoritmiek24 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.

Algoritmiek25 Tijd Prim Hoofdloop wordt n – 1 keer uitgevoerd. Elke keer O(n) stappen. Totaal O(n 2 ) 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.

Algoritmiek26

Algoritmiek27 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