markiert, 0: unmarkiert.)

Transkript

1 4.2 Fibonacci-Heaps Fibonacci-Heaps (F-Heaps) implementieren adressierbare Priority Queues (siehe Anfang von Kap. 4). Wie bei Binomialheaps besteht der Heap aus heapgeordneten Bäumen, jedoch mit gelockerten Strukturbedingungen. Man kann dadurch erreichen, dass (im amortisierten Sinn) decreasekey-operationen kostengünstiger werden. Die Datenstruktur ist so entworfen, dass eine amortisierte Analyse gut durchführbar ist Aufbau von F-Heaps Ein Knoten v hat folgende Felder: Vaterzeiger p(v) Zeiger auf linkes Geschwister: prev(v) Zeiger auf rechtes Geschwister: next(v) Kindzeiger: child(v) Schlüssel: key: aus U Informationsteil: info (anwendungsabhängig) Rang: rank: int (Anzahl der Kinder) Markierung: marked: boolean (1: markiert, 0: unmarkiert.) Organisation in einem Baum: Vaterzeiger der Wurzel ist NIL, für Nichtwurzeln v zeigt der Vaterzeiger p(v) zum Vaterknoten. child(v) zeigt zu einem (beliebigen) Kindknoten (falls es einen gibt); die Kinder sind (mittels next und prev) als zirkuläre doppelt verkettete Liste ( z.d.v.l. ) organisiert. Die Zahl rank(v) gibt die Anzahl der Kinder von v an. In Blättern ist der Kindzeiger NIL, der Rang 0. In jedem Knoten v, der keine Wurzel ist, gilt die Heapbedingung key(v) key(p(v)). Ein Fibonacci-Heap ist eine Kollektion von solchen heapgeordneten Bäumen, wobei die Wurzeln mit Hilfe ihrer next- und prev-zeiger als zirkuläre doppelt verkettete Liste organisiert sind. Keine Wurzel ist markiert. Auf die Liste wird durch einen Ankerzeiger namens MIN zugegriffen, der auf eine Wurzel mit minimalem Wurzeleintrag zeigt Potenzialfunktion Wenn D ein Fibonacci-Heap ist, ist das Potenzial Φ(D) wie folgt definiert: Φ(D) := #(Wurzeln in D) + 2 #(markierte Knoten in D). Wenn eine Operation op auszuführen ist, ist der F-Heap vorher D, der F-Heap nachher D. 1

2 4.2.3 Hilfsoperationen join und cleanup Die Hilfsoperation join(v, w) wird auf zwei Wurzeln v, w mit gleichem Rang angewendet (rank(v) = rank(w)) und vereinigt die Bäume mit diesen Wurzeln zu einem Baum. Die Wurzel mit kleinerem Schlüssel erhält die Wurzel mit größerem Schlüssel als neues Kind. Prozedur (join(v, w)) Input: Zwei Wurzelknoten v, w von gleichem Rang. (1) if key(v) key(w) (2) then (3) mache w zu neuem Kind von v (4) ( w wird in Kindliste direkt neben child(v) eingefügt ); (5) erhöhe rank(v) um 1 (6) else (7) mache v zu neuem Kind von w (8) erhöhe rank(w) um 1. Der Zeitaufwand für für op = join(v, w) ist O(1). Mit Hilfe von join realisieren wir cleanup, eine weitere Hilfsoperation. Zweck dieser Prozedur ist es, die (eventuell sehr lange) Wurzelliste eines F-Heaps zu kompaktieren, und zwar so, dass alle verbleibenden Wurzeln verschiedene Ränge haben. D(n) N bezeichnet eine (später zu berechnende) obere Schranke für den Rang von Knoten, die in einem F-Heap mit n Einträgen auftreten können. Zur vorläufigen Orientierung: Wir werden sehen, dass D(n) = O(log n) gewählt werden kann. Prozedur (cleanup(l)) Input: Wurzelliste L. Ausgabe: F-Heap D mit den gleichen Einträgen, Ränge aller Wurzeln verschieden. Methode: (1) A[0..D(n)]: Array von Zeigern, die anfangs alle NIL sind. (2) while Wurzelliste L ist nicht leer do (3) entnehme nächste Wurzel r aus L; i := rank(r); w := r (4) while A[i] NIL do (5) w := join(w, A[i]); A[i] := NIL; (6) i := i + 1; (neuer Rang von w) ( der Baum unter w enthält alle Knoten der in (3) (6) bearbeiteten Bäume ) (7) A[i] := w (8) Füge Wurzeln in A[0..D(n)] in neue Wurzelliste ein; (9) ermittle Wurzel r mit minimalem Schlüssel; lasse MIN auf r zeigen. Bemerkung: Das Array A[0..D(n)] dient nur dazu, die join-operationen zu organisieren. Wesentlich ist, dass so lange join-operationen ausgeführt werden, bis alle Wurzeln unterschiedliche Ränge haben. Kostenanalyse: Sei l die anfängliche Länge der Wurzelliste L, l D(n) + 1 die Anzahl der Wurzeln am Ende. 2

3 Der Zeitaufwand ist O(D(n) + l). (Dabei wird D(n) Zeit für die Initialisierung des Arrays A[0..D(n)] und das Auslesen der Liste am Ende benötigt. Es werden l Wurzeln betrachtet und l l join-operationen durchgeführt.) Als tatsächliche Kosten setzen wir daher c cleanup (D, D ) = D(n) + l an. Amortisierte Kosten: Da l l Wurzeln verschwinden, ist die Potenzialdifferenz Φ(D ) Φ(D) = l l. Dabei ist l D(n) + 1, und wir erhalten: a cleanup (D, D ) = c cleanup (D, D ) + Φ(D ) Φ(D) = (D(n) + l) + l l 2 D(n) + 1. (Intuition: Die negative Potenzialdifferenz, die sich durch die verschwindenden Wurzeln ergibt, genügt, um für die join-operationen zu bezahlen.) Einfache Operationen new(): MIN := NIL. Zeitaufwand: O(1). Echte Kosten: 1. Amortisierte Kosten: 1. Beachte: Φ(D 0 ) = 0, für den leeren F-Heap D 0. min(): Gib den Eintrag zurück, auf den MIN zeigt. Zeitaufwand: O(1). Echte Kosten: 1. Amortisierte Kosten: 1. insert(e): Erzeuge neue Wurzel v mit Eintrag e; hänge v direkt neben Knoten MIN in Wurzelliste; setze MIN um, falls key(v) < key(min). Zeitaufwand: O(1). Echte Kosten: c insert = 1. Amortisierte Kosten: a insert (D, D ) = c insert (D, D ) + Φ(D ) Φ(D) = = 2 (die neue Wurzel erhöht das Potenzial um 1). makeheap({e 1,..., e n }): new(); for i from 1 to n do insert(e i ). Zeitaufwand: O(n). Echte Kosten: c makeheap = n. Amortisierte Kosten: a makeheap (D 0, D ) = c makeheap (D 0, D ) + Φ(D ) Φ(D 0 ) = n + n = 2n. (Φ(D ) = n wegen der n Wurzeln.) union(h 1, H 2 ): Vereinigt zwei F-Heaps H 1 und H 2. Die beiden Heaps sind durch Zeiger MIN1 und MIN2 gegeben. Füge die Wurzelliste von H 2 in die Wurzelliste von H 1 ein, setze MIN auf MIN1 oder MIN2, je nachdem, welcher Heap das kleinere Minimum hatte. 3

4 Zeitaufwand: O(1). Tatsächliche Kosten: c union = 1. Amortisierte Kosten: a union = c union = 1, weil sich das Potenzial nicht ändert. Prozedur (deletemin()) Input: F-Heap D. Ausgabe: F-Heap D ohne den Knoten v mit minimalem Eintrag; v. Methode: (1) Sei v die Wurzel, auf die MIN zeigt. (2) Klinke v aus der Wurzelliste aus; Restliste: L; (3) Durchlaufe Kindliste von v; (4) für jedes Kind w von v: (5) p(w) := NIL; marked(w) := 0; hänge w in L ein; (6) cleanup(l); ( liefert F-Heap D ) (7) return(d, v). D sei die Datenstruktur nach Zeile (5) (vor cleanup). Der Zeitaufwand zur Erstellung von D ist O(rank(v)) = O(D(n)). Für Zeilen (1) (5) setzen wir echte Kosten c = 1 + rank(v) an. Amortisierte Kosten für Zeilen (1) (5): a = c + Φ(D ) Φ(D) rank(v) 1 + 2D(n). (Die rank(v) neuen Wurzeln erhöhen das Potenzial um je 1.) Amortisierte Kosten inklusive cleanup(l): a deletemin (D, D ) 2 + 4D(n) = O(D(n)) Komplexe Operation: decreasekey Der Zweck dieser Operation ist, in einem Knoten v den dort vorhandenen Schlüssel y durch einen neuen Schlüssel x y zu ersetzen. Problem: Die Heapbedingung könnte nun verletzt sein, wenn x < key(p(v)) ist. Idee für Abhilfe: Hänge v von seinem Vorgänger p(v) ab und mache v zu einer neuen Wurzel. Auf diese Weise können Knoten Kinder verlieren. Um zu vermeiden, dass die Bäume zu sehr ausdünnen und dadurch sehr große Ränge entstehen, obwohl es nicht viele Knoten gibt, werden die Markierungen verwendet. Wenn ein Knoten w, der keine Wurzel ist, erstmals ein Kind verliert, wird er markiert. Wenn er nochmals ein Kind verliert, wird er selbst zu einer neuen Wurzel gemacht. 4

5 Prozedur (decreasekey(v, x)) Input: F-Heap D, (Zeiger auf) Knoten v, Schlüssel x key(v). Ausgabe: F-Heap D mit denselben Einträgen, Schlüssel in v auf x erniedrigt. Methode: (0) Wenn v Wurzel oder x key(p(v)), setze key(v) := x, return. Sonst: (1) (Idee: Verfolge die Folge v 0 = v, v 1 = p(v 0 ), v 2 = p(v 1 )...) (2) i := 1; v 1 := p(v); (3) Füge v als neue Wurzel neben dem MIN-Eintrag ein; ( v 1 verliert Kind v ) (4) key(v) := x; (5) aktualisiere MIN-Zeiger, falls x neuer minimaler Schlüssel; (6) while v i ist markiert do (7) v i+1 := p(v i ); (8) Füge v i als neue Wurzel (unmarkiert) neben dem MIN-Eintrag ein ( v i+1 verliert Kind v i ); (9) i := i + 1; (10) if v i ist keine Wurzel then markiere v i. Man sieht, dass diese Operation eventuell viele neue Wurzeln erzeugen kann und dabei großen Zeitaufwand benötigt. Dabei verschwinden aber Markierungen, wodurch das Potenzial sinkt. Der (negative) Potenzialunterschied wird benutzt, um für diese Kosten zu bezahlen. Im Gegensatz zu den Binomialheaps wird nicht versucht, jetzt aufzuräumen (cleanup würde zu amortisierten Kosten O(log n) führen). Es seien v 0, v 1,..., v k die Knoten, die zu neuen Wurzeln werden. Möglicherweise wird v k+1 markiert (wenn es keine Wurzel ist). Zeitaufwand: O(k + 1) für das Umhängen der Knoten v 0, v 1,..., v k und das Ändern der Vaterzeiger und Markierungen. Als echte Kosten setzen wir an: c decreasekey (D, D ) = k + 1. Amortisierte Kosten: Das Potenzial verändert sich wie folgt: v 1,..., v k sind nicht mehr markiert, aber werden zu Wurzeln, das Potenzial sinkt dadurch um k; Knoten v wird zu neuer Wurzel, dadurch steigt das Potenzial sicher um 1. Falls v k+1 neu markiert wird, steigt das Potenzial um 2. Für die Potenzialänderung gilt also: Φ(D ) Φ(D) k + 3. Die amortisierten Kosten erfüllen demnach a decreasekey (D, D ) = c decreasekey (D, D ) + Φ(D ) Φ(D) k ( k + 3) = 4, sind also durch eine Konstante beschränkt! Die Operation delete(v), die einen Knoten entfernt, der durch einen Zeiger gegeben ist, kann wie folgt realisiert werden: Man verringert mittels decreasekey den Schlüssel in v auf einen Wert < key(min) und führt dann deletemin() aus. Die amortisierten Kosten hierfür sind a decreasekey (D, D ) + a deletemin (D, D ) 6 + 4D(n) = O(D(n)). 5

6 4.2.6 Analyse des maximalen Grades in Fibonacci-Heaps Wir müssen noch zeigen, dass es eine Schranke D(n) für den maximalen Grad eines Knotens in einem F-Heap mit n Einträgen gibt, die D(n) = O(log n) erfüllt. Definition Die Fibonacci-Zahlen sind wie folgt definiert: F 0 = 0, F 1 = 1, F i = F i 2 + F i 1 für i 2. Bekanntlich sind folgendes die ersten Fibonacci-Zahlen: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,.... Betrachte die bekannte Zahl Φ = 1 2 (1 + 5) = (Das Verhältnis 1 : Φ ist der goldene Schnitt.) Fakt (a) 1 + Φ = Φ 2. (b) Für i 0 gilt: F i+2 Φ i. Beweis: (a) Nachrechnen. (b) Vollständige Induktion. i = 0 : F 2 = 1 = Φ 0. i = 1: F 3 = 2 > Φ 1. Nun sei i 2, die Behauptung gelte für i 2 und i 1. Wir rechnen: F i+2 = F i + F i+1 I.V. Φ i 2 + Φ i 1 = Φ i 2 (1 + Φ) (a) = Φ i. Fakt Für i 1 gilt: 1 + F F i = F i+2. (Beispiel: = 21.) Allgemein ist die Gleichung ganz leicht durch Induktion zu beweisen. Für i = 1 ist sie richtig: 1 + F 1 = = 2 = F 3. Wenn sie für i 1 stimmt (I.V.), folgt: 1 + F 1 + F F i+1 = 2 + F 2 + F F i+1 = 2 + (F 0 + F F i 1 ) + (F 1 + F F i ) also die Induktionsbehauptung. = (1 + F F i 1 ) + (1 + F 1 + F F i ) I.V. = F i+1 + F i+2 = F i+3, In der Analyse von Fibonacci-Heaps spielen die Fibonacci-Zahlen die folgende Rolle: Lemma (a) v Knoten in F-Heap mit rank(v) = i der Unterbaum unter v hat mindestens F i+2 Knoten. (b) F-Heap hat n Einträge alle Ränge sind höchstens D(n) = log 2 n. 6

7 Beweis: (a) Wir benutzen Induktion über die Tiefe des Baums T v unter dem Knoten v (nicht: Induktion über den Rang!). Ind.-Anfang: T v hat Tiefe 0, d. h. er besteht nur aus dem Knoten v. Weil F 2 = 1, stimmt die Behauptung. Ind.-Schritt: Sei v Knoten mit Rang i 1. Es seien w 1,..., w i die aktuell vorhandenen Kinder von v in der Reihenfolge, in der sie zu Kindern von v gemacht wurden (in join-operationen). Der Unterbaum mit Wurzel w j sei T wj. Betrachte ein w j mit j {2,..., i}. Als w j Kind von v wurde, waren w 1,..., w j 1 schon da, also hatte v zu diesem Zeitpunkt Rang mindestens j 1. Nach den Regeln der join-operation (die beiden Knoten haben gleichen Rang) hatte auch w j zu diesem Zeitpunkt Rang mindestens j 1. Nachher kann sich der Rang von w j höchstens um 1 verringert haben (wenn ein zweites Kind von w j abgetrennt worden wäre, wäre w j nach den Regeln für die Behandlung markierter Knoten zur Wurzel gemacht worden). Also gilt aktuell: rank(w j ) j 2, für 2 j i. Nach Induktionsvoraussetzung (T wj hat geringere Tiefe als T v ) hat T wj mindestens F (j 2)+2 = F j Knoten, für 2 j i. Wir schließen: T v hat als Knoten mindestens v und w 1 und die Knoten in T w2,..., T wi, zusammen mindestens 1 + F 1 + F F i = F i+2 viele (mit Fakt 4.2.7). (b) Sei v Knoten mit Rang i in einem Fibonacci-Heap mit n Einträgen. Nach (a) hat T v mindestens F i+2 Knoten, also ist F i+2 n. Mit Fakt 4.2.6: n F i+2 Φ i. Durch Logarithmieren: i log Φ n, oder i (log Φ 2) log 2 n. Dabei ist log Φ 2 = (ln 2)/(ln Φ) = < Zusammenfassung Fibonacci-Heaps sind eine Implementierung des Datentyps Adressierbare Priority Queue. Die Operationen und ihre amortisierten Kosten sind wie folgt, wobei n die Anzahl der Einträge ist: new(): O(1). insert(e): O(1). makeheap({e 1,..., e n }): O(n). union(h 1, H 2 ): O(1). min(): O(1). deletemin(): O(log n). decreasekey(v, x): O(1). 7

8 delete(v): O(log n). Folgerung: Wenn man im Algorithmus von Jarník/Prim für Minimale Spannbäume oder im Algorithmus von Dijkstra für kürzeste Wege von einem Startknoten aus die dort benötigte adressierbare Priority Queue mit einem Fibonacci-Heap implementiert, dann erhält man Laufzeiten von O( V log V + E ), wobei V die Knotenmenge und E die Kantenmenge des betroffenen (Di-)Graphen ist. Dies liegt daran, dass V insert-operationen und V delete- Min-Operationen ausgeführt werden müssen sowie E decreasekey-operationen, und dass maximal n = V Einträge in der Priority Queue liegen. Die gesamten amortisierten Kosten sind O( V log V + E ), und nach dem allgemeinen Resultat zur Potenzialmethode gilt dies dann auch für die gesamten tatsächlichen Kosten. Für alle Graphen mit mindestens V log V Kanten haben diese beiden Algorithmen also lineare Laufzeit! 8