Minimum Opspannende Bomen

Presentatie over: "Minimum Opspannende Bomen"— Transcript van de presentatie:

1 Minimum Opspannende Bomen
Algoritmiek

2 Toepassingen Verbinden van punten met zo min mogelijk bekabeling
Netwerkontwerp Deelroute in andere algoritmen … Algoritmiek

3 Probleemstelling Gegeven: een ongerichte graaf G=(N,A)
Iedere kant representeert potentieel aan te leggen verbinding Kosten/lengte voor elke kant Gevraagd: Een verzameling kanten F Í A van minimale totale kosten/lengte zodat de deelgraaf G’=(N,F) samenhangend is Algoritmiek

4 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 F Í A, d.w.z. T is een deelboom van G Elke knoop in G in T zit De totale lengte van alle kanten in T zo klein mogelijk is. T is een (minimum) opspannende deelboom Algoritmiek

5 Minimum opspannende boom
Voorbeeld 4 4 c c e e 3 3 11 5 5 4 4 a a d d 3 3 2 2 1 1 b 17 b 1 1 f f Minimum opspannende boom is niet uniek Minimum opspannende boom Opspannende boom; Geen minimum opspannende boom Algoritmiek

6 Inhoud Een principe om minimum opspannende bomen te laten groeien
Twee greedy algoritmen + tijd en datastructuren: Het algoritme van Kruskal Het algoritme van Prim-Jarnik Algoritmiek

7 Greedy aanpak Begin met een woud zonder kanten T=(N,Æ)
Herhaal tot T een boom is Kies een kant {v,w}, zodat … Voeg deze kant aan T toe 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. Algoritmiek

8 Goed woud: voorbeelden
f a b 3 4 2 5 c 1 e d f a b 4 3 2 5 c 1 e d f a b 3 4 2 5 c 1 Algoritmiek

9 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 d 3 2 1 e d f a b 4 3 2 5 c 1 b 1 f {a,b} is veilig Algoritmiek

10 Greedy algoritme Begin met een woud zonder kanten T=(N,Æ)
Herhaal tot T een boom is Kies een veilige kant {v,w} Voeg {v,w} toe aan T Output T Maar: welke kanten zijn er veilig?? Algoritmiek

11 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 d 3 2 1 b Elk van de rode kanten verlaat de deelboom met knopen b en f 1 f Algoritmiek

12 Stelling Stel T is een goed woud. Stel W is een deelboom uit T. Laat de kant {v,w} deelboom W verlaten, en minimum lengte hebben ten opzichte van alle kanten die W verlaten. Dan is {v,w} veilig. c e 3 5 4 a {d,f} is veilig d 3 2 1 b 1 f Algoritmiek

13 Bewijs (1) Stel T is een goed woud, W een deelboom van T, en {v,w} kant van minimum lengte die W verlaat (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. Algoritmiek

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

15 Greedy algoritme Begin met een woud zonder kanten T=(N,Æ)
Herhaal tot T een boom is Kies een kant {v,w} die minimum lengte heeft t.o.v. alle kanten die een deelboom van T verlaten Voeg {v,w} toe aan T Output T Maar: hoe vind je zo’n kant snel? Algoritmiek

16 Twee methoden: overzicht
Kruskal Kanten worden in volgorde van stijgende lengte bekeken Groeit verschillende boompjes in woud Prim-Jarnik Groeit 1 boom in woud Steeds wordt de goedkoopste uitgaande kant genomen Verschillende implementaties Algoritmiek

17 Kruskal: 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. Algoritmiek

18 Kruskal: voorbeeld 4 c e 3 5 4 a d 3 2 1 b 1 f Algoritmiek

19 Kruskal: voorbeeld 4 c e 3 5 4 a d 3 2 1 b 1 f Algoritmiek

20 Kruskal: correctheid Invariant: T is een goed woud
Blijft behouden omdat toegevoegde kant veilig is (minimum lengte en verlaat deelboom van T) Mogelijk heeft deze deelboom 1 knoop Algoritmiek

21 Kruskal: implementatie
Belangrijkste problemen: Bijhouden deelbomen Testen of kant tussen twee verschillende deelbomen is Disjuncte verzamelingen datastructuur (union-find) 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}: Union (Find(v), Find(w) ). Algoritmiek

22 Kruskal: analyse 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. Algoritmiek

23 Prim-Jarnik: 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. veilig Algoritmiek

24 Prim-Jarnik: voorbeeld
4 c e 3 5 4 a d 3 2 1 b 1 f Algoritmiek

25 Prim-Jarnik: voorbeeld
4 c e 3 5 4 a d 3 2 1 b 1 f Algoritmiek

26 Prim-Jarnik: correctheid
Invariant: T is een goed woud Blijft behouden omdat toegevoegde kant veilig is (minimum lengte en verlaat B, een deelboom van T) Algoritmiek

27 Prim-Jarnik: Implementatie
Houd voor elke knoop v in N – B bij De kortste kant van een knoop in B naar v: kantnaarb[v] De lengte van deze kant: dichtbij[v] Algoritmiek

28 Prim-Jarnik: Implementatie
Kies een knoop s. B = {s}; T = (B, Æ); for all v do dichtbij[v] = maxint; kantnaarb[v] = ongedef; for all {s,v} Î A do dichtbij[v] = l({s,v}); kantnaarb[v] = {s,v}; while (B ¹ N) (of: doe n – 1 keer) do Vind v Î N - B met kleinste waarde van dichtbij[v] T = T È {kantnaarb[v]}; B = B È {v}; for all {v,w} Î A met w Î N - B do if (l({v,w}) < dichtbij[w] ) then dichtbij[w] = l({v,w}); kantnaarb[w] = {v,w}; Output T. Algoritmiek

29 Prim-Jarnik: voorbeeld
4 c e dichtbij kantnaarb a maxint ongedef b 1 {b,f} c d {d,f} e f 3 5 4 a d 3 2 1 b 1 f Algoritmiek

30 Prim-Jarnik: voorbeeld
4 c e dichtbij kantnaarb a 2 {a,b} b c maxint ongedef d 1 {d,f} e f 3 5 4 a d 3 2 1 b 1 f Algoritmiek

31 Prim-Jarnik: voorbeeld
4 c e dichtbij kantnaarb a 2 {a,b} b c 5 {c,d} d e maxint ongedef f 3 5 4 a d 3 2 1 b 1 f Algoritmiek

32 Prim-Jarnik: voorbeeld
4 c e dichtbij kantnaarb a b c 4 {a,c} d e 3 {a,e} f 3 5 4 a d 3 2 1 b 1 f Algoritmiek

33 Prim-Jarnik: voorbeeld
4 c e dichtbij kantnaarb a b c 4 {a,c} d e f 3 5 4 a d 3 2 1 b 1 f Algoritmiek

34 Prim-Jarnik: voorbeeld
4 c e dichtbij kantnaarb a b c d e f 3 5 4 a d 3 2 1 b 1 f Algoritmiek

35 Prim-Jarnik: Analyse Belangrijkste probleem: hoe vinden we de kant met de kleinste waarde van dichtbij? Gebruik priority queue. Operaties: extract-min, update O(n) iteraties O(n) keer een extract min operatie. O(a) keer een update van een waarde. Met een gebalanceerde boom: O(a log n) tijd. Met Fibonacci of hollow heap: O(a + n 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. Algoritmiek

36 Kruskal vs. Prim-Jarnik
Kanten in volgorde van stijgende lengte Groeit verschillende boompjes in woud O(a log n + a a(n) ) Prim-Jarnik Groeit 1 boom in woud Steeds wordt de goedkoopste uitgaande kant genomen O(a + n log n) Algoritmiek