Minimum Opspannende Bomen. Algoritmiek

Transcriptie

1 Minimum Opspannende Bomen

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 2

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

4 Voorbeeld a 2 e b 4 4 f c d 5 7 Opspannende boom; Geen minimum opspannende boom a 2 e b 4 4 f c d 5 Minimum opspannende boom 4

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

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

7 Goed woud: voorbeelden e a 2 b 4 4 c 5 d f e a 2 b 4 4 c 5 d f 7

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

9 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

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

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

12 Bewijs () 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. 2

13 Bewijs (2) v w T +{v,w} heeft een cycle. Deze cycle bevat zowel knopen in W als knopen niet in W. v 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. v a w Want l({v,w}) l(a). Dus {v,w} is veilig.

14 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? 4

15 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 boom Steeds wordt de goedkoopste uitgaande kant genomen Verschillende implementaties 5

16 Kruskal s algoritme Sorteer de kanten op niet-dalende lengte, zeg k(),, k(a). Begin met een woud zonder kanten T=(N, ). for i = 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. 6

17 Kruskal: voorbeeld a 7 e b c 8 d f 7

18 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) ). 8

19 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 kanten heeft. 9

20 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 20

21 Prim: voorbeeld a 7 e b c 8 d s 2

22 Steeds is geldig: Prim geeft minimum opspannende boom 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

23 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 7 maxint e a 7 b c 8 9 d s 2

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

25 Tijd Prim Hoofdloop wordt n 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. 25

26 26

27 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