7 Minimaler Spannbaum und Datenstrukturen

Transkript

1 79 7 Minimaler Spannbaum und Datenstrukturen Hier betrachten wir als Ausgangspunkt stets zusammenhängende, ungerichtete Graphen. G So sind Spannbäume (aufspannende Bäume) on G. Beachte immer Kanten bei Knoten. Definition 7.(Spannbaum): Ist G = (V, E) zusammenhängend, so ist ein Teilgraph H = (V,F) ein Spannbaum on G, genau dann, wenn H zusammenhängend ist und für alle f FH \ {f} = (V,F \ {f}) nicht mehr zusammenhängend ist (H ist maximal zusammenhängend). Folgerung 7.: Sei H zusammenhängend, Teilgraph on G. H Spannbaum on G H ohne Kreis. Beweis. Hat H einen Kreis, dann gibt es eine Kante f, so dass H \ {f} zusammenhängend ist. (A B durch B A) Ist H kein Spannbaum, dann gibt es eine Kante f, so dass H \ {f} zusammenhängend ist. Dann haben wir einen Kreis in H, der f enthält. (B A durch A B) Damit hat jeder Spannbaum genau n Kanten, wenn V = n ist. Vergleiche Seite. Die Baumkanten einer Suche ergeben einen solchen Spannbaum. Wir suchen Spannbäume minimaler Kosten. Definition 7.: Ist G = (V,E) und K : E R (eine Kostenfunktion) gegeben. Dann ist H = (V,F) ein minimaler Spannbaum genau dann, wenn:

2 80 7 MINIMALER SPANNBAUM UND DATENSTRUKTUREN H ist Spannbaum on G K(H) = K(f) ist minimal unter den Knoten aller Spannbäume. f F (K(H) = Kosten on H). Wie finde ich einen minimalen Spannbaum? Systematisches Durchprobieren. Verbesserung durch branch-and-bound. Eingabe G = (V,E),K : R,E = {e,...,e n } (also Kanten) Systematisches Durchgehen aller Mengen on n Kanten (alle Bitektoren b,...,b n mit genau n Einsen), z.b, rekursi. Testen, ob kein Kreis. Kosten ermitteln. Den mit den kleinsten Kosten ausgeben. Zeit: Mindestens ( m n ) = m! (n )! (m + )! }{{} 0 für n m Wieiel ist das? m = n, dann (n)! n(n ) (n )... n = (n )!(n + )! (n + )n(n )... n n }{{} = n n }{{} > }... {{} = n n mal... n }{{} > Also Zeit Ω( n ). Regel: c 0 a b a c b c b a. Das c im Nenner hat mehr Gewicht. Definition 7.(Ω-Notation): Ist f,g : N R, so ist f(u) = Ω(g(u)) genau dann, wenn es eine Konstante C > 0 gibt, mit f(n) C g(n) für alle hinreichend großen n. (ergleiche O-Notation) O-Notation: Obere Schranke Ω-Notation: Untere Schranke. Verbesserung: Backtracking, frühzeitiges Erkennen on Kreisen: Aufbau eines Baumes (Prozeduraufrufbaum):

3 8 e nicht e e nicht e e.. Teste auf Kreis, Ende Falls Kreis nicht betrachtet, wenn Kreis bei e, e, e Alle Teilmengen mit e,e,e sind in einem Schritt erledigt, wenn ein Kreis orliegt. Einbau einer Kostenschranke in den Backtracking-Algorithmus: Branch-and-bound. Kosten des Knotens k = K(f). f in k gewählt.. k b Blätter = mögliche Spannbäume Es ist für Blätter wie b unter k. Kosten* on k Kosten on b. *Untere Schranke an die Spannbäume unter k. Also weiteres Rausschneiden möglich, wenn Kosten on k Kosten eines bereits gefundenen Baumes. Im allgemeinen ohne weiteres keine bessere Laufzeit nachweisbar. Besser: Irrtumsfreier Aufbau eines minimalen Spannbaumes Abbildung : ungerichteter Graph mit Kosten an den Kanten

4 8 7 MINIMALER SPANNBAUM UND DATENSTRUKTUREN Abbildung : Spannbaum mit minimalen Kosten Aufbau eines minimalen Spannbaums siehe Abbildung minimaler Spannbaum Nimm die günstigste Kante, die keinen Kreis ergibt, also nicht, 7 Abbildung : schrittweiser Aufbau eines Spannbaumes Implementierung durch Partition on V { }, { },...,{ 7 } keine Kante {, 7 },,,, {, 7 } {, 7 }, {, },... {, 7 }, {, } {, 7, }, {, },... {, 7 }, {, }, { 7, } {, 7,,, },... {, 7 }, {, }, { 7, }, { 7, } hinzu. 6 hinzu Problem: Wie Partition darstellen?

5 7. Algorithmus Minimaler Spannbaum 8 7. Algorithmus Minimaler Spannbaum (Kruskal 96) Eingabe: G = (V,E), zusammenhängend, V = {,...,n}, Kostenfunktion K : E R Ausgabe: F = Mege on Kanten eines minimalen Spannbaumes.. F = Ø, P = {{},..., {n}} // P ist die Partition. E nach Kosten sortieren // geht in O(E log E )=O( E log V ), // E V, log E =Olog V. while( P ){ // solange P {{,..., n}}. {, w} = kleinstes (erstes) Element on E {, w} aus E löschen. Testen, ob F {, w} einen Kreis hat 6. if({, w} induziert keinen Kreis){ W = die Menge mit aus P; W w = die Menge mit w aus P; W und W w in P ereinigen F = F {{, w}} } } Der Algorithmus arbeitet nach dem Greedy-Prinzip (greedy = gierig): Es wird zu jedem Zeitpunkt die günstigste Wahl getroffen (= Kante mit den kleinsten Kosten, die möglich ist) und diese genommen. Eine einmal getroffene Wahl bleibt bestehen. Die lokal günstige Wahl führt zum globalen Optimum. Zur Korrektheit des Algorithmus: Sei F l = der Inhalt on F nach dem l-ten Lauf der Schleife. P l = der Inhalt on P nach dem l-ten Lauf der Schleife. Wir erwenden die Inariante: F l lässt sich zu einem minimalen Spannbaum fortsetzen. (D.h., es gibt F F l, so dass F ein minimaler Spannbaum ist.) P l stellt die Zusammenhangskomponenten on F l dar. Inariante gilt für l = 0. Gelte sie für l und finde ein l + -ter Lauf statt.

6 8 7 MINIMALER SPANNBAUM UND DATENSTRUKTUREN. Fall Die Kante {,w} wird nicht genommen. Alles bleibt unerändert. Inariante gilt für l +.. Fall {,w} wird genommen. {,w} = Kante on minimalen Kosten, die zwei Zusammenhangskomponenten on F l erbindet. Also liegt folgende Situation or: Zu zeigen: Es gibt einen minimalen Spannbaum, der F l+ = F l {,w} enthält. F l w Nach Inariante für F l gibt es mindestens Spannbaum F F l. Halten wir ein solches F fest. Dieses F kann, muss aber nicht, {,w} enthalten. Falls F {,w} enthält, gilt die Inariante für l + (sofern die Operation auf P richtig implementiert ist). Falls aber F {,w} nicht enthält, argumentieren wir so: F {, w} enthält einen Kreis (sonst F nicht zusammenhängend). Dieser Kreis muss mindestens eine weitere Kante haben, die zwei erschiedene Komponenten on F l erbindet, also nicht zu F l gehört. Diese Kante ghört z der Liste on Kanten E l, hat also Kosten, die höchstens größer als die on {,w} sind. Tauschen wir in F diese Kante und {, w} aus, haben wir einen minimalen Spannbaum mit {,w}. Also gilt die Inariante für F l+ = F l {,w} und P l+ (sofern Operationen richtig implementiert sind.) Quintessenz: Am Ende ist oder hat F l nur noch eine Komponente, da P l =. Also minimaler Spannbaum wegen Inariante. Termination: Entweder wird die Liste E l kleiner oder P l wird kleiner. Laufzeit:. O(n). Kanten sortieren: O( E log E ) (wird später behandelt), also O( E log V )! F l F w keine Kante dazwischen Abbildung 6: ein Beispiel für F

7 7. Algorithmus Minimaler Spannbaum 8. die Schleife n # Läufe E Müssen {{},...,{n}} zu {{,...,n}} machen. Jedesmal eine Menge weniger, da zwei ereinigt werden. Also n Vereinigungen, egal wie ereinigt wird 6 6 Binärer Baum mit n Blättern hat immer genau n Nicht-Blätter. Für {,w} suchen, ob es Kreis in F induziert, d.h. ob,w innerhalb einer Menge on P oder nicht. W und W w in P ereinigen Bis zu E -mal Genau n -mal. Zeit hängt an der Darstellung on P. Einfache Darstellung: arrayp[,..., n], wobei eine Partition on {,..., n} der Indexmenge dargestellt wird durch: u, in gleicher Menge on P P[u] = P[] (u,... Elemente der Grundmenge = Indizes) Die Kante {u, } induziert Kreis u, in derselben Zusammenhangskomponente on F P[u] = P[] W u und W ereinigen:. a = P[]; b = P[w] // a+b, wenn W u W. for i =,..., n{ if (P[i] = a){ P[i] = b } } Damit Laufzeit der Schleife: 7. insgesamt n O(n) = O(n ) (Es wird n -mal ereinigt.). und. insgesamt O( E ). O(n) insgesamt, wenn P mitgeführt. Also O(n ), wenn E bereits sortiert ist. Darstellung on P durch eine Union-Find-Struktur:

8 86 7 MINIMALER SPANNBAUM UND DATENSTRUKTUREN Darstellung einer Partition P einer Grundmenge (hier klein, d.h. als Indexmenge erwendbar) Für U,W P Union(U,W) soll U,W P durch U W P ersetzen Für u aus der Grundmenge Find(u) soll Namen der Menge U P mit u U geben. (Also es geht nicht ums Finden on u!) Für Kruskal E -mal Find(u) + V -mal Union(u,w) Zeit Ω( E + V ), sogar falls E bereits sortiert ist. 7. Datenstruktur Union-Find-Struktur (a) Jede Menge on P als ein Baum mit Wurzel. P = {{,,, }, {, 6}}, dann etwa Wurzel = Name der Menge. oder auch 6,... Struktur der Bäume egal! 6 (b) Find(u). u in den Bäumen finden // Kein Problem, solange Grundmenge //Indexmenge sein kann. Gehe on u aus hoch bis zur Wurzel. (Namen der) Wurzel ausgeben. Union (u,) // u, sind Namen on Mengen, also Wurzeln. u, in den Bäumen finden. Hänge u unter (oder umgekehrt)

9 7. Datenstruktur Union-Find-Struktur 87 u u oder u (c) Bäume in array(vaterarray): P[,...,n] of...n P[] = Vater on. Aus (a) weiter: Wurzel, deshalb P[] = P[] = 6 Wieder wichtig: Indices = Elemente. Vaterarray für beliebige Bäume Union (u,) P[u]=; Find() while (P[] ){ =P[]; } Ausgabe on. //u, Wurzeln // u hängt unter // O(n) im worst case.... N P = Union(,) in O().... N... N

10 88 7 MINIMALER SPANNBAUM UND DATENSTRUKTUREN... N P =... N... N Union(,) in O().... N P =... N... N Union(,) in O(). das Entstehen langer, dünner Bäume. N. N N... N P = N N N N Find() in Ω (N)

11 7. Algorithmus Union-by-Size N N Union(,); Union(,); Union(,);..., Union (N,)... N Vertauschen der Argumente Find() in O(). Union by Size; kleinere Anzahl nach unten. maximale Tiefe (längster Weg on Wurzel zu Blatt) = log N Beachte: log N zu N = log N wie N zu N. 7. Algorithmus Union-by-Size Union((u,i), (,j)) if (i j){ // i, j # Elemente in den Mengen. // Muss mitgeführt werden, j+i u } else { " umgekehrt\} Union by Size:,,, Union(,),, N, N, Union(,),, N,

12 90 7 MINIMALER SPANNBAUM UND DATENSTRUKTUREN. Union(,N),... N Tiefe Bäume durch Union-by-Size? Vermutung: N Elemente Tiefe log N. Satz 7.: Beginnend mit P = {{}, {},...,{n}} gilt, dass mit Union-by-Size für jeden entstehenden Baum T gilt: Tiefe(T) log T ( T = # Elemente on T = # Knoten on T)

13 7. Algorithmus Union-by-Size 9 Beweis. Induktion über die # der ausgeführten Operationen Union(u,), um T zu bekommen. Induktionsanfang, kein Union(u,) Tiefe(u)= 0 = log ( 0 = ) Induktionsschluss: (u, i) (, j) R = T durch Union (u,) und (, i+j) T = u S R Sei i j, dann. Fall: keine größere Tiefe als orher. Die Behauptung gilt nach Induktionsoraussetzung, da T mehr Elemente hat erst recht.. Fall: Tiefe ergrößert sich echt. Dann aber Tiefe(T) = Tiefe(R) + (log R ) + = log ( R ) T Union by Size. ( x = R x = x+ = R )! Tiefe wird immer nur um größer. Dann mindestens Verdopplung der # Elemnte. S =

14 9 7 MINIMALER SPANNBAUM UND DATENSTRUKTUREN Mit Bäumen und Union-by-Size Laufzeit der Schleife: E -mal Find(u): O( E log V ) (log V... Tiefe der Bäume) n -mal Union(u,): O(n) Rest O( E ) Also insgesamt O( E log V ) Vorne: O( V ). Für dichte Graphen ist E = Ω( ) so keine Verbesserung log V erkennbar. Beispiel 7. (Wegkompression): V i s i u Find() s u hier nachfolgende Finds schneller Wegkompression Find()

15 7. Algorithmus Wegkompression 9 Im Allgemeinen Ω(logN) und O(logN) 7. Algorithmus Wegkompression Find(). auf Keller tun // etwa als array implemntieren. while (P[] ){ (wie Schlange). = P[]; auf Keller tun }. ausgeben;. for (w auf dem Keller){ P[w] = ; //Können auch Schlange, Liste oder } //sonstwas nehmen, da Reihenfolge egal Laufzeit O(log V ) reicht immer, falls Union-by-Size dabei. Es gilt sogar (einer der frühen Höhepunkte der Theorie der Datenstrukturen): n Unions, m Finds mit Union-by-Size und Wegkompression in Zeit O(n + (n + m) log (n)) bei anfangs P = {{}, {},...,{n}}. Falls m Ω(n) ist das O(n + m log (n)). (Beachten Sie die Abhängigkeit der Konstanten: O-Konstante hängt on Ω-Konstante ab!) Was ist log (n)? Die Funktion log

16 9 7 MINIMALER SPANNBAUM UND DATENSTRUKTUREN 0 ( ( ( ( log = 0 log = log = log = + log = log = log 8 = log + = log 6 = log + = log 6 = log 6 = 6 = 6.6 log n Min{s log (s) (n) } ((((()))) log ) = 7 log (s) (n) = log(log(...(log(n))...)) }{{} s mal Kruskal bekommt dann eine Zeit on O( V + E log V ) Fast O( V + E ) bei orsortierten Kanten natürlich nur Ω( V + E ) in jedem Fall. Nachtrag zur Korrektheit on Kruskal:. Durchlauf: Die Kante mit minimalen Kosten wird genommen. Gibt es mehrere, so ist egal, welche. l + -ter Lauf: Die Kante mit minimalen Kosten, die zwei Komponenten erbindet, wird genommen.

17 7. Algorithmus Wegkompression 9 Kosten 0 in F F F l F Spannbaum Austauschen Kosten 0, nicht in F Alle Kanten, die zwei Komponenten erbinden, haben Kosten -0! Beachte: Negatie Kosten sind bei Kruskal kein Problem, nur bei branch-and-bound (orher ergrößern)! ( ) n Binomialkoeffizient für n k 0. k oberste k Faktoren on n! ( ) {}}{ n n! = k (n k) k! = n(n )... (n k + ) k! 0! ( = )! =. n = # Teilmengen on {,...,n} mit genau k Elementen ( k) ( ) ( ) n n n(n ) n = n, =, n k. k Beweis. Auswahlbaum für alle Folgen (a q,...,a k ) mit a i {,...,n}, alle a i erschieden. n Möglichkeiten... n a wählen Jedesmal n Möglichkeiten... n n... n a wählen n n Möglichkeiten n a n k+ Möglichkeiten a k

18 96 7 MINIMALER SPANNBAUM UND DATENSTRUKTUREN Der Baum hat n (k ) {}}{ n(n )... (n k + ) }{{} k Faktoren (nicht k-, da 0,,..., k+ genau k Zahlen) n! = (n k)! Jedes Blatt genau eine Folge (a,...,a k ) Jede Menge aus k Elementen kommt k!-mal or: {a,...,a k } ungeordnet, geordnet als (a,...,a k ), (a,a,...,a k ),...(a k,a k,...,a,a )k! Permutationen. Also n! (n k)!k! = ( n k ) Mengen mit k erschiedenen Elementen. 7. Algorithmus Minimaler Spannbaum nach Prim 96 Eingabe: Wie bei Kruskal Ausgabe: Menge on Kanten F eines minimalen Spannbaumes. Wähle irgendeinen Startknoten r Q = V\{r} // Q enthält immer die Knoten, F = Ø // die noch bearbeitet werden müssen.. while (Q Ø {. M = {{, w} V\ Q, w Q} // M = Menge der Kanten mit // genau einem Knoten in Q. {, w} = eine Kante on minimalen Kosten in M F = F {{, w}}; Q = Q ohne den einen Knoten aus {, w}, der auch zu Q gehört Korrektheit mit der Inariante: Es gibt einen minimalen Spannbaum F F l Q l = l = 0. Gelte die Inariante für l und finde ein l + -ter Lauf der Schleife statt. Sei F F l ein minimaler Spannbaum, der nach Induktionsoraussetzung existiert.

19 7. Algorithmus Minimaler Spannbaum nach Prim V \ Q l r k w w w Q l F l w l w l Werde {,w} im l+-ten Lauf genommen. Falls {,w} F, dann gilt die Inariante auch für l+. Sonst gilt F {{,w}} enthält einen Kreis, der {,w} enthält. Dieser enthält mindestens eine weitere Kante {,w} mit V \ Q l,w Q l. F w w F Es ist K({,w}) K({,w }) gemäß Prim. Also, da F minimal, ist K({,w} = K({,w }). Können in F die Kante {,w } durch {,w} ersetzen und haben immernoch einen minimalen Spannbaum. Damit Inariante für l+. Öaufzeit on Prim: n Läufe durch.. und. einmal O( E ) reicht sicherlich, da E V. Also O( V E ), bis O(n ) bei V = n. Bessere Laufzeit durch bessere Verwaltung on Q. Maßgeblich dafür, ob w Q in den Baum aufgenommen wird, sind die minimalen Kosten einer Kante(!) {,w} für Q. Also array key[... n] of real mit der Intention: Für alle w Q ist key[w] = min. Kosten einer Kante {,w}, wobei Q. (key[w] =, gdw. keine solche Kante existiert.) Außerdem array ka[,..., n] of {,..., n} mit: Für alle w Q ka[w] = {,w} ist eine Kante minimaler Kosten mit Q

20 98 7 MINIMALER SPANNBAUM UND DATENSTRUKTUREN Wir werden Q mit einer Datenstruktur für die priority queue (Vorrangwartesschlange) implementieren: Speichert Menge on Elementen, on denen jedes einen Schlüsselwert hat (keine Eindeutigkeitsforderung). Operation Min gibt uns (ein) Elemnet mit minimalem Schlüsselwert. DeleteMin löscht ein Element mit minimalem Schlüsselwert. Insert(, s) = Element mit Schlüsselwert s einfügen. Wie kann man eine solche Datenstruktur implementieren?. Möglichkeit: etwa als Array Min Q... 8 n Indices = Elemente, Einträge in Q = Schlüsselwerte, Sonderwert (etwa - ) bei nicht orhanden. Zeiten: Insert(,s) in O() (sofern keine gleichen Elemente mehrfach auftreten) Min in O() DeleteMin - O() fürs Finden des zu löschenden Elementes, dann aber O(n), um ein neues Minimum zu ermitteln.. Möglichkeit: Darstellung als Heap. Heap = fast ollständiger binärer Baum, dessen Elemente (= Knoten) bezüglich Funktionswerten key[j] nach oben hin kleiner werden. /9 00/9 Element /7 7/8 /0 0/ / 0/ / Wert Key[] = /00 Tiefe N, dann Innere: N Blätter: N N+ fast ollständig

21 7. Algorithmus Minimaler Spannbaum nach Prim Heapeigenschaft: für alle u,,u Vorfahr on = key[u] key[] Beispiel Minimum löschen: Nur Werte: Key[I]: kleinster einer on den beiden zweitkleinster letztes Element (nicht größtes) 0 ertauschen mit kleinerem Kind weg neues Minimum 0 00 Beispiel Einfügen Element mit Wert einfügen

22 00 7 MINIMALER SPANNBAUM UND DATENSTRUKTUREN letzter Platz Aufsteigen Priority Queue mit Heap, sagen wir Q. Min {. Gib Element der Wurzel aus } O() Deletemin{. Nimm letztes Element, setze es auf Wurzel x:=wurzel(-element). While Key[x] Key[linker Sohn on x] oder rechter Sohn {tausche x mit kleinerem Sohn} } N Elemente, O(logN), da maximal O(logN) Durchläufe Insert(,s){//Key[]=s.. Tue als letztes Element in den Heap.. While Key[Vater on ] Key[] {ertausche mit seinem Vater} } N Elemente O(logN) Vergleich der Möglichkeiten der Priority Qeue

23 7. Algorithmus Minimaler Spannbaum nach Prim 96 0 Min Deletemin Insert Element finden Heap log N logn N Array o. Liste N(!) (Array), N(Liste) Heap als Array Q[,...,N] Q[] Q[], Q[] Q[],... Q[7] Q[8],... Q[] 8 Stück in Tiefe 0 Vater I{// I Index aus,..., N if (I+){ Gebe aus} Linker Sohn I I Rechter Sohn I+ Abschließendes Beispiel 00/ Key[00]= /7 0/00 /9 /8 /00 Array Q Q[] = 00 Key[00] = Q[] = Key[] = 7 Q[] = 0 Key[0 = 00 Q[] = Q[] = Q[6] =. wenn Elemente nur einmal Suchen nach Element oder Schlüssel wird nicht (!) unterstützt.

24 0 7 MINIMALER SPANNBAUM UND DATENSTRUKTUREN 7.6 Algorithmus (Prim mit Q in heap). Wähle Startknoten r. for each Adj[r]{ key[]=k({r,}); kante[]=r} Für alle übrigen V{ key[]= ; kante[]= } Füge V\{r} mit Schlüsselwerten key[] in heap Q ein.. while Q Ø{. w = Min; DeleteMin Q ; F = F {{kante[w],w}}. for each u Adj[w] Q{ if K({u,w})<key[u]{ key[u] = k({u,w}); kante[u] = w; Q anpassen} } } Korrektheit mit zusätzlicher Inariante: Für alle w Q l key l [w] = minimale Kosten einer Kante {, w} für Q l } key l [w] =, wenn eine solche Kante nicht existiert. Laufzeit. O(n) + O(n logn) für das Füllen on Q. (Füllen on Q in O(n) - interessante Übungsaufgabe). n Läufe. Einmal O(logn), insgesamt O(n logn). Insgesamt O( E ) + E -mal Anpassen on Q. Anpassen on Heap Q Operation Decreasekey(,s) s < key[], neuer Schlüssel

25 7.6 Algorithmus (Prim mit Q in heap) 0 00/ Key[00]= /7 0/00 /9 /8 /00 Decreasekey(,s). Finde Element in Q //nicht on Q unterstützt!. while key[vater on ] s tausche mit Vater Laufzeit Deckey(,s):. O(logN). O(N)(!!). zum Finden: Index drüberlegen Direkte Adressen: Ind[] =, Ind[] =, Ind[]= 6, Ind[00] = Finden in O() Falls Grundmenge zu groß, dann Suchbaum: Finden O(logN) Falls direkte Adressen dabei: Einmaliges Anpassen on Q (und Index) O(log V ) Dann Prim insgesamt O( E log V ) (Beachte orher O( E V )) (wie Kruskal mit Union by Size.)