Universität Karlsruhe Fakultät für Informatik. Algorithmentechnik

Transkript

1 Universität Karlsruhe Fakultät für Informatik Algorithmentechnik Skript zur Vorlesung von Prof. Dorothea Wagner, Karlsruhe, Wintersemester 06/07 Stand: 7. Februar Skript erstellt von Robert Görke und Steffen Mecke Fakultät für Informatik Universität Karlsruhe Basierend auf den Vorlesungsnotizen von Dorothea Wagner und dem Skript der Vorlesung Algorithmen und Datenstrukturen aus Konstanz

2

3 Inhaltsverzeichnis Inhaltsverzeichnis Abbildungsverzeichnis 5 Algorithmenverzeichnis 7 0 Grundlagen 0. Worst-case- und Average-case-Laufzeit Beispiel: Worst-case-Laufzeit von Finde Maximum Beispiel: Average-case-Laufzeit von Finde Maximum Beispiel: Average-case-Laufzeit von Quicksort Untere Schranken für Laufzeiten Untere Schranke für Sortieren Untere Schranke für Berechnung der konvexen Hülle Amortisierte Analyse Beispiel von Stackoperationen Die Ganzheitsmethode Die Buchungsmethode Die Potentialmethode Divide-and-Conquer Verfahren und das Prinzip der Rekursion Ein Beispiel aus der Informatik-Grundvorlesung Rekursionsabschätzungen Die Substitutionsmethode Die Iterationsmethode Der Aufteilungs-Beschleunigungssatz (Meistermethode, Master-Theorem). Grundlegende Datenstrukturen für Operationen auf Mengen 9. Union-Find Drei Ansätze Die Laufzeit von Union-Find Bemerkungen Anwendungsbeispiele für Union-Find

4 INHALTSVERZEICHNIS.. Der Algorithmus von Kruskal für MST Das Offline-Min-Problem Äquivalenz endlicher Automaten Priority Queues oder Heaps Heapify Makeheap Prozedur Delete Prozedur Sift-Up Prozedur Insert Sortierverfahren Heapsort Alternative Bottom-Up-Heapify Aufspannende Bäume minimalen Gewichts 4. Einführung Das MST-Problem Motivation Die Färbungsmethode von Tarjan Grüne Regel Rote Regel Färbungsinvariante Der Algorithmus von Kruskal Der Algorithmus von Prim Implementation des Algorithmus von Prim Greedy Verfahren und Matroide Schnitte in Graphen und Zusammenhang 5. Schnitte minimalen Gewichts: MinCut Der Algorithmus von Stoer & Wagner Flussprobleme und Dualität 6 4. Grundlagen Problemstellung Bestimmung maximaler Flüsse ( Max Flow ) Ford-Fulkerson-Algorithmus (96) Der Algorithmus von Edmonds und Karp (97) Der Algorithmus von Goldberg und Tarjan (988) Anwendungsbeispiel: Mehrmaschinen-Scheduling Kreisbasen minimalen Gewichts 8 5. Kreisbasen Das Kreismatroid

5 INHALTSVERZEICHNIS 5. Der Algorithmus von Horton Der Algorithmus von de Pina (995) Beispiel zum Algorithmus von de Pina Korrektheit des Algorithmus von de Pina Effiziente Berechnung eines Zertifikats für MCB Lineare Programmierung 9 6. Geometrische Repräsentation von LPs Algorithmen zur Lösung von LPs Approximationsalgorithmen Approximationsalgorithmen mit relativer Gütegarantie Das allgemeine Knapsack Problem Bin Packing (Optimierungsversion) Approximationsschemata Ein PAS für Multiprocessor Scheduling Asymptotische PAS für Bin Packing Ein APAS für Bin Packing AFPAS für Bin Packing Randomisierte Algorithmen 5 8. Grundlagen der Wahrscheinlichkeitstheorie I Randomisierte MinCut-Algorithmen Ein einfacher Monte Carlo-Algorithmus für MinCut Ein effizienterer randomisierter MinCut-Algorithmus Grundlagen der Wahrscheinlichkeitstheorie II Das Maximum Satisfiability Problem Der Algorithmus Random Sat Das MaxCut-Problem Ein Randomisierter Algorithmus für MaxCut Relaxierung von IQP

6

7 Abbildungsverzeichnis Sortieren mit der konvexen Hülle Mengen bei Union-Find Vereinigung von Mengen bei Union-Find Tiefe eines Baumes weighted Union : Union(i, j) Pfadkompression bei Find Rang eines Knoten Deterministischer endlicher Automat A Deterministischer endlicher Automat A Deterministischer endlicher Automat A Beispiel eines Heap Beispielhafte Arbeitsweise von Heapify Ein aufspannender Baum minimalen Gewichts Beispiel eines Schnitts (S, V \ S) Ein Kreis in einem Graphen Eine Anwendung der grünen Regel Eine Anwendung der roten Regel Die Invariante der grünen Regel Unabhängige Knotenmengen sind kein Matroid Unzusammenhängende Kantenmengen sind kein Matroid Beispiel eines minimalen Schnitts Ein Beispiel für das Verschmelzen von Knoten Phase Phase Phase Phase Phase Phase

8 6 ABBILDUNGSVERZEICHNIS 7. Phase Erster aktiver Knoten v / S Erster aktiver Knoten v S Nächster aktiver Knoten Ein Fluss und Schnitte Negativbeispiel für Ford-Fulkerson Edmonds und Karp beim Start Edmonds und Karp nach Update Flussnetzwerk mit Präfluss Beispiel zu Goldberg-Tarjan Flussnetzwerk für Mehrmaschinen-Scheduling Beispiel einer Kreisbasis, die aus einem Spannbaum gewonnen wird Elemente der Basis können stets durch ihren Schnitt mit einem anderen Basiselement ersetzt werden Elemente der Basis können stets verkleinert werden Darstellung eines Kreises der MCB durch kürzeste Wege Ein Graph zur Illustration des Algorithmus von de Pina Geometrische Darstellung eines LP Klee-Minty-Polyeder Worst-case-Beispiel zu Next Fit Worst-case-Beispiel zu First Fit Jobzuteilung beim Multiprocessor Scheduling Eine Lösung von QP (I) Runden der zweidimensionalen Lösung

9 Algorithmenverzeichnis Finde Maximum Quicksort Multipop(S, k) Iteratives Merge-Sort(S, k) Rekursives Merge-Sort(A, p, r) SlowSelect(A, i) Select(A, i) Makeset(x) (#) Find(x) (#) Union(S i, S j, S k ) (#) Find(x) (#) Union(i, j) (#) Makeset(x) (#) Union(i, j) (#) Find(x) (#) Algorithmus von Kruskal Offline-Min Äquivalenz endlicher Automaten Heapify(A, i) Makeheap (M) Delete (A, i) Sift-Up(A, i) Insert(A, x) Heapsort(A) Bottom-Up-Heapify(A, ) Färbungsmethode von Tarjan Algorithmus von Kruskal (verbal) Algorithmus von Prim (verbal) Algorithmus von Prim Greedy Methode für ein Optimierungsproblem Minschnittphase(G i, c, a) Min Schnitt(G, c, a) Max-Flow Algorithmus von Ford-Fulkerson Algorithmus von Goldberg-Tarjan Prozedur Push Prozedur Relabel MCB-Greedy-Methode Algorithmus von Horton Algorithmus von de Pina ([]) Algorithmus von de Pina algebraisch Simple MCB

10 8 ALGORITHMENVERZEICHNIS 4 MCB-Checker Greedy-Knapsack Next Fit (NF) First Fit (FF) List Scheduling Algorithmus A l für Multiprocessor Scheduling APAS für Bin Packing Random MinCut Fast Random MinCut Random MaxCut

11 When I consider what people generally want in calculating, I found that it always is a number. I also observed that every number is composed of units, and that any number may be divided into units. Moreover, I found that every number which may be expressed from one to ten, surpasses the preceding by one unit: afterwards the ten is doubled or tripled just as before the units were: thus arise twenty, thirty, etc. until a hundred: then the hundred is doubled and tripled in the same manner as the units and the tens, up to a thousand;... so forth to the utmost limit of numeration. Abu Ja far Muhammad ibn Musa Al-Khwarizmi 80 (Namensgeber des Begriffs Algorithmus )

12

13 Kapitel 0 Grundlagen Der Literaturtip. Ein gutes Buch unter vielen zum Gesamtthema der Vorlesung ist []. Es enthält auch einführende Kapitel zum Algorithmusbegriff sowie zur Laufzeitanalyse von Algorithmen und zu Wachstumsraten von Funktionen (O, Ω, Θ). Ein weiteres empfehlenswertes Buch ist []. 0. Worst-case- und Average-case-Laufzeit Definition 0. (Worst-case-Laufzeit). Bezeichne die Anzahl Operationen, die ein Algorithmus A bei Eingabe x ausführt, mit t A (x). Die Worst-case-Laufzeit eines Algorithmus A ist: T worst A (n) := max x Eingabe, x =n t A(x) Definition 0. (Average-case-Laufzeit). Die Average-case-Laufzeit eines Algorithmus A ist: TA av (n) := {x : x ist Eingabe mit x = n} x: x =n t A (x) Dies bedeutet, TA av(n) gibt die mittlere Laufzeit bzw. den Erwartungswert für die Laufzeit bei Eingabe der Länge n an, wobei Gleichverteilung unter allen Eingaben angenommen wird. Somit gilt für die Zufallsvariable t A (x): TA av(n) = E[t A(x)]. 0.. Beispiel: Worst-case-Laufzeit von Finde Maximum Es sei A[,..., n], n ein Array der Länge n. Bestimme das Maximum der Werte A[],..., A[n]. Algorithmus : Finde Maximum Eingabe : Unsortiertes Array von n verschiedenen Zahlen A = (A[],..., A[n]) Ausgabe : Maximum aller A[i] max A[] for i to n do Wenn A[i] > max max A[i] 4

14 Grundlagen c Aufwand von Schritt c Aufwand von Schritt und bei einem Durchlauf c Aufwand von Schritt 4 Also: T worst A (n) c + (n )(c + c ) 0.. Beispiel: Average-case-Laufzeit von Finde Maximum Es sei A[,..., n] eine beliebige Permutation der Zahlen A[],..., A[n]. Alle n! Permutationen seien gleich wahrscheinlich. Somit gilt: Pr(A[] > A[]) = Pr(A[] > max(a[], A[])) =. Pr(A[n] > max(a[],..., A[n ])) = n Nun sei X j für j {,..., n} eine Zufallsvariable mit: X j = { falls A[j] Maximum in A[,..., j] 0 sonst () dann ist der Erwartungswert E[X j ] = Pr(A[j] > max(a[],..., A[j ])) = j. Für Algorithmus gilt somit: n A (n) = c + (n )c + c E T av j= X j n = c + (n )c + c E[X j ] j= n = c + (n )c + c j j= }{{} H n Hier ist H n die harmonische Reihe, für die gilt: ln(n + ) H n ln n +. Somit gilt: T av A (n) c + (n )c + c ln n

15 0. Worst-case- und Average-case-Laufzeit Algorithmus : Quicksort Eingabe : Unsortiertes Array von r l verschiedenen Zahlen A = (A[l],..., A[r]) Ausgabe : Sortiertes Array A Wenn r l > 0 x A[l] Ordne A = (A[l,..., r]) so um, dass alle Elemente, die kleiner bzw. größer als x sind, links, respektive rechts von x in A stehen. Sei das Element x danach an Position q in A Quicksort A[l,..., q ] Quicksort A[q +,..., r] Beispiel: Average-case-Laufzeit von Quicksort Wir wollen die Average-case-Laufzeit von Quicksort (Algorithmus ) bestimmen. Im Folgenden zählen wir für die Laufzeit nur noch die Anzahl der Vergleiche, die ein Sortieralgorithmus braucht. Bemerkung 0.. Der Worst-case tritt ein, falls zum Beispiel A bereits vorsortiert ist. Dann werden im ersten Aufruf n Vergleiche, im nächsten n Vergleiche etc. gemacht. Somit folgt: TQuicksort worst (n) = n i= i = (n )n Θ(n ), wobei wir in T nur die Vergleiche zählen. Annahme: Alle n! Permutationen sind gleich wahrscheinlich. Es bezeichne s i das i-kleinste Element in A. Weiterhin seien X ij Zufallsvariablen, definiert für alle Paare i < j: X i,j = { falls s i und s j verglichen werden 0 sonst () Bemerkung 0.4. Die Elemente s i und s j werden höchstens einmal verglichen. Es gilt: Quicksort(n) = E X ij = E[X ij ] i<j i<j T av und E[X ij ] = p ij 0 ( p ij ) = p ij wobei p ij die Wahrscheinlichkeit ist, dass s i und s j verglichen werden. Beobachtung 0.5. Die Elemente s i und s j werden genau dann verglichen, wenn µ = i oder µ = j, wobei s µ = A[k], k linkeste Stelle in A, an der ein Element aus s i, s i+,..., s j steht.

16 4 Grundlagen Somit folgt: p ij = j i+ und T av Quicksort(n) = i<j = = n j i + n i= j=i+ n j i + n+( i) i= j=i++( i) n n i= j= j }{{} H n n(h n ) n ln n (, 86n log n) n j i + ( i) = harmonische Reihe! i= n+ i j= j 0. Untere Schranken für Laufzeiten 0.. Sortieren ist in Ω(n log n) Eingabe eines Sortieralgorithmus ist ein Array A = A[,..., n]. Die Ausgabe ist das Array in sortierter Form und somit eine von n! möglichen Permutationen von A[,..., n]. Ein beliebiges Sortierverfahren, welches eine Abfolge von Vergleichen ausführt, entspricht einem Entscheidungsbaum wie folgt: A[i]<A[j] A[.] < A[.]. ja nein.... mindestens n! Blätter A[.] < A[.].. Höhe mind. log n! Somit gilt für jeden Sortieralgorithmus, der auf Vergleichen von je zwei Elementen beruht ( n ) n TSort worst (n) log n! log = n (log n ) Ω(n log n) Algorithmen, die nicht nur auf dem Vergleichen von zwei Elementen beruhen, fordern in der Regel spezielle Voraussetzungen, wie zum Beispiel Bucket Sort, oder erlauben spezielle algebraische Operationen. Gegebenenfalls ist Sortieren dann in Linearzeit möglich. Es gilt übrigens auch: TSort av (n) Ω(n log n), da auch die mittlere Blatttiefe log n! ist. 0.. Untere Schranke für Berechnung der konvexen Hülle von n Punkten ist Ω(n log n) Berechnung der konvexen Hülle H(P ) der Menge P von n Punkten im R, d.h. das minimale konvexe Polygon, so dass alle Punkte aus Q im Innern oder auf dem Rand des Polygons liegen. Graham-Scan-Algorithmus in O(n log n) Jarvis-March-Algorithmus in O(nh), mit h Anzahl der Punkte auf dem Rand von H(P )

17 0. Amortisierte Analyse 5 Annahme: Es gibt einen Algorithmus A, der H(P ) in T A (n) o(n log n) berechnet. Konstruiere aus n Zahlen a,..., a n eine Punktemenge P := {(a, a ), (a, a ),..., (a n, a n)}. Die Sortierung der Zahlen a,..., a n ist dann möglich mittels Berechnung von H(P ) und Minimum a min der Zahlen a,..., a n durch Ablauf des Randes von H(P ) im Gegenuhrzeigersinn ab (a min, a min ), denn alle Punkte aus P liegen auf dem Rand von H(P ). Siehe dazu Abbildung. Also: T Sort (n) O(T A (n) + n), ein Widerspruch zu Sortieren ist in Ω(n log n) (da wir auch hier wie üblich lediglich Vergleiche zulassen und i.a. keine weiteren Voraussetzungen haben). 5 a min 5 Abbildung : Die konvexe Hülle dieser Punktemenge liefert eine Sortierung 0. Amortisierte Analyse Die amortisierte Laufzeitanalyse ist eine Analysemethode, bei der die Zeit, die benötigt wird, um eine Folge von Operationen auszuführen, über alle auszuführenden Operationen gemittelt wird. Diese Analysemethode kann angewandt werden, um zu beweisen, dass die mittleren Kosten einer Operation klein sind, wenn man über eine Folge von Operationen mittelt, obwohl eine einzelne Operation sehr aufwendig sein kann. Im Unterschied zu der Average-case -Analyse werden keine Wahrscheinlichkeitsannahmen gemacht. Analyse-Techniken für die amortisierte Analyse sind:. Ganzheitsmethode: Bestimme eine obere Schranke T (n) für die Gesamtkosten von n Operationen. Das ergibt T (n) n als die amortisierten Kosten für eine Operation.. Buchungsmethode (engl. accounting): Bestimme die amortisierten Kosten jeder Operation. Verschiedene Operationen können verschiedene Kosten haben. Es werden frühe Operationen in der betrachteten Folge höher veranschlagt und die zu hoch veranschlagten Kosten jeweils als Kredit für festgelegte Objekte gespeichert. Dieser Kredit wird dann für spätere Operationen verbraucht, deren Kosten niedriger veranschlagt werden, als sie tatsächlich sind.. Potentialmethode: Ähnlich wie bei der Buchungsmethode werden die amortisierten Kosten jeder einzelnen Operation berechnet. Dabei werden möglicherweise wieder einzelne Operationen höher veranschlagt und später andere Operationen niedriger veranschlagt. Der Kredit wird als Potentialenergie insgesamt gespeichert, anstatt einzelnen Objekten zugeordnet zu werden.

18 6 Grundlagen Beachte dabei: Der Kredit wird nur für die Analyse eingeführt. 0.. Beispiel von Stackoperationen Wir wollen die drei Methoden am Beispiel Stack mit Multipop erläutern. Betrachte dazu eine Datenstruktur mit Last in First out, einen Stack S. Ein normaler Stack umfasst zwei Operationen: Push(S, x): lege Objekt x auf Stack S Pop(S): gib oberstes Objekt vom Stack aus und entferne es vom Stack. Beide Operationen sind in Θ(). Veranschlage daher die Kosten pro Operation mit. Dann sind die Gesamtkosten einer Folge von insgesamt n Push- und Pop-Operationen in Θ(n). Betrachte nun eine weitere Operation: Multipop(S, k): gib die obersten k Objekte vom Stack aus und entferne sie vom Stack, bzw. falls der Stack weniger als k Objekte enthält, gib alle Objekte aus, bis der Stack leer ist. Eine formale Beschreibung von Multipop(S, k) zeigt Algorithmus. Algorithmus : Multipop(S, k) Eingabe : Stack, Anzahl zu entfernender Elemente Ausgabe : Die k obersten Elemente des Stack Seiteneffekte : Stack verkleinert sich um bis zu k Elemente Solange S und k 0 tue Pop(S) k k Beispiel Push(S,8) Push(S,7) Pop(S) Ausgabe: Multipop(S,) Ausgabe: 8,, Multipop(S,) Ausgabe: 9,7,4 Die Laufzeit einer Operation Multipop(S, k) ist linear in der Anzahl der ausgeführten Pop- Operationen, also O(min(s, k)), wobei s = S ist und wobei die Kosten im Worst-case betrachtet werden. Für eine Folge von n Push-, Pop- und Multipop-Operationen, angewandt auf einen zu Beginn leeren Stack, ergibt sich: Worst-case-Laufzeit einer Multipop-Operation ist O(n) Worst-case-Laufzeit einer beliebigen Stack-Operation ist O(n) Für n Stack-Operationen ergibt sich dann im Worst-case O(n ).

19 0. Amortisierte Analyse Die Ganzheitsmethode Eine einzelne Multipop-Operation kann teuer sein, d.h. sie kann Kosten n haben. Andererseits gilt: Ein Objekt kann höchstens einmal wieder einen Pop erfahren für jedes Mal, dass es einen Push erfahren hat. Bei dieser Rechnung sind die Pop-Operationen von Multipop inbegriffen. Es sind also höchstens so viele Kosten für Pop-Operationen möglich wie für Push-Operationen, d.h. höchstens n. Die Gesamtlaufzeit ist also in O(n), und damit ist der amortisierte Aufwand einer einzelnen Operation in der Folge der n Stack-Operationen in O(). 0.. Die Buchungsmethode Es werden verschiedene Gebühren für verschiedene Operationen veranschlagt. Die Gebühr pro Operation ist dann der amortisierte Aufwand der Operation. Falls der amortisierte Aufwand einer einzelnen Operation höher ist als der wirkliche Aufwand, so wird die Differenz als Kredit speziellen Objekten zugeordnet. Dieser Kredit kann später benutzt werden, um Aufwand, der höher als der amortisierte Aufwand einer Operation ist, auszugleichen. Der amortisierte Aufwand muss sorgfältig veranschlagt werden. Der Kredit darf niemals negativ sein, denn die gesamte amortisierte Laufzeit einer Folge von Operationen muss immer eine obere Schranke für die wirkliche Laufzeit sein. Tatsächlicher Aufwand bei Stack-Operationen: Definiere amortisierten Aufwand (Gebühr): Push(S, x): Pop(S): Multipop(S, k): min( S, k) Push(S, x): Pop(S): 0 Multipop(S, k): 0 Beispiel 0.7 (Tabletts in der Mensa). Wenn wir ein Tablett auf den Stack legen, bezahlen wir zwei Einheiten. Eine Einheit wird sofort verwendet, um die wirklichen Kosten der Push- Operation zu bezahlen. Die zweite Einheit bleibt auf dem Tablett liegen. Wenn das Tablett ein Pop-Operation erfährt, egal ob durch Pop oder Multipop, wird die Einheit auf dem Tablett verwendet, um die wirklichen Kosten für Pop zu bezahlen. Offensichtlich ist der Kredit niemals negativ. Bei einer Folge von n Push-, Pop- und Multipop-Operationen benötigen wir höchstens n amortisierte Gesamtkosten, da für maximal n Push-Operationen je zwei als amortisierte Kosten veranschlagt werden. Die Gesamtlaufzeit ist also in O(n) Die Potentialmethode Es wird aus zu hoch veranschlagten Kosten ein Potential aufgespart, das später verbraucht werden kann. Starte mit einer Datenstruktur D 0, auf der n Operationen ausgeführt werden. Für i =,,..., n seien c i : die tatsächlichen Kosten der i-ten Operation D i : die Datenstruktur nach der i-ten Operation (angewandt auf D i ). Definiere eine Potentialfunktion C : D i C(D i ) Potential von D i und den amortisierten Aufwand ĉ i der i-ten Operation bzgl. C als ĉ i := c i + C(D i ) C(D i ) Die amortisierten Kosten sind also die tatsächlichen Kosten plus dem Zuwachs (oder Verlust) an

20 8 Grundlagen Potential entsprechend der Operation. Das heißt: n n ĉ i = (c i + C(D i ) C(D i )) i= = i= n c i + C(D n ) C(D 0 ). i= Wenn C so definiert wird, dass C(D n ) C(D 0 ) ist, dann sind die amortisierten Kosten eine obere Schranke für die Gesamtkosten. Im allgemeinen ist nicht unbedingt im vorhinein klar, wieviele Operationen ausgeführt werden. Falls C(D i ) C(D 0 ) für alle i, so ist allerdings garantiert, dass (wie bei der Buchungsmethode) im voraus immer genug Kredit angespart wurde. Oft ist es günstig, C so zu wählen, dass C(D 0 ) = 0 ist und zu zeigen, dass C(D i ) 0 ist für alle i. Intuitiv ist klar: Falls C(D i ) C(D i ) > 0 ist, dann wird durch die amortisierten Kosten ĉ i eine überhöhte Gebühr für die i-te Operation dargestellt, d.h. dass das Potential wächst. Falls C(D i ) C(D i ) < 0 ist, so ist ĉ i zu tief veranschlagt. Beispiel: Stack mit Multipop: Definiere C als Anzahl der Objekte auf dem Stack. Dann ist C(D 0 ) = 0. Da die Anzahl der Objekte auf einem Stack nie negativ ist, gilt für alle i C(D i ) C(D 0 ). C ist also gut gewählt, da die amortisierten Gesamtkosten l i= c i + C(D l ) C(D 0 ) zu jedem Zeitpunkt l eine obere Schranke für die wirklichen Gesamtkosten sind. Betrachte den amortisierten Aufwand für die verschiedenen Stack-Operationen:. Die i-te Operation sei ein Push, auf einen Stack mit s Objekten angewandt: Daraus folgt c i = und C(D i ) C(D i ) = (s + ) s =. ĉ i = c i + C(D i ) C(D i ) = + =.. Die i-te Operation sei ein Pop, angewandt auf einen Stack mit s Objekten: Daraus folgt c i = und C(D i ) C(D i ) = s s =. ĉ i = = 0.. Die i-te Operation sei ein Multipop(S, k), auf einen Stack S mit s Objekten und k := min( S, k) angewandt: Daraus folgt c i = k und C(D i ) C(D i ) = (s k ) s = k. ĉ i = c i + C(D i ) C(D i ) = k k = 0. Also ist n i= ĉi n; die amortisierte Gesamtlaufzeit ist damit im Worst-case in O(n). Bemerkung 0.8. Ein weiteres Beispiel, an dem sich die Ideen der amortisierten Analyse gut erklären lassen, sind dynamische Tabellen: Objekte sollen in einer Tabelle abgespeichert werden, wobei Objekte eingefügt bzw. gelöscht werden können. Zu Beginn einer Folge von Operationen vom Typ Einfügen und Löschen habe die Tabelle die Größe h. Wenn eine Operation Einfügen zu einem Zeitpunkt auf die Tabelle angewandt wird, an dem die Tabelle voll ist, soll eine Tabellenexpansion vorgenommen werden, in der die Tabelle verdoppelt wird. Die Tabellenexpansion (angewandt auf die Tabelle der Größe k) habe wirkliche Kosten k. Entsprechend werde eine Tabellenkontraktion durchgeführt, in der die Tabelle halbiert wird, wenn sie nur noch sehr dünn besetzt ist, etwa höchstens zu 4. Die Tabellenkontraktion angewandt auf eine Tabelle mit k Elementen hat dann wiederum Kosten k. Wie groß ist die amortisierte Laufzeit für eine Folge von n Operationen vom Typ Einfügen bzw. Löschen?

21 0.4 Divide-and-Conquer Verfahren und das Prinzip der Rekursion Divide-and-Conquer Verfahren und das Prinzip der Rekursion Ein grundlegendes algorithmisches Prinzip besteht darin, ein Problem zu lösen, indem man es in Probleme (meist desselben Typs) kleinerer Größe oder mit kleineren Werten aufteilt, diese löst und aus den Lösungen eine Lösung für das Ausgangsproblem konstruiert. Wir werden in den angegebenen rekursiven Algorithmen oft keine explizite Abbruchbedingung angeben. Es wird angenommen, dass eine geeignete Abbruchbedingung eingebaut wird Ein Beispiel aus der Informatik-Grundvorlesung Merge-Sort ist ein Verfahren zum Sortieren einer Folge von n Werten, auf denen es eine Ordnung gibt. Merge-Sort sortiert eine Folge der Länge n, indem es zunächst halb so lange Teilfolgen sortiert und aus diesen die sortierte Folge der Länge n zusammmenmischt. Dies kann, wie im Folgenden beschrieben, auf iterative oder auf rekursive Weise durchgeführt werden. Iterativ bzw. Bottom-up Algorithmus 4 : Iteratives Merge-Sort(S, k) Sortiere zunächst Teilfolgen der Länge zwei und mische sie zu sortierten Folgen der Länge vier zusammen Mische je zwei sortierte Folgen der Länge vier zu sortierten Folgen der Länge acht zusammen u.s.w. Rekursiv Sehr oft werden Divide-and-Conquer Verfahren jedoch rekursiv angewandt. Das bedeutet: Das Verfahren ruft sich selbst wieder auf, angewandt auf Eingaben kleinerer Länge bzw. mit kleineren Werten. Algorithmus 5 : Rekursives Merge-Sort(A, p, r) Eingabe : Array A mit n Elementen, die an den Stellen A[p] bis A[r] stehen. Ausgabe : n Elemente sortiert in Ergebnisarray B. Wenn p < r gilt q p+r B Merge-Sort(A; p, q) B Merge-Sort(A; q +, r) 4 B Merge(B ; B ) 5 6 sonst B A[p] } rekursive Aufrufe Die Hauptarbeit besteht hier bei Merge-Sort (vgl. Algorithmus 5), wie auch bei den meisten Divide-and-Conquer Verfahren, im Zusammensetzen der Teillösungen, bei Merge-Sort also in Merge (Zeile 4). Merge informell: Durchlaufe A einerseits von A[p] bis A[q] und andererseits von A[q+] bis A[r] und vergleiche die Elemente jeweils paarweise. Das kleinere der Elemente wird weggeschrieben

22 0 Grundlagen (in ein Ergebnisarray) und in dem entsprechenden Teil von A um eine Position weitergegangen. Ist man bei A[q] oder A[r] angelangt, wird der restliche Teil des anderen Teilarrays von A an das Ergebnisarray angehängt. Die Einträge aus dem Ergebnisarray könnten dann an die Stellen A[p] bis A[q] kopiert werden. Merge hat also eine Laufzeit, die linear in der Länge der Eingabe ist, also in O(n) ist. Aus der rekursiven Beschreibung für Merge-Sort können wir als Laufzeit T (n) insgesamt ablesen: T (n) = T ( n/ ) + T ( n/ ) + k n }{{} für Merge mit k 0 Konstante. Solche Rekursionsgleichungen sind typisch für rekursiv beschriebene Divide-and-Conquer- Algorithmen. Wie schätzt man eine Laufzeitfunktion, die als Rekursionsgleichung (bzw. Rekursionsungleichung) gegeben ist, möglichst gut ab? Zur Erinnerung: Bei Merge-Sort ist T (n) O(n log n). Der Beweis wird induktiv geführt, vgl. Informatik Grundvorlesungen Methoden zur Analyse von Rekursionsabschätzungen Die Laufzeit eines Algorithmus, der nach dem Prinzip teile und herrsche arbeitet ist oftmals leicht abschätzbar in Form einer Rekursionsabschätzung wie beispielsweise: T (n) = m T ( n ) + f(n). i= Beispiel 0.9 (Laufzeit von Mergesort). Der Algorithmus Mergesort hat die Laufzeit : T (n) = T ( n ) + cn Θ(n log n) (c > 0 konstant) Siehe dazu Informatik I + II. Die folgenden Methoden stehen zur Verfügung:. Substitutionsmethode: Wir vermuten eine Lösung und beweisen deren Korrektheit induktiv.. Iterationsmethode: Die Rekursionsabschätzung wird in eine Summe umgewandelt und dann mittels Techniken zur Abschätzung von Summen aufgelöst.. Meistermethode: Man beweist einen allgemeinen Satz zur Abschätzung von rekursiven Ausdrücken der Form T (n) = a T (n/b) + f(n), wobei a und b >. Normalerweise ist die Laufzeitfunktion eines Algorithmus nur für ganze Zahlen definiert. Entsprechend steht in einer Rekursionsabschätzung eigentlich T ( n/b ) oder T ( n/b ). Außerdem haben Laufzeitfunktionen T (n) die Eigenschaft, dass zwar T (n) O() ist für kleine n, allerdings oft mit großer O-Konstante. Meistens kann man diese Details jedoch vernachlässigen.

23 0.4 Divide-and-Conquer Verfahren und das Prinzip der Rekursion 0.4. Die Substitutionsmethode Betrachte als Beispiel wieder die Laufzeitfunktion, von Merge-Sort (siehe Algorithmus 5) von der wir wissen, dass sie in O(n log n) liegt. Es gilt: T (n) = T ( n/ ) + T ( n/ ) + n. Wir beweisen, dass T (n) c n log n für geeignetes c > 0, c konstant ist. Dazu nehmen wir als Induktionsvoraussetzung an, dass die Abschätzung für Werte kleiner n gilt, also insbesondere Im Induktionsschritt erhalten wir also: T ( n/ ) c n/ log( n/ ) und T ( n/ ) c n/ log( n/ ). T (n) c n/ log n/ + c n/ log n/ + n c n/ (log n ) + c n/ log n + n = c n log n c n/ + n c n log n für c, n. Für den Induktionsanfang muss natürlich noch die Randbedingung bewiesen werden, z.b. für T () =. Dies ist oft problematisch. Es gilt beispielsweise für kein c > 0, dass T () = c log = 0 ist. Da uns bei Laufzeitfunktionen allerdings asymptotische Abschätzungen genügen, d.h. Abschätzung für n n 0, können wir auch mit der Randbedingung T (4) starten, d.h. T (4) = T () + 4 = 4 T () + 8 = c 4 log 4 = c 8 für c. Wie kommt man an eine gute Vermutung? Es gibt keine allgemeine Regel für die Substitutionsannahme, aber einige heuristische Kochrezepte. Lautet die Rekursionsgleichung etwa T (n) = T (n/ + 7) + n, so unterscheidet sich die Lösung vermutlich nicht substantiell von der Lösung für obige Rekursion, da die Addition von 7 im Argument von T für hinreichend große n nicht so erheblich sein kann. In der Tat ist hier wieder T (n) O(n log n) und dies kann wieder mit Induktion bewiesen werden. Manchmal lässt sich zwar die korrekte Lösung leicht vermuten, aber nicht ohne weiteres beweisen. So ist vermutlich T (n) = T ( n/ ) + T ( n/ ) + O(n). Versucht man jedoch zu beweisen, dass T (n) c n für geeignetes c > 0 ist, so erhält man im Induktionsschritt aber kein c > 0 erfüllt T (n) c n. T (n) c n/ + c n/ + = c n +, Trick: Starte mit der schärferen Vermutung T (n) c n b für c > 0 und einer geeigneten Konstanten b 0. Dann gilt T (n) c n/ b + c n/ b + c n b + c n b für b. Ein weiterer Trick, der oft funktioniert, ist die Variablenersetzung, wie in Beispiel 0.0 demonstriert.

24 Grundlagen Beispiel 0.0. T (n) = T ( n ) + log n. Setze m = log n, also n = m, dann ergibt sich T ( m ) = T ( m/ ) + m T ( m/ ) + m. Setzt man nun S(m) := T ( m ), so gilt S(m) S(m/) + m O(m log m). Rückübersetzung von S(m) nach T (m) ergibt dann T (n) = T ( m ) = S(m) O(m log m) = O(log n log log n) Die Iterationsmethode Eine naheliegende Methode zur Auflösung einer Rekursionsgleichung ist deren iterative Auflösung. Beispiel 0.. T (n) = T ( n/4 ) + n = n + ( n/4 + T ( n/6 )) = n + ( n/4 + ( n/6 + T ( n/64 ))) = n + n/4 + 9 n/6 + 7 T ( n/64 ). Wie weit muss man die Rekursion iterativ auflösen, bis man die Randbedingungen erreicht? Der i-te Term ist i n/4 i. Die Iteration erreicht im Argument, wenn n/4 i, d.h. wenn i log 4 n. Dann ergibt sich T (n) n + n/4 + 9 n/6 + 7 n/ log 4 n c für c 0 konstant ( ) i n + c n log 4, da log 4 n = n log 4 4 i=0 = 4n + c n log 4 O(n), da log 4 <. Die Iterationsmethode führt oft zu aufwendigen (nicht unbedingt trivialen) Rechnungen. Durch iterative Auflösung einer Rekursionsabschätzung kann man jedoch manchmal zu einer guten Vermutung für die Substitutionsmethode gelangen Der Aufteilungs-Beschleunigungssatz (Meistermethode, Master- Theorem) Satz 0. (Aufteilungs-Beschleunigungssatz (Master-Theorem), eingeschränkte Form). Seien a, b >, c > 0 und c > 0 Konstanten und T (n) über nichtnegative ganze Zahlen definiert durch Für n = b q gilt c T () c und a T (n/b) + c n T (n) a T (n/b) + c n.

25 0.4 Divide-and-Conquer Verfahren und das Prinzip der Rekursion (i) T (n) Θ(n), falls b > a. (ii) T (n) Θ(n log n), falls a = b. (iii) T (n) Θ(n log b a ), falls b < a. Satz 0. ist eingeschränkt auf den Fall, dass f(n) Θ(n) ist, wir beweisen ihn nur für Potenzen von b, d.h. n = b q. Letztere Einschränkung wird aus technischen Gründen vorgenommen; man kann für n b q die Analyse unter Betrachtung der nächsten Potenzen von b, d.h. n = b q+ für n = b q < n < n durchführen. Die Einschränkung auf f(n) Θ(n) vereinfacht den Beweis insofern, dass man nicht ausführlich f(n) gegenüber a T (n/b) abschätzen muss. Beweis. Durch Induktion über q beweisen wir dass T (n) c n q (a/b) i. Für q = 0 ergibt sich T () c. Die Behauptung gelte also für q > 0. Betrachte q + : i=0 T (b q+ ) a T (b q ) + c b q+ ( q a c b q (a/b) i) + c b q+ i=0 ( q ) = c b q+ (a/b) i+ + = c b q+ i=0 ( q+ ) (a/b) i + i= q+ = c b q+ (a/b) i. i=0 Analog lässt sich auch folgern q T (n) c n (a/b) i. i=0 Fall b > a Dann ist a/b < und es gibt Konstante k, k > 0, so dass c n k T (n) c n k, d.h. T (n) Θ(n). Fall b = a q T (n) = T (b q ) c b q i = c b q (q + ) und T (n) c b q (q + ), also T (n) Θ(n log n). Fall b < a q q T (n) = T (b q ) c b q (a/b) i = c a i b q i = c i=0 i=0 q a q i b i = c a q i=0 i=0 i=0 q (b/a) i.

26 4 Grundlagen Dann gibt es Konstante k, k > 0, so dass c a log b }{{ n } k T (n) c a logb n }{{} k =n log b a =n log b a und damit T (n) Θ(n log b a ). Bemerkung 0.. Gelten in der Voraussetzung von Satz 0. nur die Beschränkungen nach oben (unten), so gilt immer noch T (n) O(n) (bzw. T (n) Ω (n)). Allgemeiner als Satz 0. gilt der folgende Satz: Satz 0.4 (Master-Theorem). Seien a und b > Konstanten, f(n) eine Funktion in n und T (n) über nichtnegative ganze Zahlen definiert durch wobei n/b für n/b oder n/b steht. T (n) = a T (n/b) + f(n), (i) T (n) Θ(f(n)) falls f(n) Ω(n log b a+ε ) und af( n b ) cf(n) für eine Konstante c < und n n 0, (ii) T (n) Θ(n log b a log n) falls f(n) Θ(n log b a ), (iii) T (n) Θ(n log b a ) falls f(n) O(n log b a ε ). Beachte, dass die Fälle aus Satz 0. und 0.4 korrespondieren. Es existieren noch allgemeinere Formulierungen dieses Satzes, wie zum Beispiel die folgende: Satz 0.5 (Allgemeinere Form des Master-Theorems). Es sei T (n) = m T (α i n) + f(n), i= wobei gilt 0 < α i <, m und f(n) Θ(n k ), k 0. Dann ist i) T (n) Θ(n k ) falls m i= αk i <, ii) T (n) Θ(n k log n) falls m i= αk i =, iii) T (n) Θ(n c ) falls m i= αk i >. wobei c bestimmt wird durch m αi c = i= Die Beweise der Sätze 0., 0.4 und 0.5 lassen sich jeweils per Induktion führen. Beispiel 0.6. Merge-Sort T (n) = T ( n/ ) + T ( n/ ) + n b =, a =, f(n) Θ(n) = Θ(n log ) Aus Fall (ii) folgt T (n) Θ(n log n).

27 0.4 Divide-and-Conquer Verfahren und das Prinzip der Rekursion 5 Beispiel: Matrix-Multiplikation nach Strassen Gegeben seien zwei (n n)-matrizen A, B. Berechne A B mit möglichst wenigen Operationen. Herkömmlich: C = A B = (a ij ) (b ij ) = (c ij ) mit c ij = n k= a ik b kj. Die Laufzeit ist insgesamt in O(n ). Ein Divide-and-Conquer Ansatz für die Matrixmultiplikation ist: ( ) ( ) ( ) a a A B = b b c c = = C, a a 4 b b 4 c c 4 wobei die a i, b i, c i (n/ n/)-matrizen sind. Dann berechnet sich C durch c = a b + a b c = a b + a b 4 c = a b + a 4 b c 4 = a b + a 4 b 4 8 Matrixmultiplikationen von (n/ n/)-matrizen und 4 Additionen von (n/ n/)-matrizen Addition zweier (n n)-matrizen ist in Θ(n ). Damit ergibt sich T (n) = 8 T (n/) + c n, c > 0 Konstante, c n O(n log 8 ε ) = O(n ε ) mit 0 < ε = = T (n) Θ(n log 8 ) = Θ(n ) (leider!) Für die Laufzeit ist offensichtlich die Anzahl der Multiplikationen verantwortlich. Das heißt: Wenn man die Anzahl der Multiplikationen der (n/ n/)-matrizen auf weniger als 8 reduzieren könnte bei ordnungsmäßig gleicher Anzahl von Additionen erhält man eine bessere Laufzeit. Es gibt einen Divide-and-Conquer Ansatz von Strassen, der nur 7 Multiplikationen bei 8 Additionen verwendet. Als Laufzeit ergibt sich dann T (n) = 7 T (n/) + c n = T (n) Θ(n log 7 ). Schema: c = P 5 + P 4 P + P 6 c = P + P c = P + P 4 c 4 = P 5 + P P P 7 mit P = a (b b 4 ) P = (a + a ) b 4 P = (a + a 4 ) b P 4 = a 4 (b b ) P 5 = (a + a 4 ) (b + b 4 ) P 6 = (a a 4 ) (b + b 4 ) P 7 = (a a ) (b + b ) Beispiel: Das Auswahlproblem (Select) Das Auswahlproblem lautet wie folgt: Finde aus dem Array A[,..., n] das i-kleinste Element, mit i n. O.B.d.A. seien dabei die Elemente A[],..., A[n] paarweise verschieden. Dieses Problem ist mit Hilfe eines Sortierverfahrens in O(n log n) lösbar. Ein einfacher Sortieralgorithmus verfährt wie in Algorithmus 6. Mit Merge-Sort als Sortieralgorithmus ergibt sich beispielsweise eine Laufzeit in Θ(n log n). Ein Verfahren mit linearer Worst-case-Laufzeit ist Select(n, i): Laufzeitanalyse von Select: Die Schritte,, 4 und 5 sind in O(n).

28 6 Grundlagen Algorithmus 6 : SlowSelect(A, i) Eingabe : Unsortierte Folge von Zahlen Ausgabe : i-kleinstes Element Sortiere die Elemente in aufsteigender Reihenfolge Gib das i. Element der sortierten Folge aus Algorithmus 7 : Select(A, i) Eingabe : Unsortiertes Array A von n verschiedenen Zahlen A = (A[],..., A[n]) Ausgabe : Das i-kleinste Element aus A Teile A in n 5 Gruppen mit jeweils 5 Elementen und eine Gruppe mit n 5 n 5 Elementen. Bestimme für jede Gruppe das mittlere Element, sammle diese in M. Rufe Select(M, n 0 ) auf, mit dem Array M bestehend aus den n 5 mittleren Elementen, um rekursiv das mittlere der mittleren Elemente m zu bestimmen A Elemente a i aus A mit a i m A Elemente a j aus A mit a j > m Falls i A rufe Select(A, i) auf, sonst Select(A, i A ) Schritt benötigt T ( n/5 ) Zeit. Schritt 6 benötigt T (max( A, A ) Zeit; dabei ist T (n) die Laufzeit von Select(n, i) mit i n. Dieses Verfahren hat die Laufzeit T (n) T ( n 5 )+T (max( A, A ))+cn. Man beachte zunächst für A, dass mindestens die Hälfte aller n/5 vollen Gruppen mindestens Elemente (die Mehrzahl) zu A beisteuern, abzüglich dem einen, mittleren Element. Analoges gilt für A. Somit lässt sich max( A, A ) abschätzen: T (n) A n 5 > ( n ) 5 = 0 n 5 A < 7 0 n + 5. Analog gilt A n 5 > 0 n, 5 A < 7 0 n +, 5. Also gilt max( A, A ) 7 0 n +, 5 Zunächst stellen wir fest, dass ab n 9 gilt: n > 7 0n +, 5. Somit muss ab n < 9 die Rekursion abgebrochen werden. Es gilt also { c 0 n n n 0, n 0 > 9 geeignet gewählt T ( n 5 ) + T ( 7 0 n +, 5) + c n für n > n 0 Wir beweisen T (n) O(n) durch Substitution. Sei also T (n) cn für eine Konstante c > 0 und alle n n 0. Für n > n 0 folgt dann per Induktion: n ( ) 7 T (n) c + c 5 0 n +, 5 + c n c n 5 + c + c 7 0 n +, 5c + c n = c 9 0 n +, 5c + c n.

29 0.4 Divide-and-Conquer Verfahren und das Prinzip der Rekursion 7 Damit garantiert ist, dass n c (9/0) +, 5 c + c n c n gilt, muss c so gewählt werden können, dass gilt c n c (n/0, 5). Dazu muss n > 5 gelten. In der Abschätzung sollten }{{} >0 nötig wir also n 0 > 5 wählen.

30

31 Kapitel Grundlegende Datenstrukturen für Operationen auf Mengen. Union-Find Das Union-Find-Problem ist ein grundlegendes Problem, das sehr viele Anwendungen in sehr unterschiedlichen Bereichen hat. Neben seiner grundsätzlichen Bedeutung zeichnet es sich durch die Tatsache aus, dass es zwar einen ausgesprochen einfachen (einfach zu implementierenden) Algorithmus zu seiner Lösung gibt, die Analyse dieses Algorithmus jedoch beeindruckend schwierig ist und überraschenderweise eine fast lineare Laufzeit ergibt (aber eben nur fast). Definition.. Das Union-Find-Problem besteht darin, eine Folge disjunkter Mengen zu verwalten, die sich infolge von Vereinigungsoperationen laufend ändert. Gegeben sei eine endliche Grundmenge M. Es soll möglichst effizient eine beliebige Abfolge von Operationen folgenden Typs ausgeführt werden: Makeset(x): Führe eine neue einelementige Menge {x} ein, die zuvor noch nicht existiert hat; x M. Union(S i, S j ; S k ): Bilde eine neue Menge S k := S i S j aus bisher vorhandenen (disjunkten) Mengen S i und S j durch Vereinigung. Entferne S i und S j. Find(x): Für x M gib diejenige Menge der bisher entstandenen Mengen an, welche x enthält... Drei Ansätze Als Beispiel dienen im Folgenden die Mengen S, S, und M: S = {,, 5, 7}, S = {, 4, 8}, M = {,,, 4, 5, 6, 7, 8, 9, 0}. Ansatz Benutze ein Array A, das die Zuordnung von x zum Index der Menge, die x enthält, angibt. x A[x]...

32 0 Grundlegende Datenstrukturen für Operationen auf Mengen Algorithmus 8 : Makeset(x) (#) Eingabe : Element x Seiteneffekte : Neuer Index in A[x] Schreibe in A[x] neuen Index, etwa x Beispiel: Makeset(6), A[6] := 6. Laufzeit ist in O(). Algorithmus 9 : Find(x) (#) Eingabe : Element x Ausgabe : Menge, in der x enthalten ist Gib A[x] aus Laufzeit ist in O(). Algorithmus 0 : Union(S i, S j, S k ) (#) Eingabe : Mengen S i, S j, S k Seiteneffekte : Mengen S i, S j werden zur neuen Menge S k vereint Für x M Wenn A[x] = i A[x] = j A[x] k Laufzeit ist in O( M ). Wenn also eine beliebige Folge von n Operationen vom Typ Makeset, Find und Union ausgeführt wird, so ist die Laufzeit dafür in O(n ), falls M O(n). Wir setzen im Folgenden voraus: M O(n).. Ansatz Repräsentiere Mengen durch Wurzelbäume, d.h. jede Menge ist eine Struktur Baum, dessen Knoten die Elemente der Menge sind. Diese Bäume, wie in Abbildung. entstehen durch die Operationen Makeset und Union. Als Mengenindex diene jeweils die Wurzel des Baumes. Dann neue Menge S Abbildung.: Einige Mengen, erzeugt durch Makeset und Union werden zwei Mengen vereinigt, indem der eine Baum an die Wurzel des anderen gehängt wird. Als Mengenindex der neuen Menge diene der Index der Menge, an deren Wurzel angehängt wurde, wie in Abbildung.. Union(S, S, S ) Union(,, ) und Union(S, S 6, S 6 ) Union(, 6, 6) Wir schreiben zur Vereinfachung auch Union(S i, S j ) statt Union(S i, S j, S k ). Find wird für ein Element x ausgeführt, indem von dem entsprechenden Knoten aus durch den Baum bis zu dessen Wurzel gegangen wird. Die Repräsentation der Bäume erfolgt durch ein Array

33 . Union-Find Abbildung.: Resultat von Union(S, S, S ) 7 Vor, in dem in Vor[x] der Vorgänger von x im Baum abgelegt ist. Dabei setzen wir Vor[x] := 0, wenn x eine Wurzel ist. x Vor[x] Algorithmus : Find(x) (#) Eingabe : Element x Ausgabe : Menge, in der x enthalten ist j x Solange Vor[j] 0 (und definiert) tue j Vor[j] 4 Gib j aus Die Laufzeit ist in O(n). Algorithmus : Union(i, j) (#) Eingabe : Mengen S i, S j Seiteneffekte : Elemente der Menge S i werden zur Menge S j hinzugefügt Vor[i] j Algorithmus : Makeset(x) (#) Eingabe : Element x Seiteneffekte : Neuer Index in A[x] Vor[x] 0 Die Laufzeit für Union und Makeset ist in O(). Gesamtlaufzeit: Bei einer Folge von n Operationen vom Typ Makeset, Union und Find ist die Gesamtlaufzeit in Θ(n ): Θ(n) Operationen vom Typ Makeset (z.b n/4), gefolgt von Θ(n) Operationen vom Typ Union, gefolgt von Θ(n) Operationen vom Typ Find. Operationen vom Typ Find sind also besonders teuer, da durch Union sehr hohe Bäume entstehen können, wie in Abbildung. zu sehen.

34 Grundlegende Datenstrukturen für Operationen auf Mengen l l l Höhe O(n) Abbildung.: Tiefe eines Baumes Eine Folge von t verschiedenen Find hat dann eine Laufzeit von mindestens (weil t Θ(n)). t i Θ(t ) = Θ(n ) i=. Ansatz Wie nehmen zwei Modifikationen am zweiten Ansatz vor: Modifikation : ein Ausgleich bei Union: weighted Union rule oder balancing. Modifikation : Pfadkompression bei Find. Modifikation : weighted Union : Bei der Ausführung von Union wird immer der kleinere Baum an den größeren Baum gehängt, wie in Abbildung.4. Kleiner bzw. größer bezieht sich hier einfach auf die Anzahl der Knoten (Kardinalität der entsprechenden Menge). Um zu entscheiden, welcher Baum kleiner bzw. größer ist, wird in Vor[x] für Wurzeln x jeweils die Knotenzahl des Baums als negative Zahl gespeichert. Das negative Vorzeichen kennzeichnet die Wurzeleigenschaft und der Betrag die Kardinalität der Menge. Formal: Union(i, j): Es gilt: Vor[i] = #(Knoten im Baum i) Vor[j] = #(Knoten im Baum j) Algorithmus 4 : Union(i, j) (#) 4 5 z Vor[i] + Vor[j] Wenn Vor[i] < Vor[j] Vor[i] j und Vor[j] z sonst Vor[j] i und Vor[i] z. Die Laufzeit ist offensichtlich in Θ(). Lässt sich nun etwas über die Höhe von Bäumen aussagen, die durch weighted Union entstanden sind? Lemma.. Entsteht durch eine Folge von Makeset und weighted Union über einer Menge M ein Baum T mit T = t (T enthält t Knoten), so ist h(t ) log t, wobei h(t ) die Höhe von T ist, also die maximale Anzahl von Kanten auf einem einfachen Weg von der Wurzel von T zu einem Blatt von T.

35 . Union-Find i Vor[i] = 6 j Vor[j] = j Vor[j] = 7 Vor[i] = j i Abbildung.4: weighted Union : Union(i, j) Beweis. Induktion über die Anzahl der Union-Operationen. Solange keine Union-Operation ausgeführt wurde, haben alle Bäume Höhe 0 und einen Knoten, d.h. es gilt für alle T : h(t ) = 0 log = 0. Betrachte die n-te Union-Operation, etwa Union(i, j), wobei T i Baum mit Wurzel i und T j Baum mit Wurzel j vor Ausführung der Operation Union(i, j) sei. O.B.d.A. sei T j T i. Dann wird T i durch Union(i, j) an die Wurzel j von T j angehängt und es entsteht der Baum T Union(i,j) mit h(t Union(i,j) ) = max(h(t j ), h(t i ) + ). Falls h(t j ) > h(t i ) +, dann ist Falls h(t j ) h(t i ) +, dann ist h(t Union(i,j) ) = h(t j ) log ( T j ) log ( T Union(i,j) ). h(t Union(i,j) ) = h(t i ) + log ( T i ) + log ( T i ) log ( T Union(i,j) ). Beobachtung.. In einem durch weighted Union-Operationen entstandenen Baum kann jede Find-Operation in O(log n) Zeit ausgeführt werden. Für eine Folge von n Makeset-, Unionund Find-Operationen ergibt sich dann eine Gesamtlaufzeit von O(n log n).

36 4 Grundlegende Datenstrukturen für Operationen auf Mengen Modifikation : Pfadkompression: Bei der Pfadkompression werden bei der Ausführung einer Operation Find(i) alle Knoten, die während dieses Find durchlaufen werden, zu direkten Nachfolgern der Wurzel des Baumes gemacht, in dem Knoten i liegt. Abbildung.5 illustriert wie Pfadkompression entsprechend Algorithmus 5 erfolgt. Algorithmus 5 : Find(x) (#) Eingabe : Element x Ausgabe : Menge, in der x enthalten ist j x Solange Vor[j] > 0 tue j Vor[j] i x Solange Vor[i] > 0 tue temp i i Vor[i] Vor[temp] j Gib j aus Auch bei Find mit Pfadkompression hat eine Operation Find eine Worst-case-Laufzeit von O(log n). Die Gesamtlaufzeit ist also weiterhin in O(n log n). Eine genauere amortisierte Analyse ergibt jedoch eine bessere Gesamtlaufzeit von O(n G(n)), wobei G(n) sehr, sehr langsam wächst wesentlich langsamer als log n. G(n) ist für alle praktisch relevanten Werte n klein, d.h. G(n) verhält sich praktisch wie eine Konstante. Definition.4. wobei F (0) := und F (y) = F (y ) für y > 0. Wie schnell wächst F (n) bzw. G(n)? G(n) := min{y : F (y) n}, F (0) F () F () F () F (4) F (5) = = 4 = 6 = 6556 = = = 4 = 6 = 6556 Für alle praktisch relevanten Werte von n ist also G(n) 5. Man schreibt oft auch log (n) für G(n)... Die Laufzeit von Union-Find Satz.5 (Hopcroft & Ullman 97). Die Gesamtlaufzeit für eine Folge Q von n Operationen vom Typ Makeset, weighted Union und Find mit Pfadkompression ist in O(n G(n)). Für eine beliebige Folge Q von Operationen trennen wir die Laufzeit für die Makeset- und Union- Operationen von der Laufzeit für die Find-Operationen. Die Gesamtlaufzeit für alle Makesetund alle Union-Operationen ist in O(n). Die Gesamtlaufzeit für alle Find-Operationen ist im wesentlichen proportional zu der Anzahl der durch Find-Operationen bewirkten Knotenbewegungen (Zuteilung eines neuen Vorgängers). Eine einzelne solche Knotenbewegung hat Aufwand O(). Die Knotenbewegungen werden in zwei Klassen A und B aufgeteilt. Dazu werden Ranggruppen γ,..., γ G(n)+ gebildet, für die sich die jeweilige Anzahl an Knotenbewegungen leicht aufsummieren lässt. Im Folgenden dieses Abschnitts beweisen wir Satz.5.