UNION-FIND / 1 ADT UNION-FIND verwaltet disjunkte Zerlegung S1

UNION-FIND / 1
Universität Paderborn
Theoretische Informatik
Prof. Dr. rer. nat. Burkhard Monien
ADT UNION-FIND
verwaltet disjunkte Zerlegung S1,..., Sk von V = { 1 ,...,n }
Operationen:
Make-Set (v) :
Union (x,y) :
Find-Set (x) :
Erzeugt Menge { v } mit Namen {v}
x sei in Si , y sei in Sj
→ erzeuge Si ∪ Sj , gebe der Menge
beliebigen Namen aus Si ∪ Sj ,
“zerstöre“ Si, Sj
Finde namengebendes Element
der Menge, in der x liegt.
UNION-FIND / 2
DS1: Array und Listen
Universität Paderborn
Theoretische Informatik
Prof. Dr. rer. nat. Burkhard Monien
A [1 : n]:
A[i] enthält Name der Menge, die i enthält
→ Make-Set & Find-Set benötigen Zeit O(1)
Aber: Union benötigt Zeit
O(n)
L(S):
zusätzlich zu Array A halten wir eine Lineare Liste
für Menge S (identifiziert durch Namen von S),
weiterhin: Size (S), Größe von S.
Union (x,y):
Zeit:
i = Find-Set (x) ; j = Find-Set (y) ;
(Sei (οBdA)
Size (Si) >= Size (Sj))
Durchlaufe Sj und aktualisiere die
zugehörigen Einträge in A mit i .
L(Si) = L (Si) υ L(Sj), Size(Si) + = L(Sj),
Make-Set, Find-Set: O(1)
Union O(min(|Si| , |Sj|)
UNION-FIND / 3
Universität Paderborn
Theoretische Informatik
Prof. Dr. rer. nat. Burkhard Monien
Zeit für n-1 Unions, startend bei n einelementigen Mengen:
O(n log(n))
Zeit für Algorithmus von Kruskal:
O(|E| log |E|)
+ O(|V| log |V|)
+ O(|V|)
+ O(|E|)
= O(|E| log |E|)
(sortieren)
(n-1 mal Union)
(n mal Make-Set)
(2|E| mal Find-Set)
UNION-FIND / 4
DS 2 :
Universität Paderborn
Theoretische Informatik
Prof. Dr. rer. nat. Burkhard Monien
Bäume
Jede Menge wird als Baum verwaltet, Wurzel ist Namenselement.
Zu jedem Baum gibt es Variable Size (S)
Make-Set 9
Find-Set (v) : Laufe von v aus in seinem Baum zur Wurzel,
dort steht Name
Union (x,y) : i = Find-Set (x) ; j = Find-Set (y) ;
(οBdA sei Size (Si) ≥ Size (Sj))
Hänge Wurzel von Sj unter Wurzel von Si ;
Size (Si) ← Size (Si) + Size (Sj)
Zeit : Make-Set:
O(1)
Find-Set (x) : O(Tiefe des Baums in dem x liegt).
Union(x, y): O(Tiefe des B. mit x + Tiefe des B. mit y).
UNION-FIND / 5
Universität Paderborn
Theoretische Informatik
Prof. Dr. rer. nat. Burkhard Monien
Wie tief werden die Bäume ?
Behauptung: Baum mit Tiefe d hat mind. 2 d Knoten.
→ Union benötigt Zeit O(log(n))
→ Zeit für Kruskal‘s Algorithmus wird dadurch nicht
verbessert.
UNION-FIND / 6
Universität Paderborn
Theoretische Informatik
Prof. Dr. rer. nat. Burkhard Monien
DS 3 : Bäume und Weg-Komprimierung
Wie DS 2,
aber bei FIND-SET(x) wird jeder Knoten
auf dem Weg von x zur Wurzel
direkt unter die Wurzel gehängt.
→ Zeit für FIND bleibt O(Tiefe des Baumes)
→ Aber: Zeit für n-1 Unions und f Find-SetOperationen: O((n+f ) • log*(n))
log*(n) : = min{k | z(k)≥n} , mit z(0) = 1,
Bsp: log*(n)≤5 für alle n≤265536
z(i) =2 z(i-1)
UNION-FIND / 7
Universität Paderborn
Theoretische Informatik
Prof. Dr. rer. nat. Burkhard Monien
Bäume + Weg-Komprimierung
liefert Zeit O(|E| log*|E|) für Kruskals Algorithmus,
falls Kanten sortiert vorliegen.
(Vorher : Zeit O(|V|log |V| + |E|) ; für
dünne Graphen schlechter als neue DS)
Implementierung des Algorithmus
von Prim / 1
Universität Paderborn
Theoretische Informatik
Prof. Dr. rer. nat. Burkhard Monien
Baum T enhalte Knoten S, R : = V - S.
Wir benötigen zu jedem x∈R eine Kante
(i,x) von S mit i∈S, die minimales Gewicht Key (x) hat.
→ Verwalte R bzgl. der Schlüssel key(x) als
Priority Queue Q.
Initialisierung: R = V, also n mal Insert (Q, x).
Pro Iteration: Extract-Min (Q) ; (Ergebnis sei x)
Decrease-Key (Q, y) für alle Nachbarn y von x.
Implementierung des Algorithmus
von Prim / 2
O(|V| ⋅ log(|V|)
+ O(|E| log(|V|)
Universität Paderborn
Theoretische Informatik
Prof. Dr. rer. nat. Burkhard Monien
(|V| mal Insert,
|V| mal Extract-Min)
(|E| mal Decrease-Key)
= O(|E| log(|E|)
Bessere Implementationen der Priority Queue, durch
Fibonacci-Heaps, liefern Zeit O(|E|) für alle |E| vielen
Decrease-Key-Operationen zusammen.
→ Zeit O(|V|log|V| + |E|) für Algo von Prim.