Technische Universit at M unchen Institut f ur Informatik

Technische Universitat Munchen
Institut fur Informatik
E ziente Algorithmen und
Datenstrukturen
WS 1998/99
(WS 97/98)
Stand: 22. Juni 1999
Dozent:
Mitschrift:
Prof. Dr. Ernst W. Mayr
Bardia Kabiri
(Martin Stumpf)
(Thomas Schopf)
(Martin Hans)
(Guido Wimmel)
Inhaltsverzeichnis
0 Einleitung und Aurischung
0.0
0.1
0.2
0.3
Einleitendes Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . .
Was sind "kombinatorische\ Algorithmen? . . . . . . . . . . . . . . .
Maschinenmodelle . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Komplexitatsma
e . . . . . . . . . . . . . . . . . . . . . . . . . . . .
0.3.1 Probleme und Funktionen . . . . . . . . . . . . . . . . . . . .
0.3.2 Wachstumsverhalten von Funktionen . . . . . . . . . . . . . .
0.3.3 Rekursionsgleichungen . . . . . . . . . . . . . . . . . . . . . .
0.3.3.1 Multiplikatoren . . . . . . . . . . . . . . . . . . . . .
0.3.3.2 Charakteristisches Polynom . . . . . . . . . . . . . .
0.3.3.3 Erzeugendenfunktionen . . . . . . . . . . . . . . . .
0.3.3.4 Transformation des Denitions- bzw. Wertebereichs
1 Hohere Datenstrukturen
1.1 Grundlegende Operationen . . . . . . . . . . . . . . . . . . . . .
1.2 Suchbaume, balancierte Baume . . . . . . . . . . . . . . . . . . .
1.2.1 Hohenbalancierte Baume . . . . . . . . . . . . . . . . . .
1.2.1.1 (a,b)-Baume . . . . . . . . . . . . . . . . . . . .
1.2.1.2 Rot-Schwarz-Baume . . . . . . . . . . . . . . . .
1.3 Binare Suchbaume . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3.1 Naturliche binare Suchbaume . . . . . . . . . . . . . . . .
1.3.2 Hohenbalancierte binare Suchbaume (AVL-Baume) . . . .
1.4 Hashing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.4.1 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . .
1.4.2 Chainingverfahren . . . . . . . . . . . . . . . . . . . . . .
1.4.3 Hashing mit oener Adressierung . . . . . . . . . . . . . .
1.4.4 Universelles Hashing . . . . . . . . . . . . . . . . . . . . .
1.4.5 Perfektes Hashing . . . . . . . . . . . . . . . . . . . . . .
1.5 Priority Queues . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.5.1 Binomial Queues (binomial heaps) . . . . . . . . . . . . .
1.5.2 Fibonacci-Heaps . . . . . . . . . . . . . . . . . . . . . . .
1.5.2.1 Die Datenstruktur . . . . . . . . . . . . . . . . .
1.5.2.2 Amortisierte Kostenanalyse fur Fibonacci-Heaps
1.6 Sich selbst organisierende Datenstrukturen . . . . . . . . . . . . .
1.6.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . .
1.6.2 Sich selbst organisierende lineare Listen . . . . . . . . . .
1.6.2.1 Sich selbst organisierende Binary Keys . . . . .
1.6.2.2 Splay-Trees als Suchbaume . . . . . . . . . . . .
1.6.2.2.1 Einleitung . . . . . . . . . . . . . . . .
1.6.2.2.2 Die Splaying-Operation . . . . . . . . .
1.6.2.2.3 Amortisierte Kostenanalyse . . . . . . .
1.6.2.2.4 Worterbuchoperationen in Splay-Trees
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3
3
4
4
4
5
5
6
6
7
8
9
11
11
12
12
12
15
18
18
19
21
21
21
22
24
24
25
25
31
31
34
36
36
36
38
41
41
42
43
47
INHALTSVERZEICHNIS
2
1.6.3 Weitere Arten von Datenstrukturen . . . . . . . . .
1.7 Radix-basierte Priority-Queue . . . . . . . . . . . . . . . . .
1.7.1 Buckets . . . . . . . . . . . . . . . . . . . . . . . . .
1.7.1.1 1-Level-Buckets . . . . . . . . . . . . . . .
1.7.1.2 2-Level-Buckets . . . . . . . . . . . . . . .
1.7.1.3 k-Level-Buckets . . . . . . . . . . . . . . .
1.7.2 Von-Ende-Boas-PQ . . . . . . . . . . . . . . . . . . .
1.7.3 Radix-Heaps . . . . . . . . . . . . . . . . . . . . . .
1.8 Union-Find-Datenstrukturen . . . . . . . . . . . . . . . . .
1.8.0 Motivation . . . . . . . . . . . . . . . . . . . . . . .
1.8.1 Union-Find-Datenstruktur . . . . . . . . . . . . . . .
1.8.1.1 Intrees . . . . . . . . . . . . . . . . . . . .
1.8.1.2 Gewichtete Union (erste Verbesserung) . .
1.8.1.3 Pfad-Kompression mit gewichteten Union
Verbesserung) . . . . . . . . . . . . . . . .
1.8.1.4 Erweiterung . . . . . . . . . . . . . . . . .
.....
.....
.....
.....
.....
.....
.....
.....
.....
.....
.....
.....
.....
(zweite
.....
.....
2 Selektieren und Sortieren
2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
2.9
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Der Blum-Floyd-Pratt-Rivest-Tarjan Selektions-Algorithmus
Randomisierter-Median-Algorithmus . . . . . . . . . . . . . .
Der SPP-Algorithmus . . . . . . . . . . . . . . . . . . . . . .
Eine untere Schranke fur die Medianbestimmung . . . . . . .
Eine bessere untere Schranke . . . . . . . . . . . . . . . . . .
Untere Schranke fur (vergleichbasiertes) Sortieren . . . . . . .
Bucketsort im Schnitt . . . . . . . . . . . . . . . . . . . . . .
Quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4.1 Grundlegende Begrie . . . . . . . . . . . . . . . . . . . . . .
4.2 Das single-source-shortest-path-Problem . . . . . . . . . . . .
4.2.1 Dijkstra's Algorithmus . . . . . . . . . . . . . . . . . .
4.2.2 Dikstra's Algorithmus mit Radix-Heaps . . . . . . . .
4.2.3 Bellman-Ford-Algorithmus . . . . . . . . . . . . . . .
4.3 Floyd's Algorithmus fur das All-pairs-shortest-path-Problem .
4.4 Digraphen mit negativen Kantengewichten . . . . . . . . . . .
4.4.1 Grundsatzliches . . . . . . . . . . . . . . . . . . . . . .
4.4.2 Modikation von Bellman-Ford-Algorithmus . . . . . .
4.4.3 Modikation von Floyd's-Algorithmus . . . . . . . . .
4.4.4 Der Algorithmus von Johnson . . . . . . . . . . . . . .
4.5 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . .
4.6 Transitive Hulle . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3 Minimale Spannbaume
3.0 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . .
3.1 Traversierung von Graphen . . . . . . . . . . . . . . . .
3.1.1 DFS-Algorithmus . . . . . . . . . . . . . . . . . .
3.1.2 DFS-Algorithmus . . . . . . . . . . . . . . . . . .
3.2 Minimale Spannbaume . . . . . . . . . . . . . . . . . . .
3.2.1 Konstruktion von minimalen Spannbaumen . . .
3.2.2 Generischer minimaler Spannbaum-Algorithmus
3.3 Kruskals Algorithmus . . . . . . . . . . . . . . . . . . .
3.4 Prim's Algorithmus, erste Variante . . . . . . . . . . . .
3.5 Prim's Algorithmus, zweite Variante . . . . . . . . . . .
4 Kurzeste Pfade
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
48
48
48
49
51
54
55
58
60
60
61
61
61
61
63
65
65
66
67
69
77
79
83
84
84
87
87
89
89
90
91
92
94
94
96
98
101
101
101
102
104
106
106
107
107
108
108
108
109
110
INHALTSVERZEICHNIS
3
4.6.1 Min-Plus-Matrix-Produkt und Min-Plus-Transitive Hulle . . 110
4.6.2 Boolesche Matrixmuliplikation und Transitive Hulle . . . . . 111
4.6.3 Der 4-Russen-Algorithmus fur Boolesche Matrixmultiplikation 112
4.6.4 Transitive Hulle und DFS . . . . . . . . . . . . . . . . . . . . 115
4.7 Ein besserer Algorithmus fur das All-pairs-shortest-distance-Problem 117
4.8 Ein Algorithmus fur die transitive Hulle mit lin. erwarteter Laufzeit 118
4.9 Matrizenmultiplikation a la Strassen . . . . . . . . . . . . . . . . . . 121
5 Matchings in Graphen
124
5.1 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
5.2 Matchings maximaler Kardinalitat in bipartiten Graphen . . . . . . 128
Kapitel 0
Einleitung und Au rischung
0.0 Einleitendes Beispiel
Berechnung von Fn , die n ; te Fibonachi-Zahl:
F0 = 0 F1 = 1
Fn = Fn;1 + Fn;2 fur alle n 2
1.Methode: Funktionales Programmieren
f(n) :=
if n = 0 then 0
elseif n = 1 then 1
else f(n ; 1) + f(n ; 2)
fi
T(n) : Zeitbedarf fur die Berechnung von f(n) :
T(n) = T(n ; 1) + T(n ; 2) n 2
T(0) = T(1) = 1 p n
p n
)T(n) = c1 1+2 5 + c2 1;2 5
p
p
n=1:
1 = c1 ( 1+2 5 ) + c2 ( 1;2 5 )
n = 0 :p 1 = c1 + c2
c1 = 21 + p105
c2 = 12 ; 105 p
p
p
p
) T(n) = ( 12 + 105 )( 1+2 5 )n + ( 12 ; 105 )( 1;2 5 )n
2.Methode: Dynamische Programmierung
array: F0 : n] F0] = 0 F1] = 1
for i = 2 to n do
Fi] = Fi ; 1] + Fi ; 2]
Zeitbedarf : O(n)
3.Methode: Direkt (mit etwas mathematischer Arbeit)
p !n p !n !
1
+
1
5 ; 1; 5
F(n) := p
5
2
2
Zeitbedarf: O(log n))
3
KAPITEL 0. EINLEITUNG UND AUFFRISCHUNG
4
0.1 Was sind "kombinatorische\ Algorithmen?
Probleme, die, konnten wir alle Falle aufzahlen, trivial waren, aber eine sehr gro
e
Anzahl von Fallen haben.
Beispiel: Hamiltonscher Kreis (NP-vollstandig), Eulerscher Kreis (P)
0.2 Maschinenmodelle
Turingmaschine (TM)
Random Access Machine (RAM)
Schaltkreise
(Quantencomputer)
(DNA-Computer)
0.3 Komplexitatsmae
. Lesekopf
Eingabeband
+
Steuereinheit
Q
s
Q
Speicher- zugriffseinheit
Speicher
-
M0
M1
Ausgabeband
- Schreibkopf
2Z
..
.
1?
Abb. 1: Random Access Machine
Problem: Sprache L, Alphabet , 8x 2 :
{ Halt die Maschine nach endl. Zeit und gibt eine Antwort?
x 2 L : Antwort \ja\
x 62 L : Antwort \nein\ Maschine entscheidet L
f (x), Maschine berechnet f (partielle Funktion)
{ Entweder
halt die Maschine nach endl. Zeit und sagt \ja\ oder
die Maschine halt nicht oder halt und sagt \nein\. Falls 8x 2 L,
o.B.d.A. das nicht vorkommt, ) Maschine akzeptiert L
Wie werden die Kosten berechnet? Betrachte Eingaben x der Lange n
{ worst-case Komplexitat:
C(n) := maxfKomplexitat(x) jxj = ng
{ durchschnittliche Komplexitat (average complexity):
C(n) := j1n j
X
jxj=n
Komplexitat(x)
allgemeiner: Wahrscheinlichkeitsma
C(n) :=
X
x2n
(x) Komplexitat(x)
{ amortisierte Komplexitat:
durchschnittliche Kosten der Operationen in Folgen
worst-case uber alle Folgen von Operationen
KAPITEL 0. EINLEITUNG UND AUFFRISCHUNG
{ probabilistische oder randomisierte Komplexitat:
5
Algorithmus hat Zufallsbits zur Verfugung. Erwartete Laufzeit (uber alle
Zufallsfolgen) fur feste Eingabe x, dann worst-case fur alle jxj = n.
Ressourcen
{ Rechenzeit
{ Speicherplatz
{ Anzahl von Vergleichen
{ Anzahl von Multiplikationen
{ Schaltkreisgro
e
{ Programmgro
e
{ Schachtelungstiefe von Laufschleifen
Kosteneinheiten:
{ uniformes Kostenmodell
{ logarithmisches Kostenmodell: Kosten Lange der Operanden
Beispiel:
r := 2
for i = 1
n
() r2 )
to
n
do
r = r2
od
Zeit:
{ uniform: n-Schritte
{ logarithmisch: 1 + 2 + 4 + + 2n = nn;1 + 1 = O(2n)
Platz:
{ uniform: 1
{ logarithmisch: 2n
0.3.1 Probleme und Funktionen
Probleme sind Teilmengen von , wobei endliches Alphabet ist.
Berechnung von Funktionen:
Denition: Seien ; Alphabete. Eine TM (bzw. RAM) M berechnet eine (partielle) Funktion f : ! ; gdw. (8x 2 ) falls
M mit Eingabe x halt, dann ist die Ausgabe von M gleich f(x) x 2
Denitionsbereich von f].
0.3.2 Wachstumsverhalten von Funktionen
Denition: f g seien Funktionen von N nach R
g(n) ist O(f(n)) auch: g ist O(f), g(n) = O(f(n)), g(n) 2 O(f(n))]
gdw. (9C 2 R 9n0 2 N)(8n n0 )jg(n)j C jf(n)j]]
3
Beispiel: n3 ist nicht O logn n
g(n) ist (f(n)) gdw. (9C > 0 9n0 2 N)(8n n0 )jg(n)j C jf(n)j]]
KAPITEL 0. EINLEITUNG UND AUFFRISCHUNG
6
g(n) ist !(f(n)) gdw. g ist O(f) und g ist (f)
g(n) ist o(f(n)) gdw. (8C > 0 9n0 )(8n n0 )jg(n)j C jf(n)j]]
g(n) ist !(f(n)) gdw. (8C > 0 9n0 )(8n n0 )jg(n) C jf(n)j]]
g(n) ist 1 (f(n)) gdw. (9C > 0)jg(n)j C jf(n)j fur unendlich viele n]
Beispiel: n2 sin 2 n = 1 (n)
g(n) ist !1 (f(n)) gdw. (8C > 0)jg(n)j C jf(n)j] fur unendlich viele n]
0.3.3 Rekursionsgleichungen
Mergesort:
T(n) = 2T n2 + cn
= cn + 2T n2
= cn + 2 c n2 + 2T n4
= cn + cn + 4T n4
cn log2 n (nur genau fur Zweierpotenzen, sonst 1)
Allgemein: C(n) = F1 (C(n(1) ) C(n(2) ) : : : C(n(r) )) + F2 (n) n(i) < n fur alle i
0.3.3.1 Multiplikatoren
f1 = 1 fn = 2fn;1 + n n 2
fn = 2fn;1 + n
fn;1 = 2fn;2 + n ; 1
..
.
f2 = 2f1 + 2
f1 = 1
j1
j2
..
.
9
>
>
>
>
>
>
>
>
>
>
>
=
nX
;2
>
i=0
fn = 2n;1 f1 +
>
>
>
j 2n;2 >
>
>
>
n
;
1
>
j2 >
>
2i (n ; i) = 2n+1 ; n ; 2
Addieren aller Gleichungen:
fn = 2n;1 +
nX
;2
i=0
2i (n ; i) = 2| n{z;1} + n
(2) (Geometrische Reihe): n
(1)
nX
;2
i=0
2i ;
| {z }
(2)
nP
;2 i
2 = n(2n;1 ; 1)
i=0
nX
;2
i 2i
i=0{z
|
(3)
}
KAPITEL 0. EINLEITUNG UND AUFFRISCHUNG
(3) (Substitution: n ; 2 = k):
k
X
i=0
ixi =
k
X
ixi (erster Summand ist 0)
i=1
k
X
=x
=x
ixi;1
i=1
k dxi
X
i=1
d
= x dx
dx
k
X
i=1
xi
d xk+1 ; 1
= x dx
x;1
k+2 ; xk+1 (k + 1) + x
kx
=
(x ; 1)2
Einsetzen von k = n ; 2 und x = 2:
nX
;2
i=0
i2i = 2n (n ; 2) ; 2n;1(n ; 1) + 2 = 2n n ; 2n+1 ; 2n;1 n + 2n;1 + 2
(2) ; (3):
n
nX
;2
i=0
2i ;
nX
;2
i=0
i2i = n (2n;1 ; 1) ; 2nn + 2n+1 + 2n;1n ; 2n;1 ; 2
= 2n;1 (2n ; 1) ; 2n (n ; 2) ; n ; 2
(1) + (2) ; (3):
2n;1 + n
nX
;2
i=0
2i +
nX
;2
i=0
i2i = 2n;1 + 2n;1 (2n ; 1) ; 2n (n ; 2) ; n ; 2
= 2n+1 ; n ; 2
0.3.3.2 Charakteristisches Polynom
Sei
() fn = fn;1 + fn;2 fur n 2 f1 = 1 f0 = 0
(lineare homogene Rekursionsgleichung zweiter Ordnung)
Setze fn = an fur ein unbekanntes a.
p
an ; an;1 ; an;2 = 0 da hier a 6= 0: a2 ; a ; 1 = 0 a1=2 = 12 5
a1 und a2 Losungen von (), dann auch fn = c1 an1 + c2 an2 eine Losung fur ().
f1 = 1 und f0 = 0hliefern
p5 zwei
p5 n i fur c1 und c2 .
n Gleichungen
1+
1
1
;
Losung: fn = p5
; 2
2
7
KAPITEL 0. EINLEITUNG UND AUFFRISCHUNG
8
Satz: Sei p(x) das charakteristische Polynom der Rekursionsgleichung
() p0 fn + p1 fn;1 + : : : + pk fn;k = 0
mit den konstanten Koe"zienten pi . Seien ri i = 1 : : : m die (i. a. komplexen)
Wurzeln von p(x), jeweils mit Vielfachheit mi . Dann ist die allgemeine Losung
von () gegeben durch
fn =
m
X
i=1
0
rin
@
mX
i ;1
j =0
1
cij nj A mit Konstanten cij .
0.3.3.3 Erzeugendenfunktionen
Fur lineare und nicht lineare Rekursionsgleichungen erhalt man oft eine Losung, indem man die fn als Koe"zienten einer Potenzreihe betrachtet und eine geschlossene
Form, der dadurch denierte Funktion sucht.
Denition: Fur eine Folge (fn)n0 ist die \erzeugende Funktion\ deniert als:
F(z ) =
1
X
n=0
fn z n z 2 C
Exponentielle Erzeugendenfunktion:
X
F(z ) = nfn! z n
n0
auch Notation:
F(z ) =
Sei F(z ) =
X
n>0
P
n>0
fn z n ) fn = z n]F(z )
fn z n und G(z ) =
Erz. Fkt.
F+G
zkF
F(z)
1;z
z dF(z)
Rx
dz
F(t)dt
0
F(cz )
n0
gn z n
n-tes Folgenglied
cfn
fn + gn
cF
FG
P
hn :=
n
P
i=0
fi gn;i (Konvolution)
Anmerkungen:
P
n0
fn z n
!
P
gn z n =
n0
n
P
(mit hn =
!
i=0
fi gn;i )
P
n0
hn z n
if n < k then 0else fn;k n
P
fi
1
1;z
if n = 0 then 0 else fnn;1 cn fn
fn z n ("geht uber auf\) fn zn+1
P
P
F(cz ) = fn (cz )n = fn cn z n
i=0
nfn
=
P
n0
zn
n+1
n0
n0
KAPITEL 0. EINLEITUNG UND AUFFRISCHUNG
Beispiel:
F(z ) :=
G(z ) :=
X
n 0
X
n0
2n z n = 1 ;1 2z
nz n = (1 ;z z )2
) F(z )G(z ) = (1 ; z )2z(1 ; 2z ) =
n
XX
n0 i=0
(n ; i)2i z n
Partialbruchzerlegung:
z
(1)
(2)
z }| {
(1 ; z )2 (1 ; 2z )
z }| {
z + 2
= (1;;2z ) ; (1 ;
; z )2 1 ; 2z
=
X
n 0
2n+1 z n ;
|
{z
(2)
}
X
n0
nz n ; 2
X
n0
z n
| {z }
(1)
Also:
n
X
i=0
2i (n ; i) = z n](FG)(z )
0
= z n] @
X
1
(2n+1 ; n ; 2)z nA
n0
n
+1
= 2 ; n ; 2
0.3.3.4 Transformation des Denitions- bzw. Wertebereichs
Beispiel 1:
fn = fn;1 fn;2 fur n 2
f1 = 2 f0 = 1
Setze: gn = log fn
) gn = gn;1 + gn;2 fur n 2
g1 = log 2 = 1 g0 = 0 fur log = log2
) gn = Fn (n-te Fibonacci-Zahl)
) fn = 2Fn
Beispiel 2:
fn = 3f n2 + n fur n = 2k 9
KAPITEL 0. EINLEITUNG UND AUFFRISCHUNG
f1 = 1
Setze: gk = f2k
Dann: gk = 3gk;1 + 2k k 1
g0 = 1
Es ergibt sich: gk = 3k+1 ; 2k+1 also: fn = 3 3k ; 2 2k
= 3(2log 3 )k ; 2 2k
= 3(2k )log 3 ; 2 2k
= 3nlog 3 ; 2n
10
Kapitel 1
Hohere Datenstrukturen
1.1 Grundlegende Operationen
Es sei U das Universum von Schlusseln mit der Ordnung . Menge S U . Gegeben
seien eine Menge von Datensatzen x1 xn , wobei jeder Datensatz x durch einen
Schlussel Key(x) = K S gekennzeichnet ist. x = (KVal(K )).
IsElement(K S ):
Insert(K S :
Delete(K S ):
FindMin(S ):
FindMax(S ):
DeleteMin(S ):
DecreaseKey(K $ S ):
Union(S1 S2 ):
Find(K ):
Merge(S1 S2 ):
Split(S1 K S2 ):
Concatenate(S1 S2 ):
ist K 2 S , wenn ja, return Val(K )
S := S fK g
S := S n fK g
return min S
return max S
S := S n min S
Ersetze K durch K ; $
S1 = S1 S2
Falls K 2 S , so nde (KVal(K ))
S1 = S1 S2 , falls S1 \ S2 = S2 = fK 0 2 S2 jK 0 K g
S1 = fK 0 2 S1 jK 0 < K g
S1 := S1 S2 Voraussetzung: FindMax(S1 ) FindMax(S2 )
Datenstrukturklasse
mindestens angebotene Funktionen
Worterbuch (Dictiona- IsElement(), Insert(),
ry)
Delete()
Vorrangwarteschlange FindMin(), Insert(), De(Priority Queue)
lete(), IsElement()]
Mergeable heaps
FindMin(), Insert(), Delete(), Merge()
Concatenable queues FindMin(), Insert(), Delete(), Concatenate()
11
realisiert in
Hashtable, balancierte
Baume
balancierte, Leftist-,
Binomialbaume
2-3-Baume, Binomialwalder, Leftist-Baume
2-3-Baume
KAPITEL 1. HOHERE
DATENSTRUKTUREN
12
1.2 Suchbaume, balancierte Baume
1.2.1 Hohenbalancierte Baume
Denition: Bei einem externen Suchbaum werden die Datenelemen-
te nur an den Blattern gespeichert, und die inneren Knoten enthalten
Verwaltungsinformationen. Bei internen Suchbaumen liegen die Datenelemente an den internen Knoten. Zeiger auf Blatter sind NIL-Pointer.
Daher kann man sagen: An allen Knoten sind Daten gespeichert.
1.2.1.1 (a,b)-Baume
Denition: Ein (a,b)-Baum ist ein externer Suchbaum, alle Blatter haben die gleiche Tiefe, die Anzahl der Kinder eines jeden internen Knoten
ist b und a (Fur die Wurzel 2), und es gilt b 2a ; 1. Spezialfall:
b = 2a ; 1 (B-Baume).
Mit jedem internen Knoten V mit d =Grad(V ) werden (d + 1) Schlusselwerte
K0 : : : Kd gespeichert.
K0 = ;1, Kd = +1 , Ki;1 < (alle Schlussel im i Unterbaum von V ) Kd
etwa (*): ki = max(Schlussel im i-ten UB von V )
Sortierung im (a,b)-Baum:
(Schlussel im i-ten UB) (Schlussel im (i + 1)-ten UB)
Beispiel:
Wir betrachten im folgenden (2,4)-Baume.
2
! l
!
l
!
!!
l
3 4 5
1 A
A
B
A
1
2
3
4
B
5
A
6
Lemma: Sei T ein (a,b)-Baum mit n Blattern und der Hohe h. Dann gilt:
(1) 2ah;1 n bh
n
n
(2) logb n = log
log b h 1 + loga 2
Beweis:
(1) n bh : Maximal fur vollstandigen Baum-Verzweigungsgrad b. Minimal fur
Baum mit Grad der Wurzel = 2, alle anderen internen Knoten = a.
(2) aus (1).
3
KAPITEL 1. HOHERE
DATENSTRUKTUREN
13
Operationen:
1. IsElement(K S )
v
T
:= Wurzel von while = Blatt do
v6
i = minfsj1 s Grad v
v := i-tes Kind von v
K KS g
and
od
if
=Key( ) then return Val( )
else return False
fi
K
v
k
Zeitbedarf: (h) = (log n)
2. Insert(K S )
Fuhre IsElement(K T ) aus. Blatt w
Sei Key(w) 6= K , w enthalt unter (*) den kleinsten Schlussel > K Fuge K links von w ein
v =Vater von w
Falls Grad v = b + 1: Rebalancierung (v)
3
!
! l
l
!
!!
l 4 5 7
1 2
A
A
B
A
1
3
4
2
B
+
7
A
8
6
3 6
a
a
a
aa
1 2
4 5
7
A
A
A
1
5
2
A
3
4
5
A
6
A
7
8
Rebalancierung(v):
a) Falls ein unmittelbarer Bruder v0 von v Grad < b hat, v0 adoptiert au
erstes links/rechts Kind von v.
b) Sonst: Spalte Menge C aller Kinder von v in C1 C2 (gleichgro
). Spalte
Knoten v in v1 v2 ,v1 ubernimmt C1 , v2 ubernimmt C2 b+1
a b b+1
2 c d 2 e b wegen b 2a ; 1
Kosten O(log N )
KAPITEL 1. HOHERE
DATENSTRUKTUREN
14
3. Delete(x S ):
Fuhre IsElement(K T ) aus. Blatt w. Sei Key(w) = K Losche w v := Vater w
Falls Grad v = a ; 1: Rebalancierung0(v)
2 4
Q
Q
Q
Q 1 2 5 6
A
A
A
A
1
5
A
6
7
. oder & 2 5
4
H
Q
H
HH
QQ 1 2 A 5 6 A 1A 4A 6A 1
A
@3; 4
;@
2
2
A
4
5
6
A
7
A
1
2
A
4
5
A
6
7
Rebalancierung0(v):
a) Falls ein unmittelbarer Bruder v0 von v Grad > a hat: v adoptiert Kind
von v0
b) Sonst verschmelze v mit einem unmittelbaren Bruder
Zeitbedarf: O(log n)
Spezialfalle von (a b)-Baume:
- (2 3)-Baume,
- (2 4)-Baume,
- (a 2a ; 1)-Baume (B-Baume)
Bemerkungen:
1. Zur Wahl von a:
Daten in RAM ) a klein, z.B. a = 2 oder a = 3.
Daten auf Platte ) a gro
, z.B. a = 100.
2. Zur Wahl von b:
b 2a liefert wesentlich bessere amortisierte Komplexitat (ohne Beweis, siehe
Mehlhorn).
3. Top-Down-Rebalancierung: b 2a.
Bei der Restrukturierung nach der Top-Down-Strategie, folgen wir wie gewohnt dem Pfad von der Wurzel zum gesuchten Blatt. Beim Einfugen stellen
wir jetzt jedoch fur jeden besuchten Knoten sicher, da
der Knoten weniger
als b Kinder hat. Wenn der gerade betrachtete Knoten ein b-Knoten ist, dann
KAPITEL 1. HOHERE
DATENSTRUKTUREN
15
spalten wir ihn sofort auf. Weil der Vater kein b-Knoten ist (das haben wir ja
bereits sichergestellt) p'anzt sich der Aufspaltungsproze
nicht nach oben hin
fort. Insbesondere kann das neue Element ohne Probleme eingefugt werden,
wenn die Suche das Blattniveau erreicht hat. Damit diese Strategie moglich
ist, mu
b mindestens 2a sein (und nicht 2a ; 1), da sonst nach der Spaltung
nicht genugend Elemente fur die beiden Teile vorhanden sind.
Beim Loschen verfahren wir analog. Fur jeden besuchten Knoten, au
er der
Wurzel des (a b)-Baumes, stellen wir sicher, da
er mindestens a + 1 Kinder
hat. Wenn der gerade betrachtete Knoten nur a Kinder hat, so versuchen wir
zuerst ein Element des rechten oder linken Nachbarknoten zu stehlen. Sind
beide Nachbarknoten vom Grad a, so verschmelzen wir unseren Knoten mit
einem der beiden Nachbarn. Ist der Vater nicht die Wurzel, so hatte er aber
vorher mindestens a + 1 Kinder, und dieser Verschmelzungsproze
kann sich
nicht nach oben fortsetzen. Andernfalls erniedrigt sich der Grad der Wurzel
um 1, wenn die Wurzel Grad gro
er 2 hat, oder die alte Wurzel wird geloscht
und der soeben verschmolzene Knoten wird zur neuen Wurzel.
Restrukturierung nach der Top-Down-Strategie sorgt nicht fur eine bessere Laufzeit, sondern erleichtert die Synchronisation, wenn mehrere Prozesse
gleichzeitig auf einen (a b)-Baum zugreifen wollen. Bei herkommlichen (a b)Baumen schreiten die Such- und die Restrukturierungsoperationen in entgegengesetzten Richtungen fort, was dazu fuhrt, da
sich oft Prozesse gegenseitig
behindern (der eine will im Baum absteigen, der andere mu
auf dem gleichen Pfad aufwarts restrukturieren). Bei der Top-Down-Strategie gibt es nur
Operationsfolgen, die den Baum hinabsteigen. Mehrere Prozesse konnen so in
einer Art Pipeline gleichzeitig einen Pfad mit kurzem Abstand begehen.
1.2.1.2 Rot-Schwarz-Baume
Denition: Rot-Schwarz-Baume sind externe Binarbaume (jeder Knoten hat 0 oder 2 Kinder) mit roten und schwarzen Kanten, so da
gilt:
1. alle Blatter hangen an schwarzen Kanten (durchgezogene Linien)
2. alle Blatter haben die gleiche "Schwarztiefe\
3. kein Pfad von der Wurzel zu einem Blatt enthalt aufeinanderfolgende rote Kanten (gewellte Linien).
Dabei ist die "Schwarztiefe\ eines Knoten die Anzahl der schwarzen Kanten auf
dem Pfad von der Wurzel zu diesem Knoten. Rot-Schwarz-Baume konnen zur Implementierung von (2,4)-Baumen dienen.
Vorteil: Interne Knoten haben Verzweigungsgrad = 2.
pp
p b d Q
Q
Q
a
c
pp pp pp pp pp e pp
p p p p p p
)
pp
p
b ;
;
;
a
d pp p p AA
p p c pp p p p p e p p pp pp pp pp
KAPITEL 1. HOHERE
DATENSTRUKTUREN
pp
p
)
b
d
f
Q
Q
Q
a
c
e
pp pp pp pp pp pp pp g pp
p p p p p p p
p
16
pp
p
d b f A
AA
A
g
e
a
c
pp p p p p p p p p p p p p p p p p p p p pp p p pp p
Operationen auf Rot-Schwarz implementierten (a b)-Baume:
1. IsElement(K T ) : vgl. (a b)-Baume
Zeit O(log n)
2. Insert(K T ): Fuhre IsElement(K T ) aus Blatt w. Dort sei noch nicht das
Element v gespeichert. Ersetze w durch interne Knoten w0 mit Kindern v w,
wobei v ein neues Blatt mit Schlussel K sei. w0 behalt rote Eingangskante.
Falls nun zwei aufeinanderfolgende rote Kanten an w0 vorliegen, Rotation zur
Rebalancierung:
S
S
pSp p a pp p S SS
pp
S
p
pp p SS S
b S pb JJ
Einfache
pp p Sp S SSS Rotation
p
S
p p p SS S
c
J
p
p a p
p c p
S pp
J
p
p
p
p
p
pJpS p pJ pJp p pJ Jp p p pJ
)
U1
U2
3
4
UJ
UJ
a @@
p @
pp p p p
@
pp p
c
p
JJ
ppp
p
;; p p p p
p p ;; JJ
pp p b p
p Jp
J
U1
U4
2
3
UJ
UJ
1
2
UJ
UJ
3
4
UJ
UJ
pp
p
b Doppelte
Rotation
a
pp p p
pp
pp p c p
p
pJ pJ pJ p pJ
)
1
2
UJ
UJ
3
4
UJ
UJ
KAPITEL 1. HOHERE
DATENSTRUKTUREN
pp
p
b pp p a p
pp
pp p c p
p
pJ Jp pJ p pJ
)
1
2
UJ
UJ
3
4
UJ
UJ
17
b ; @
;
@
;
@
a
pp p p
pp
pp p c p
p
pJ pJ pJ p pJ
1
2
UJ
UJ
3
4
UJ
UJ
3. Delete(KT): Das Loschen des Blattes v macht es erforderlich, da
der Vater
des Blattes durch den Bruder des Blattes ersetzt wird, damit der Binarbaumstruktur erhalten bleibt. Der Bruder von v ist naturlich eindeutig bestimmt.
Dabei treten zwei Falle auf:
1.Fall
b
b
m
m
a
v
J
J
w
)
w
m
:
Dadurch andert sich die Schwarztiefe von w nicht, denn die Eingangskante zu
w wird (notwendig) zu schwarz umgefarbt. Auch kann es hierdurch nicht zu
zwei aufeinanderfolgenden roten Kanten kommen.
2.Fall
b
b
;
;
m
;
a
v
J
J
w
m
)
w
m
Hierdurch verkleinert sich die Schwarztiefe von w um 1. Man kann sie nicht
wieder erhohen, ohne dabei auch die Schwarztiefe anderer Blatter zu vergro
ern. Daher mu
sie fur alle anderen Blatter des Baumes um 1 verkleinert
werden. Man betrachte dazu den Pfad von w zur Wurzel als unveranderlich
und farbt Kanten so um, da
auf allen anderen Pfaden jeweils genau eine Kante von schwarz zu rot wird. Ferner darf dabei nicht die Situation entstehen,
da
zwei aufeinanderfolgende Kanten rot werden. Ist dies nicht vermeidbar,
so mu
gema
obigem Schema rebalanciert werden.
Satz: Die Tiefe eines Rot-Schwarz-Baumes mit n Blattern ist O(log n)
Beweis: Siehe U bungsblatt.
3
Korollar: Die Worterbuch-Operationen benotigen auf Rot-Schwarz-Baumen
O(log n) Zeit.
KAPITEL 1. HOHERE
DATENSTRUKTUREN
18
1.3 Binare Suchbaume
1.3.1 Naturliche binare Suchbaume
Denition: Ein naturlicher binarer Suchbaum uber einem durch geordneten Universum U ist ein interner Binarbaum (Schlussel an den
internen Knoten).
Sortierungsbedingung:
(Alle Schlussel im l. UB von v) Key(v) (Alle Schlussel im r. UB von v)
;
;
5m
m
2
@
@
J
J
mHH
8
HH
;
m
m
11
m
;
6
10
@
@
m
13
m 3m
1
Lemma: Die In-Order-Linialisierung eines binaren Suchbaumes mit obigen Suchwegbedingungen ergibt eine aufsteigende Folge von Schlusselwertern.
Operationen:
IsElement(K T ):
v
ist Wurzel
while ( = Blatt) do
if Key( ) =
then return (Val( ))
elseif Key( )
then :=rechtes Kind von
else :=linkes Kind von fi
od
v6
v
v
K
v K
v
v
K
v
Insert(K T ):
Fuhre IsElement(K T ) aus
Sei K nicht enthalten, dann fuhrt IsElement zu Blatt w (NIL-Pointer)
Fuge man Knoten v mit Key(v) = K an Blatt w ein
Delete(K T ):
Fuhre IsElement(K T ) aus.
Sei K enthalten, dann fuhrt IsElement zu Knoten w (i.a. interne Knoten).
Ersetze w durch seinen in-order-Vorganger oder -Nachfolger.
Problem: Lineare Entartung von naturli- @
@
R
chen binaren Suchbaumen bei Einfugen in
eine monotone Reihenfolge ) Insert, Delete, IsElement in worst-case O(n). Falls aber
; @
;
@
die Sclussel in zufalliger Reihenfolge eingefugt werden ) j E(h) - O(log n)j. Falls
; @
;
@
alle topologische (von der Form her gleichaussehende) Baume
; @
;
@
p gleichwahrscheinlich
sind ) j E(h) - ( n)j.
m
m
m
KAPITEL 1. HOHERE
DATENSTRUKTUREN
19
1.3.2 Hohenbalancierte binare Suchbaume (AVL-Baume)
Denition: Ein AVL-Baum 1 ist ein spezieller binarer Suchbaum, der
neben den Sortierungsbedingungen auch die folgende Hohenbalancierungen erfullt. Fur den Knoten v gilt:
j Hohe(lUBv ) - Hohe(rUBv ) j 1
Lemma: Ein AVL-Baum der Hohe h hat mindestens nh = Fib(h + 2) Blatter.
Beweis: Induktion nach h:
I) h = 1 ) nh = 2 = Fib(3)
h = 2 ) nh = 3 = Fib(4)
k
k
S
S
S
S
k
S
S
II) h 3 ) nh nh;1 + nh;2
Bei einem bzgl. der Blatterzahl minimalen AVL-Baum der Hohe h darf nur
einer der Unterbaume der Hohe h ; 1 haben. Der andere mu
kurzer sein, aber
wegen der Balancierungsbedingung mindestens Hohe h ; 2 haben. Beide sind
naturlich minimale AVL-Baume. Also gilt nh = nh;1 + nh;2 . Dies ist genau
die Bestimmungsgleichung fur Fib(h + 1).
k
; @
;
A
A
A
A
h;2
h;1
3
Folgerung:
AVL-Baume der Hohe h haben mindestens Fib(h + 2) Blatter, also Fib(h +
2) ; 1 interne Knoten.
p n
Da anderseits gilt: Fib(n) p15 1+2 5 , hat ein AVL-Baum mit n-Blattern
(oder interne Knoten) die Hohe O(log n). Dies ist ein bedeutender Fortschritt
gegenuber der bisweilen bei naturlichen Suchbaumen entstehenden Zeitkomplexitat von (n) fur die Suchoperation IsElement.
Operationen auf AVL-Baumen:
1. IsElement : Diese Operation wird wie bei den naturlichen Suchbaumen implementiert. Wie oben ausgefuhrt, haben aber AVL-Baume mit n Datenelementen eine Hohe von O(log n), woraus logarithmische Zeit fur das Suchen folgt.
2. Insert : Zunachst wird eine IsElement -Operation ausgefuhrt, die fur den Fall,
da
das einzufugende Element nicht bereits enthalten ist, zu einem Blatt fuhrt.
Dies ist die Stelle, an der das neue Element einzufugen ist. Dabei ergeben sich
1
Benannt nach Adelson, Velskii und Landis
KAPITEL 1. HOHERE
DATENSTRUKTUREN
20
2 Falle:
1. Fall:
x!
m Balance +1
; @
;
@ m
A
A
)
m
Balance 0
; @
@
;
xm
m
A
A
A
A
(Balance ;1 ! 0: symmetrisch)
2. Fall:
x!
)
m Balance 0
; @
;
@
xm
m Balance ;1
; @
@
;
A
A
Hier ist eventuell eine Rebalancierung auf dem Pfad zur Wurzel notwendig,
denn die Hohe eines Unterbaums andert sich derart, da
die Balance nicht zu
0 wird, sondern zu +1 oder ;1. Zur Rebalancierung (T1 T2 T3 T4 ):
Fall 2-a)
m
m
q
s
PPP
p ;Balance
1 ! ;2 B
B
; @
;
@
T3 B
h;1
B
B
B
B
T1 B
T2 B
s
h;1!h
s
)
h;1
m
p Balance 0
m
PP
P
q
D
; @
D
;
@
D
B
B
D
B
B
T1 D
T2 B
T3 B
s
s
h;1
h
s
h;1
Fall 2-b)
m
r Balance ;1 ! ;2
m
@
p @
; @
@
;
@
@
q
B
B
B
A
B
T1 B
A
T4 B
h;1
h;1
B
B
B
B
T2 B T3 B
s
s
m
s
s
)
m
m
q Balance 0
m
PPP
p
r
A
A
A
A
B
B
B
B
B
B
B
T3 B
B
h ; 2 T4 B
T1 B T2 B
s
s
h;1 h;1
s
s
h;1
h;2! h;1 h;2
3. Delete : Auch diese Operation wird wie bei naturlichen Suchbaumen implementiert. Doch am Ende hat ggf. noch eine Rebalancierung auf dem Pfad
KAPITEL 1. HOHERE
DATENSTRUKTUREN
21
vom geloschten Blatt (das an die Stelle des zu loschenden Elements geschrieben wird) zur Wurzel zu erfolgen.
Satz: Bei AVL-Baumen sind die Operationen IsElement, Insert, und Delete so
implementiert, da
sie die Zeitkomplexitat O(log n) haben, wobei n die Anzahl
der Datenelemente (oder die Anzahl der Blatter) ist.
Siehe auch:
Aho, Hopcroft, Ullmann
Sedgewick/Flajolet
Info IV Skript SS94, Prof. Mayr
In der Theorie: Sehr schone Eigenschaften.
In der Praxis: Sehr aufwendig zu implementieren.
1.4 Hashing
1.4.1 Grundlagen
Zutaten:
Universum U von Schlusseln
Schlusselmenge K M
array T 0::m ; 1] Hashtabelle
Hashfunktion h : U ! 0::m ; 1]
Hash-Tabelle
0 - -
pp
p
m;1
-
pp
p
Problemstellung: Gegeben sei eine Menge M von Elementen, von denen jedes
durch einen Schlussel k aus der Menge K bezeichnet sei. Die Problemstellung ist
nicht neu: Wie mu
die Speicherung der Elemente aus M organisiert werden, damit
jedes anhand eines Schlussels moglich schnell lokalisiert werden kann? Gesucht ist
also eine Abbildung h : K ! T von der Menge aller Schlussel in Adressraum T der
Maschine. Hierbei soll jedoch eine bisher nicht beachtete Schwierigkeit berucksichtigt werden: Die Menge K der moglischen Schlusselwerte ist wesentlisch gro
er als
der Adre
raum. Folglich kann die Abbildung h nicht injektiv sein, es gibt Schlussel
k1 k2 :: mit h(k1 ) = h(k2 ) = : : : . Wir werden sehen, da
aufgrund dieses Umstandes die Speicherstelle eines Elements mit Schlussel k von einem anderen Element
mit einem anderen Schlussel l besetzt sein kann (Kollision).
Zwei Methoden zur Kollisionsauosung:
Chaining (Verkettung)
Oene Adressierung
1.4.2 Chainingverfahren
Die Hashtabelle ist eine array von m linearen Listen, wobei die i-te Liste alle k
Schlussel beinhaltet, fur die gilt:
h(k) = i
KAPITEL 1. HOHERE
DATENSTRUKTUREN
22
Zugri: Berechne h(k) und durchsuche die Liste T h(k)].
h(k1 k2 ) =
h(k1 S ) :=
1 falls h(k1 ) = h(k2 ) ^ k1 6= k2
0 sonst
X
k2 2S
h (k1 k2 ) Anzahl Kollisionen von k1 mit S
Zugriskosten : O(1 + h(k S ))
worst-case: hjs = const ) Entartung des Hashings zu linearer Suche O(jS j)
average-case :
- Moge h das Universum U uber 0::m ; 1] gleichverteilen
- Seien alle Werte in U gleichwahrscheinlich als Argument von Access(), Insert(),
Delete()
- Sei = mn der maximale Fullgrad von T , n = Anzahl Operationen
Dann: Die erwartete Laufzeit fur n-Operationen = O (1 + 2 )n
Beweis: Durch die Gleichverteilung fur den Wert h(ki ) bei der i-ten Operation
P (h(k) = j ) = m1 (0 j m ; 1)
) E (Listenlange) mr nach der r-ten Operation
) E (Kosten von (n + 1)-ten Operationen) = O(1 + mi )
) E (Kosten von n Operationen) = O((1 + 21 mn )n)
3
1.4.3 Hashing mit o
ener Adressierung
Beispiele:
Lineares Sondieren (linear Probing)
Quadratisches Sondieren
Double Hashing
Robin-Hood-Hashing
:::
Bei dieser Methode werden die Elemente nicht in der Liste, sondern direkt in der
Hash-Tabelle gespeichert. Wird bei Insert oder IsElement, angewendet auf Schlussel
k, ein Element mit Schlussel 6= k an der Adresse h(k) gefunden, so wird auf deterministische Weise eine alternative Adresse berechnet. Fur jeden Schlussel k 2 U
wird somit eine Reihenfolge (Sondierungsfolge), in der alle slots in T ] betrachtet
werden, um k zu speichern bzw. zu nden, festgelegt. Dieser Vorgang hei
t sondieren.
KAPITEL 1. HOHERE
DATENSTRUKTUREN
23
Sondieren:
Sei s(j k) : 0::m ; 1] U ! 0::m ; 1]
(0 j m ; 1)
Deniere h(j k) = (h(k) ; s(j k)) mod m
Starte mit h(k), dann (falls (h(k)) belegt) Index (h(k) ; s(1 k)) mod m
Problem: Sei h(k) = h(k0) fur 2 Schlussel k k0 2 S U . Werde zunachst k
eingefugt, dann k0 , dann k geloscht. Wie ndet man k0 (Beachte: k0 steht nicht unmittelbar an h(k0 ))?
Losungsvorschlag: Markiere k als geloscht! Wenn Speicher gebraucht wird, k uberschreiben. Alternativ: Hashtabelle neu aufbauen/uberarbeiten.
Beispiele fur Sondierungen:
Lineares Sondieren: Setze s(j k) = j d.h. sondiere gema
h(k) h(k);1 : : : 0 m;
1 :: h(k) + 1
Es wird fur IsElement solange ruckwarts gesucht, bis entweder das Element
mit Schlussel k oder eine freie Position gefunden ist. Im letzteren Fall ist das
gesuchte Element nicht in der Hash-Tabelle enthalten.
Problem: Es entstehen primare Haufungen (primary Clustering) um diejenigen Schlussel herum, die beim Einfugen eine Kollision hervorgerufen haben.
Satz: Die durchschnittliche Anzahl der Sondierungen ist :
E(#
8
<
1
Sondierungsschritte) = : 21
2
1 + (1;1 ) erfolgreich
1 + (1;1)2 erfolglos
erfolgreich erfolglos
0.5
0.9
0.95
1.5
5.5
10.5
2.5
50.5
200.5
Quadratisches Sondieren
Setze s(j k) = (;1)j d 2j e2 , d.h. sondiere nach h(k) h(k) + 1 h(k) ; 1 h(k) +
4 h(k) ; 4 : : :
Frage: Ist das uberhaupt eine Permutation von 0::m ; 1]? Ist s(j k) geeignet
alle slots zu erreichen?
Man kann zeigen, da
fur ein primes m von der Form 4i + 3 die Sondierungsgro
e (h(k) ; s(j k)) mod m Permutation von 0::m ; 1] ist.
Satz: Die durchschnittliche Anzahl der Sondierungen ist :
8
<
E(# Sondierungsschritte) = :
1 + ln 1;1 ; 2 erfolgreich
1
1
erfolglos
1; ; + ln 1;
erfolgreich erfolglos
0.5
0.9
0.95
1.44
2.85
3.52
2.19
11.4
22.05
KAPITEL 1. HOHERE
DATENSTRUKTUREN
24
Double Hashing
Setze s(j k) = jh0 (k), wobei h0 eine zweite Hashfunktion ist. h0 (k) mu
relativ
prim zu m gewahlt werden, damit (h(k) ; s(j k)) mod m eine Permutation
der Hashadressen wird.
Satz: Die durchschnittliche Anzahl der Sondierungen ist :
E(# Sondierungsschritte) =
1
1
1m 1; erfolgreich
erfolglos
1;
erfolgreich erfolglos
0.5
0.9
0.95
1.39
2.55
3.15
2
10
20
Zum Beispiel: h0 (k) = 1 + k mod n ; 2 (mit n prim).
1.4.4 Universelles Hashing
Wir denieren eine Klasse H von geeigneten Hashfunktionen und wahlen eine spezielle Hashfunktin zufallig aus H aus. Dabei soll fur jedes S U \fast jedes\ h 2 H
die Schlusselmenge S \fast\ gleichverteilen uber 0::m ; 1]. Formal:
Denition: H hei
t c-universell (c 2 R) g.d.w. 8k1 k2 2 U gilt:
jf h 2 H j h (k1 k2 ) = 1gj c
jH j
m
Satz: Sei H eine c-universelle Klasse von Hash-Funktionen, und sei h 2 H zufallig
und gleichverteilt gewahlt. Wird Chaining verwendet, dann ist die erwartete Zeit
fur Access(), Insert() und Delete() gleich O(1 + c )
Beispiel einer 4-universellen Hashtabelle:
Seien N 2 N prim, m 2 N, und 8a b 2 0::N ; 1] :
hab(k) = ((ak + b) mod N ) mod m 8k 2 U 0::N ; 1]
Dann ist H = fhab j 0 a b N ; 1g 4-universell.
1.4.5 Perfektes Hashing
Fur das statische dictionary problem (nur Access()) konnen wir denieren:
Eine Hash-Funktion h ist \perfekt\ fur S U gdw. fur alle Paare von verschiedenen Schlussel, also 8k1 k2 2 S gilt: h (k1 k2 ) = 0, also h(k1 ) 6= h(k2 ).
Eine minimale perfekte Hash-Funktion braucht nur den Platz m = jS j = n.
Fur m 3n kann man in Zeit O(nN ) eine perfekte Hash-Funktion fur S U
nden, die in O(1) Zeit auszuwerten ist (durch ein Programm der Gro
e
O(n log N )) Bits.
Bisher bestes Resultat:
Programmgro
e O(n log log n + log log
N)
2
n
(untere Schranke: m + log log N )
KAPITEL 1. HOHERE
DATENSTRUKTUREN
25
1.5 Priority Queues
Operationen:
Insert(), Delete(), DeleteMin(), FindMin(), DecreaseKey(), Merge()
Implementierungen:
Binomial Queues
Fibonacci Heaps
1.5.1 Binomial Queues (binomial heaps)
Um binomial Queues betrachten zu konnen, denieren wir zunachst ihre nichttrivialen Bestandteile: Binomialbaume
Denition: Die Binomialbaume sind rekursive wie folgt deniert:
B0
B
B
sm m
s1 A2sm
s s As
s
Bn
sm
;@
;Bn;1@
;@
;Bn;1@
s
Achtung: Binomialbaume sind keine Binarbaume! Wie in folgender Darstellung dieser Baume deutlich wird, hat Bn an der Wurzel Grad n.
Binomialbaume haben folgende Zerlegungseigenschaften:
Lemma: Ein Bn la
t sich wie folgt zerlegen:
s
#c
#
c
(1)
#
c
#
c
#
c
;@
;@
;@
; Bn;1@ ; Bn;2@ ; Bn;3@
s
s
s q q q q ;s@
; B1 @
(2)
s
;@
; B0 @
s
@
;
Bn;1@
;
Ruckgrat XXX
@
z;
X
; Bn;2@
;@
Bn;3@
@ ;
;
B1 @
;
sB0 sB0
pp
psp p p p p p p
s
s
KAPITEL 1. HOHERE
DATENSTRUKTUREN
26
Satz: Es gilt:
1.
2.
3.
4.
Bn hat 2n Knoten.
Die Wurzel von Bn hat Grad n
Bn hat Hohe n
; Bn hat ni Knoten in Tiefe i
Beweis:
zu 1: Induktion unter Verwendung der Denition von Binomialbaumen
zu 2: Siehe Zerlegung (1) fur Binomialbaume
zu 3: Siehe Zerlegung (2) fur Binomialbaume
zu 4: Induktion uber n:
I) ;n = 0 : B0 hat 1 Knoten in Tiefe i = 0 und 0 Knoten in Tiefe i > 0, also
0 Knoten in Tiefe i
i
II) Ist Nin die Anzahl der Knoten in Tiefe i in Bn , so gilt unter der entsprechenden Induktionsannahme
ur Bn , da
; ;f
Nin+1 = Nin + Nin;1 = ni + i;n1
3
Bemerkung: Eine mogliche Implementierung von Binomialbaumen ist das Schema
\Pointer zu Kind 1. und zum nachsten Geschwister\.
Denition: Eine Binomial Queue mit N Elementen wird wie folgt aufgebaut:
1. Betrachte die Binardarstellung bin(N ) von N
2. Fur jedes gesetzte Bit (\1\) an Position i wird ein Binomialbaum
vom Type Bi benotigt. Dieser hat bekanntlich 2i Knoten
3. Verbinde die Binomialbaume in einer doppelt verketteten zirkularen
Liste.
4. Beachte, da
innerhalb jedes Binomialbaums die Minimumsvariante der Heap-Bedingung, namlich VATERSOHN erfullt sein mu
.
Dadurch ist die Wurzel eines einzelnen Binomialbaums gleichzeitig
sein minimales Element.
5. Richte einen Min-Pointer auf das Element in der Wurzel-Liste mit
minimalem Schlussel. Es ist dann das kleinste Element von allen in
der Binomial Queue
Beachte, da
Priority-Queues wegen O(n) fur Suchen keine Suchstrukturen
sind.
KAPITEL 1. HOHERE
DATENSTRUKTUREN
27
Beispiel: N = 11 = (1011)2:
B3
m
7
2m
Y
Q
Q
Q m
m
m
3
8
10
A
A
A
A
4m
11m
9m
-
B1
j
B0
m I
@
@
m
6
min
m
7
1
Operationen:
1. IsElement : Die Heap-Bedingung wirkt sich nur auf die Anordnung der Datenelemente innerhalb jedes einzelnen Binomialbaums aus, regelt aber nicht, in
welchem Binomialbaum ein gegebenes Element gespeichert sein mu
. Tatsachlich
kann ein Element in jedem der vorhandenen Binomialbaume stehen. Das Suchen ist hier nicht e"zient implementierbar, denn im worst-case mu
jedes
Element eines Binomialbaums angeschaut werden. Bi enthalt 2i Knoten und
eine Binomial Queue mit N Elementen besitzt maximal die Binomialbaume
B0 B1 ::Blog N ;1 . Also waren zum Suchen eines Elements schlimmstenfalls
20 + 21 + + 2log N ;1 = N ; 1 = O(N ) Elemente zu betrachten. Daher
wird eine gesonderte Datenstruktur, etwa ein Suchbaum, fur die IsElement Operation verwendet. Dort ist Suchen mit Zeitaufwand O(log n) moglich.
2. Merge : Das Vorgehen fur das Merge zweier Vorrangwarteschlangen entspricht
genau der Addition zweier Binarzahlen: Ein einzelnes Bi wird ubernommen,
aus zwei Bi s wird ein Bi+1 konstruiert. Damit die Heap-Bedingung erhalten
bleibt, wird als Wurzel des entstehenden Binomialbaums Bi+1 die kleinere der
Wurzeln der beiden Bi genommen (*). Allerdings kann ein solcher U bertrag
dazu fuhren, da
im nachsten Verschmelzungsschritt drei Bi+1 zu verschmelzen sind. Dann wird unter Beobachtung obiger Regel ein Bi+2 gebildet, und
der verbleibende Bi+1 unverandert gelassen.
Algorithmus:
for
i := 0 1 2 3 ::
do
genau 3 i s) then
erzeuge/verbinde i+1 nach (*) und behalte ein
elseif ( genau 2 i s) then
erzeuge i+1 nach (*) elsif ( ein i ) then
behalte es
fi
if
(9
9
9
B
B
B
B
B
Bi od
Komplexitat: Binomial Queue Nr. 1 mit N1 Elementen hat log N1 Binomialbaume, und analog hat Binomial Queue Nr. 2 mit N2 Elementen log N2
Binomialbaume. Sei N := N1 + N2 . Ein einzelner Merge -Vorgang, das Zusammenhangen zweier Binomialbaume erfolgt in konstanter Zeit. Naturlich mu
er so oft ausgefuhrt werden, wie Binomialbaume in der resultierenden Binomial Queue vorliegen. Diese Anzahl wiederum ist hochstens log N .
KAPITEL 1. HOHERE
DATENSTRUKTUREN
28
Zeitkomplexitat O(log N ) = O(log (N1 + N2 ))
3. Insert : Die Insert -Operation wird einfach durch Merge -Operation implementiert. Die Vorrangswarteschlange, die neu hinzukommt, ist trivial. Sie enthalt
nur einen Binomialbaum B0 .
1 0 0 1 0 1 0 1
(B7 )
(B4 )
(B2 )
(B0 )
1
1 0 0 1 0 1 1 1
Kosten O(log n)
4. Initialisierung einer Binomial-Queue durch N sukzessive Insert -Operationen:
Kosten mit O(n log n) schlecht abgeschatzt. Dabei moge sowohl das Einfugen
dieses neuen einelementigen Baum als auch jede rekursive Verschmelzungsschritt eine Zeiteinheit kosten, denn jede dieser Operationen ist von der Komplexitat O(1). Wir sind an den gesamten Kosten zum Aufbau einer Binomial
Queue mit N Elementen interessiert. Dies sind ubrigens identisch zum Aufwand fur das binare Hochzahlen von 0 bis N , wenn jeder Zahlschritt und jeder
U bertrag eine Zeiteinheit kosten:
0| {z
+ 1} +1 +1 +1 +1
1 {z }
2 Schritte
{z
}
|
1
|
{z
}
3 {z
|
}
1
|
Sei an die Anzahl der Schritte (Einfugen des neuen Elements und anschlie
ende Verschmelzungen) beim Mergen eines Knotens zu einer Queue mit (n ; 1)
Elementen. Dann gilt fur an :
n an
1
..4
..8
..16
..32
2
1
1
1
1
3
2 1 4
2 1 3 1 2 1 5
2 1 3 1 2 1 4 1 2 1 3 1 2 1 6
Man erkennt sofort, da
die h-te Zeile von der Lange 2k ist, und alle Elemente
der Zeilen 1 2 :: (k ; 1) enthalt, wobei das letzte Element um eins erhoht ist.
Daraus ergeben sich folgende Rekursionsgleichungen fur an :
a1 = 1
an = a n2 + 1 fur n 2 2N0
an = an;2blog nc sonst
KAPITEL 1. HOHERE
DATENSTRUKTUREN
29
Diese Bestimmungsgleichung ist unmittelbar einsichtig, denn fur n 2 2N0
unterscheidet sich die Situation von n = 2i Knoten nur insofern von der
Situation mit n2 = 2i;1 Knoten, da
im ersten Fall noch ein Binomialbaum
Bi;1 vorliegt. Das Hinzunehmen eines weiteren Knotens lost in beiden Fallen
die selbe Folge von Verschmelzungsschritten aus, mit der Einschrankung, da
im letzteren Fall der neu entstandenen Baum Bi;1 mit dem vorhandenen zu
einem Bi vereinigt wird. Das ist die \+1\ in an = a n2 + 1. Im Falle n 62
2N0 liegen ahnliche Verhaltnisse vor. Zwei Queues mit n bzw. (n ; 2blog nc )
Knoten unterscheiden sich nur um einen Baum Bblog nc . Gesucht ist nun Sn :=
nk=1 ak . Statt obige Rekursionsgleichungen zu expandieren und eine explizite
Darstellung fur an zu suchen, die dann aufsummiert wird, betrachten wir
einfach S2k . Obiger Tabelle sieht man an, da
S2k = S2k;1 +1 gilt. Substituiert
man S2k durch Tk und lost man die entstehene Rekursionsgleichung Tk =
2Tk;1 + 1, so ergibt sich Tk = 2k+1 ; 1, also Sn = 2n ; 1. Folglich ist:
SN = O(N )
5. FindMin: Diese Operation ist trivial ausfuhrbar, denn es ist ein Pointer auf
das minimale Element gegeben. Daher ist auch die Zeitkomplexitat O(1).
6. DeleteMin:Das Minimum ist auf Grund der Heapbedingung Wurzel eines Binomialbaums Bk in der Liste. Wird es geloscht, so zerfallt der Binomialbaum
in k Teilbaume B0 B1 : : : Bk;1
r
A
Brk
r
A
@;
;
@
A
A
A
A
AA AA AA
rA
q q q q
&(k-Kinder)
A
AA
B0 B1 : : : Bk;1
Die Teilbaume B0 B1 : : : Bk;1 sind alle zur verbleibenden Queue zu mergen.
Au
erdem mu
der Min-Pointer aktualisiert werden. Der Zeitaufwand fur DeleteMin-Operation ist: O(log N )
7. Delete : Losche Knoten x:
1-Fall) x ist min-Wurzel: s.o.
2-Fall) x ist eine andere Wurzel in der Wurzelliste. Analog zu oben, ohne den
Min-Pointer zu aktualisieren.
3-Fall) x sei nicht Wurzel eines Baumes:
Angenommen, x ist in Baum Bi enthalten:
KAPITEL 1. HOHERE
DATENSTRUKTUREN
30
Bp pkp
p
p
p
p
p ;is@p p p p
p
p
p
p
p
p p p s; Bk;1@p p p p p
p
p
p
p
p
pp pp ps ;;Bk@;2@ p p p p p p p p
p
p
p
p
p
ppspp pp p p p;p p ;Bk@;3@ p p p p p p p p
p
p
p
p
p
pspp pp p p ;;Bi@+1@ p p p p p p p p p (Bp i+1 (II)
: : : Bk;1 )
p
p
p
@
p
p
;
(I)
p
p p sp p pp ;;;@;B@@i @p p p p p p p p
(Bi )p p p p p p p p p p p p psp p p p p p;;Bi@;1@p p p p - (III) (B ohne x)
p
p
p
p
p
i
p pp pp p ;;B@0 @ p p p p p p p p p
ppp pppppp
pp ppp
Im Fall-3 mu
unterschieden werden:
3a) x ist Wurzel:
sx
A
B0 ,B1 : :A: ,Bi;1
A
A
Siehe (2-Fall)
3b) x ist in Wurzel des Bi :
Bi
s
s
A
A
xA
A
Bi
So lange 3-te Fall wiederholen (Rekursiv), bis Fall-3a) eintritt
Insgesamt mu
die Binomial-Queue ohne Bi mit einer aus B0 BN ;1
bestehenden Binomial-Queue vereinigt werden.
Zeit O(log N )
8. DecreaseKey : Verkleinere Key(x)
1-Fall) x ist die min-Wurzel: keine Strukturanderung notig
2-Fall) x ist eine andere Wurzel: keine Strukturanderung notig
3-Fall) Sonst wie Delete(x), aber einfugen des Baumes mit Wurzel x und den
neuen Key(x) in die Wurzelliste.
Kosten O(log n)
Satz: Binomial-Queues haben fur die Operationen Insert, Delete, DeleteMin, FindMin, Merge und Initialize worst-case-Kosten von jeweils O(log n).
KAPITEL 1. HOHERE
DATENSTRUKTUREN
31
1.5.2 Fibonacci-Heaps
Vorbemerkungen:
Fibonacci-Heaps stellen eine Erweiterung der Binomial-Queues dar und eine
weitere Moglichkeit zur Implementierung von Heaps. Die amortisierten Kosten
fur die Operationen Delete() und DeleteMin() betragen hierbei O(log n), die
fur alle anderen Heap-Operationen lediglich O(1). Naturlich konnen die worstcase-Kosten fur (n Insert ) + (n DeleteMin) nicht unter (n log n) liegen,
denn diese Operationen zusammengenommen stellen einen Sortieralgorithmus
dar mit unterer Schranke (n log n).
Die Verwendung von Fibonacci-Heaps erlaubt eine Verbesserung der Komplexitat der Algorithmen fur die minimale Spannbaume sowie fur Dijkstra's
kurzeste-Wege-Algorithmus, denn diese verwenden relativ haug die DecreaseKey -Operation, welche durch Fibonacci-Heaps billig zu implementieren ist.
Bei einem Algorithmus, bei dem die Delete - und DeleteMin-Operationen nur
einen geringen Anteil der Gesamtoperationen darstellen, sind Fibonacci-Heaps
asymptotisch schneller als die Binomial-Queues.
Bemerkungen:
Priority-Queues eignen sich grundsatzlich nicht fur Suchoperationen, unabhangig
von ihrer Implementierung. Es ist daher immer eine zusatzliche Datenstruktur, etwa ein Suchbaum, zu verwenden.
Jedes Element besteht aus einem Schlussel (key) und einem Wert. Der Schlussel
darf in einer Priority-Queue nur einmal vorkommen. Es ist jedoch zulassig,
da
derselbe Datenwert mehreren verschiedenen Schlusseln zugeordnet ist.
Fur die folgenden Betrachtungen sind gespeicherte Werte aber uninteressant,
es werden nur die Schlussel betrachtet.
1.5.2.1 Die Datenstruktur
Die Schlussel sind an den Knoten von Baumen gespeichert
Jeder Knoten hat
{ Schlussel und Wert
{ Rang (Anzahl der Kinder)
{ Zeiger zum ersten Kind, zum Vater (NIL im Falle der Wurzel), doppelt
verkettete Liste der Kinder
{ Markierung 2 f0 1g (au
er Wurzel)
Bemerkung: Die doppelte Verkettung der Kinder- bzw. Wurzellisten innerhalb
von Heaps erlaubt das Loschen eines Listeneintrages in Zeit O(1).
Binomial-Queue vs. Fibonacci-Heap:
Fibonacci-Heaps: Wald von Baumen, innerhalb derer die Heap-Bedingungen
erfullt sind.
A-Priori: Keine Einschrankung fur die Topologie der Baume, aber ohne Delete oder DekreaseKey-Operation bleibt ein Binomialwald ein Binomialwald.
keine Invariante der Form \Nur Baume verschiedenen Wurzel-Rangs\.
KAPITEL 1. HOHERE
DATENSTRUKTUREN
U berblick:
32
Operationen worst case amortisiert
Insert
O(1)
O(1)
Merge
O(1)
O(1)
FindMin
O(1)
O(1)
DecreaseKey O(log n)
O(1)
Delete
O(log n) O(log n)
DeleteMin
O(n)
O(log n)
Linken von Baumen: Zwei Baume desselben Wurzel-Rangs werden unter Einhaltung der Heap-Bedingung verbunden. Sind k1 und k2 die Wurzeln der zwei zu linkenden Baume, so wird ein neuer Baum aufgebaut, dessen Wurzel bzgl. der Schlussel
das Minimum von k1 und k2 ist. Sei dies k2 , dann erhalt der Baum mit Wurzel k2
als zusatzlichen Unterbaum den Baum mit Wurzel k1 , d.h. der Rang von k2 erhoht
sich um eins.
rk1 > k;2 r@
;@
; @ ; @
)
k2 r
k1 r
;@
;
@
;@
;
@
Dies ist gerade der konstruktive Schritt beim Aufbau von Binomialbaumen. Zur
Verbesserung der amortisierten Zeitschranken sind zusatzlich folgende Regel Formuliert:
Kaskadiertes Abschneiden:
Ein Knoten ist im \Anfangszustand\, wenn
i) er durch einen Linkschritt Kind eines anderen Knotens wird oder
ii) er in die Wurzelliste eingefugt wird.
Wenn ein Knoten ab seinem Anfangszustand zum zweitenmal einen Sohn verliert, wird er in die Wurzelliste eingefugt.
Der kritische Zustand (ein Kind verloren) wird durch das Markierungsbit angezeigt.
Algorithmus:
x verliert Kind
y = P (x) : (Vater von x)
while (y markiert) do
entferne y f
uge y unmarkiert in die Liste
if (P (y )=NIL) then exit fi
y = P (y)
od
markiere
ein
y
Operationen:
1. Insert(x): Fuge B (mit dem Element x) in die Wurzelliste ein.
Update Min-Pointer.
Kosten O(1)
KAPITEL 1. HOHERE
DATENSTRUKTUREN
33
2. Merge(): Verbinde beide Listen und aktualisiere den Min-Pointer.
Kosten O(1)
3. FindMin(): Es wird das Element ausgegeben, auf das der Min-Pointer zeigt.
Dabei handelt es sich sicher um eine Wurzel.
Kosten O(1)
4. Delete(x)
i) Falls x Min-Wurzel, DeleteMin-Operator benutzen
ii) Sonst:
while true do
f
uge Liste der Kinder in die Wurzelliste ein
l
osche ,
=Vater( )
if Markierung( )=0 then Markierung( )=1 exit
else
h
ange
samt Unterbaum in Wurzelliste
entferne Markierung von
da
Wurzel
= Vater( )
fi
od
x x
x
x
x
x
x
x
x
x
5. DeleteMin(): Diese Operation hat auch Aufraumfunktion und ist daher recht
kostspielig. Sei x der Knoten, auf den der Min-Pointer zeigt:
x :=" Min-Pointer
x
entferne
aus der Liste
Konkataniere Kinderliste vom
mit der Wurzelliste
while (
2 B
aume von selben Wurzel-Rang ) do
erzeuge Baum vom Wurzel-Rang + 1
od
update Min-Pointer
9
x
i
i
Man beachte, da
an jedem Knoten, insbesondere jeder Wurzel, der Rang gespeichert ist. Zwar vereinfacht dies die Implementierung, doch mussen noch
immer Paare von Wurzeln gleichen Rangs gefunden werden. Dies wird wie
folgt realisiert: Wir verwenden ein array, dessen Indizies je fur einen Rang
stehen. Die Elemente sind Zeiger auf eine Wurzel dieses Rangs. Es ist garantiert, da
ein Element nur dann unbesetzt ist, wenn tatsachlich keine Wurzel
entsprechenden Rangs existiert. Nach dem Entfernen des Knoten x aus der
Wurzelliste fugen wir die Kinder eines nach dem anderen in die Wurzelliste ein
und aktualisiern in jedem Schritt das array. Soll eine bereits besetzte Position
des arrays beschrieben werden, so wird ein Link-Schritt ausgefuhrt und versucht, einen Pointer auf die neue Wurzel in die nachsthohere Position im array
zu schreiben. Dies zieht evtl. weitere Link-Schritte nach sich. Nach Abschlu
dieser Operation enthalt die Fibonacci-Heap nur verschiedene Baume. Liegt
der kanonische Fall vor, da
ausschlie
lich Binomialbaume im Spiel sind, so
erhalten wir durch DeleteMin-Operation eine Binomial-Queue.
Zeitkomplexitat fur DeleteMin: O(max Rang + # Link-Schritte)
KAPITEL 1. HOHERE
DATENSTRUKTUREN
34
6. DecreaseKey(K $):
x
entferne = ( )
f
uge
unmittelbar in die Wurzelliste ein
Key( ) := Key( ) - $
while ( markiert) do
entferne f
uge
unmarkiert in die Wurzelliste ein
if ( ( ) =NILL) then exit fi
= ( )
od
markiere y Px
x
x
x
y
y
Py
y Py
y
y
Zeitkomplexitat: O(max Hohe)
Bemerkung: Wird mit einem leeren oder gar keinem Fibonacci-Heap gestartet,
und werden ausschlie
lich die aufbauenden Operationen Insert, Merge und FindMin
angewendet, so konnen nur Binomialbaume enstehen. In diesem naturlichen Fall also liegt stets ein Binomialwald vor, der jedoch i.a. nicht aufgeraumt ist. Das hei
t,
es existieren mehrere Binomialbaume Bi desselben Typs, die nicht paarweise zu
Bi+1 -Baumen verschmolzen sind. Dies geschieht erst bei der Operation DeleteMin.
Man beachte, da
nur nach einer solchen Operation momentan ein Binomial Heap
vorliegt, ansonsten nur ein Binomialwald.
1.5.2.2 Amortisierte Kostenanalyse fur Fibonacci-Heaps
Kostenanalyse fur Operation Sequenzen:
i) Summieren der worst-case-Kosten ware zu pessimistisch. Der resultierende
Wert ist i.a. zu gro
.
ii) average-case:
- Aufwand fur Analyse zu hoch
- realistische Verteilung fur Eingabe?
iii) amortisierte Kostenanalyse: average-case-Analyse uber worst-case-Sequenzen
von Operationen.
Denition: Wir fuhren fur jede Datenstruktur (Fibonacci-Heap) ein
Bankkonto ein und ordnen ihr eine nichtnegative reelle Zahl bal, ihr
Potential (bzw. Kontostand) zu. Die amortisierten Kosten fur eine Operation ergeben sich als Summe der tatsachlichen Kosten und der Veranderung des Potentials ($bal), welche durch die Operation verursacht wird:
ti := worst-case-Kosten der i-ten Operation
$bali = bali ; bali;1 : Potentialveranderung durch die i-te Operation.
ai = ti + $bali : \amortisierte Kosten\ der i-ten Operation
m : Anzahl der Operationen
Falls balm bal0 (Was bei bal0 := 0 stets gilt):
m
X
i=1
ai =
m
X
m
X
i=1
i=1
(ti + $bal) =
ti + balm ; bal0 m
X
i=1
ti
KAPITEL 1. HOHERE
DATENSTRUKTUREN
35
Amortisierten Kosten einer Sequenz sind obere Schranke fur die tatsachlicher Kosten. Anwendung auf Fibonacci-Heaps:
bal := # Baume + 2#(markierte Knoten 6= Wurzel)
Lemma: Sei x ein Knoten im Fibonacci-Heap mit Rang(x) = k. Seien die Kinder
von x sortiert in der Reihenfolge ihres Anfugens an x, dann ist der Rang des i-ten
Kindes i ; 2.
Beweis: Zum Zeitpunkt des Einfugens des i-ten Kindes ist der Rang(x) = i ; 1
(Das i-tes Kind hat zu dieser Zeit auch Rang (i ; 1)). Danach kann das i-te Kind
hochstens einen Sohn verloren haben ) Rang i ; 2.
3
Satz: Sei x Wurzel eines Baums im Fibonacci-Heap, Rang(
x) = k. Dann enthalt
P
der Baum mit Wurzel x mind. Fk+2 Elemente (Fk+2 = ki=2 Fi + 2).
(D.h., die Wurzelrange sind logarithmisch beschrankt).
Beweis: Sei fk die minimale Anzahl der Elemente im Baum, dessen Wurzel Rang
k hat.
) fk fk;2 + fk;3 + : : : + f0 + 1 + 1
Setze: gk := gk;2 + gk;3 + : : : + g0 + 2, d. h. fk gk g0 := 1
(1)
gk
= gk;2 + gk;3 + : : :
(2)
gk;1
=
gk;3 + gk;4 + : : :
(1) - (2) gk ; gk;1 = gk;2
) gk = gk;1 + gk;2 ) fk gk = Fk+2
pp
3
Amortisierte Kosten der FH-Operationen (ai = ti + $bali):
FindMin: a = t = O(1).
Insert : t = O(1) $bal = +1 ) a = O(1).
Merge : t = O(1) $bal = 0 ) a = O(1).
DeleteMin:
9
Einfugen der Kinder von x in Wurzelliste:
>
>
>
>
$bal = Rang(x)
>
>
Jeder Link-Schritt verkleinert # Baume um 1 = ) a = O(log N )
$bal = ;1
>
>
>
) Jeder Link-Schritt wird von Bankkonto >
>
>
bezahlt und verschwindet amortisiert
DecreaseKey : Es ist $bal = 3 ; (# kaskadierte Schritte)
Jeder Schritt erhoht die # der Baume um 1
bal+ = 1
Jeder Schritt vernichtet eine Markierung
bal; = 2
Der letzte Schritt erzeugt eine Markierung
bal+ = 2
Literatur:
9
>
>
>
>
>
>
=
>
>
>
>
>
>
) a = O(1)
Fredman, Tergen: Fibonacci-Heaps and their uses in improved network optimization algorithmus, Procceedings of the 25th., FOCS, 1984, S. 338-346
KAPITEL 1. HOHERE
DATENSTRUKTUREN
36
1.6 Sich selbst organisierende Datenstrukturen
1.6.1 Motivation
einfach, wenig Verwaltungsoverhead
e"zient im amortisierten Sinn
1.6.2 Sich selbst organisierende lineare Listen
Beim sog. \Worterbuchproblem\ ist auf moglichst e"ziente Weise eine Menge von
bis zu n Elementen zu organisieren:
Einfugen
Loschen
Reihenfolge andern
Dabei soll die E"zienz der Implementierung bei beliebigen Sequenzen von m Operationen untersucht werden. Die Menge wird als unsortierte Liste dargestellt.
s
?
-
s
-
s
-
ppppppppp
-
s
Operationen:
1. Access(i): Suchen des Elements i:
Die Liste wird von Anfang an durchsucht, bis das gesuchte Element gefunden
ist. Fur das i-te Element betragen die tatsachlichen Kosten i Einheiten.
2. Insert(i): Einfugen des Elements i:
Die Liste wird von Anfang an durchsucht, und wenn sie vollstandig durchsucht
wurde und das Element nicht enthalten ist, so wird es hinten angefugt. Diese
erfordet (i + 1) Schritte, wenn die Lange der Liste i ist.
3. Delete(i): Loschen des Elements i:
Wie bei Access wird die Liste zuerst durchsucht und dann das betreende
Element geloscht. Diese kostet im Falle des i-ten Elements i Schritte.
Nach Abschlu
einer jeden Operation konnen gewisse Umordnungsschritte stattnden, die spatere Operationen beschleunigen.
Annahme: Wir nehmen an, da
nach Ausfuhrung jeder Access - oder Insert -Operation,
die auf Element i angewandt wird, dieses Element kostenlos um beliebig viele Positionen in Richtung Listenanfang geschoben werden kann. Wir nennen jede daran
beteiligte Elementenvertauschung einen kostenlosen Tausch. Jeder andere Tausch
zweier Elemente ist ein bezahlter Tausch und kostet eine Zeiteinheit.
Ziel: Es soll eine einfache Regel gefunden werden, durch die mittels obiger Ver-
tauschungen die Liste so organisiert wird, da
die Gesamtkosten einer Folge von
Operationen minimiert werden. Wir sprechen von \selbstorganisierenden linearen
Listen\ und untersuchen hierzu folgende Regeln:
MFR (Move-to-Front-Rule): Access und Insert stellen das betreende Element
vorne an die Liste an und verandern ansonsten nichts.
TR (Transposition-Rule): Access bringt das Element durch eine Vertauschung
um eine Position nach vorne, insert hangt es ans Ende der Liste an.
KAPITEL 1. HOHERE
DATENSTRUKTUREN
37
Bemerkung:
- Die MFR erlaubt die Ausfuhrung einer Sequenz von Operationen Access, Insert
und Delete mit einer amortisierten Laufzeit, die um hochstens den konstanten
Faktor 2 schlechter ist als ein optimaler Listenalgorithmus.
- Fur die TR dagegen gibt es keinen solchen konstanten Faktor. Sie kann verglichen mit MTR bzw. einem optimalen Algorithmus beliebig schlecht sein.
Fur die Algorithmen nehmen wir an:
1. Kosten fur Access(xi ) und Delete(xi ) sind gleich der Position von xi in der
Liste (von Anfang an gezahlt).
2. Kosten fur Insert(x) (x nicht in Liste) ist der Lange der Liste nach der Insert Operation (d.h. neue Elemente werden zunachst an Listenende) angehangt
3. Ein Algorithmus kann die Liste jederzeit umorganisieren (die Reihenfolge
andern).
(a) kostenlose Vertauschung: nach einer Access(x)- oder Insert(x)-Operation
kann x beliebig naher an den Anfang der Liste verschoben werden.
(b) bezahlte Vertauschung: jede andere Vertauschung benachbarter Listenelemente kostet eine Einheit.
Bemerkung: MFR (und auch Transpose) benutzen nur kostenlose Vertauschungen. 3a ist pessimistisch fur MFR.
Satz: Sei s eine beliebige Folge von Access, Insert und Delete Operationen, be-
ginnend mit einer leeren Liste. Sei A ein beliebiger (optimaler) WorterbuchAlgorithmus mit obigen Einschrankungen. Sei CA (s) der Zeitaufwand von A auf s,
ohne bezahlte Vertauschungen. Sei XA (s) die Anzahl der bezahlten Vertauschungen. Sei CMFR (s) der Gesamtaufwand der Move to front-Heuristik auf s. Sei FA (s)
die Anzahl der kostenlosen Vertauschungen, die A auf s ausfuhrt. Sei m := jsj die
Lange von s. Dann
CMFR(s) 2 CA (s) + XA (s) ; FA (s) ; m
Beweis: Potentialfunktion: LA bzw. LMFR seien die Listen, A bzw. MFR (fuhrt
bei Eingabesequenz s) sind die Algorithmen.
Potential := Anzahl der Inversionen in LMFR im Vergleich zu LA
D.h. sei o.B.d.A. LA = (x1 x2 : : : xn ).
Dann ist die Potential:
bal(LMFR LA ) =
n
X
j =1
jf i j > i und xj ist in LMFR vor xi gj
Wir betrachten im folgenden Insert(x) als ein Access auf ein (ktives) (n + 1)-tes
Element. Eine Operation (Access(xi ) bzw. Delete(xi )) kostet fur A dann i Einheiten
und fur MFR t Einheiten, wobei t die Position von xi in LMFR ist.
i) A andert (bei Access bzw. Delete ) LA in kanonischer Weise. Fur Element xi
sind die Kosten i-Einheiten.
KAPITEL 1. HOHERE
DATENSTRUKTUREN
38
ii) Die amortisierten Kosten einer Operation (Access(xi ) oder Delete(xi )) fur
MFR sind 2i ; 1
A:
MFR :
L
L
1 x2
x
: :x:i
: : : xn
: : : : : : : :x:j
: : : xi
:::
"
t
Sei k die Anzahl der Elemente (wie xj ), j > i, die im LMFR vor xi stehen.
t ist die Position xi im LMFR:
ti+k )k t;i
$bal ;k + (i ; 1) i ; t + i ; 1 2i ; 1 ; t (bei Access)
$bal = ;k i ; t (bei Delete )
Amortisierte Kosten t + $bal 2i ; 1.
iii) Die amortisierten Kosten einer kostenlosen Vertauschung durch Algorithmus
A sind ;1
A:
LMFR :
L
+s
1 x2 : : : xi;1 xi : : : xn
: : : xi : : : xi;1 : : : : : :
x
eine Inversion weniger
iv) Die amortisierten Kosten einer bezahlten Vertauschung durch Algorithmus A
sind 1
A:
LMFR :
L
+s
1 x2 : : : xi;1 xi : : : xn
: : : xi;1 : : : xi : : : : : :
x
plus eine Inversion
Anfangspotential : 0
) CMFR (s) amort. Kosten MFR 2 CA (s) + XA (s) ; FA (s) ; m
3
Anmerkung: Wenn wir nicht mit einer leeren Liste (oder zwei identischen Listen, d.h. LA = LMFR ) starten, ergibt sich:
CMFR 2CA (s) + XA (s) ; FA (s) ; m + n2
Literatur:
Sleator, D.R., Tarjan: Amortized e"ciency of list update and paging rules. Comm.
ACM 28(2), p. 202-208 (1985).
1.6.2.1 Sich selbst organisierende Binary Keys
Priority Queue
Variante von Leftist-Baumen s.Knuth]: Ein Leftist-Baum ist ein (interner)
binarer Suchbaum, so da
fur jeden der Knoten gilt, da
ein kurzester Weg
zu einem Blatt uber das rechte Kind fuhrt.
KAPITEL 1. HOHERE
DATENSTRUKTUREN
39
Wir wollen folgende Operationen unterstutzen:
- Insert
- FindMin
- DeleteMin
- Delete
- Merge
9
>
>
>
>
=
>
>
>
>
alle Operationen lassen sich auf Merge zuruckfuhren
Operationen:
1. Insert(T x): neuer Baum mit x als Element, merge diesen mit T
p
2. FindMin: (Minimum an der Wurzel, wegen Heap-Bedingung)
3. DeleteMin:
m
@;
;@
; @
;
@
A
A
T1A T2A
q
4. Delete :
q
p
pp p p
mp(x)
@;
mx
;@
q;; @@qA
A
T1A T2A
) mergeq T1 undq T2
A
A
T1A T2A
p
ppmp p
p(x)
)
J
J
J
merge(T1 T2 )
5. Merge : Seien zwei Heaps H1 und H2 gegeben, seien a1 :: ar1 die Folge der
Knoten in H1 von der Wurzel zum rechtesten Blatt, sei b1 :: br2 die entsprechende Folge in H2 .
H1
H2
a1
b
pp p p p s@@s a2
pp p p p s@1@s b2
p
p
pp p p @@p sp
pp p p @@p sp
p p
p p
p p p p pp p s
p p p p pp p s
p p p @@sar1
p p p @@sbr1
Sei c1 c2 :: cr1 +r2 die durch Merging aus (a1 :: ar1 ) und (b1 :: br2 ) entstehende (sortierte) Folge. Mache (c1 :: cr1 +r2 ) zum linkesten Pfad im neuen Baum
und hange den jeweiligen anderen (d.h. linken) UB ai bzw. bj als rechten UB
des entsprechenden ci an.
KAPITEL 1. HOHERE
DATENSTRUKTUREN
40
Beispiel:
H1
;
;
m
9
A
A
H1
; @
;
@
m
5
m
1
m
3
; @
;
@
m
11
A
A
m
m
4
m
6
10
A
A
m
8
;
;
m
7
m
2
; @
;
@
A
A
)
A
A
m
4
A
A
6m
A
A
m
3
m
2
m
1
A
A
A
A
m
11
A
A
m
7
m
5
A
A
8m
Amortisierte Kostenanalyse der Merge-Operation:
Sei w(x) := Gewicht von x = # Knoten im UB von x (einschlie
lich x)
xr
J
z r
r
J y
J
(x y) schwer ) (x z ) leicht
Kante(x y) hei
t leicht, falls 2:w(y) w(x)
Kante(x y) hei
t schwer, sonst
Es gilt: Es ist immer ein Kind uber leichte, eins uber schwere Kante erreichbar.
Beobachtungen:
1. (x y) schwer ) (x z ) leicht
2. Da sich uber eine leichte Kante das Gewicht mindestens halbiert, kann ein
Pfad von der Wurzel zu einem Blatt hochstens log n leichte Kanten enthalten.
Potential: # schwere Kanten zu rechten Kindern
KAPITEL 1. HOHERE
DATENSTRUKTUREN
H1
n1 := jH1 j
p p s a1
41
H2
n2 := jH2 j
p p p s@b1
p p p @@6p p@s
p p @@@@COp p@s
p p p ;@p p @s
p p p CC @p p s
C pp @
;
@
Hp p p
@p s
Cp
@p s
@
leichte H
H pp
p@
C
p
H
@
@
Kanten
pp HH @H@p s
p
@p s
C p
j
@
ppH
C
@
p
XX p p -@
XXX @
p
@p ps
@p ps
schwere
Kanten
XX
z
X
pp -@@
p @@
p
p
p
@
@
s
@
@s br1
ar1
schwere Kanten
s1 := # schwere Kanten auf den rechten Pfad.
s2 := Analog.
r1 s1 + log n1
r2 s2 + log n2
Amortisierte Kosten fur Merge:
r1 + r2 + log(n1 + n2 ) ; s1 ; s2
log n1 + log n2 + log(n1 + n2 )
= O(log(n1 + n2 ))
Satz: Eine Folge von m merge-Operationen benotigt Zeit:
m
X
O(
i=1
log(ni ))
wobei ni die Gro
e des Baumes ist, der in der i-ten merge-Operation geschaen
wird.
1.6.2.2 Splay-Trees als Suchbaume
1.6.2.2.1 Einleitung
Wie schon in fruheren Kapiteln sollen binare Suchbaume verwendet werden, um Elemente, bestehend aus einem Schlussel und einer Information, anhand ihres Schlussels
zu lokalisieren. Das Universum ist total geordnet, und innerhalb eines Suchbaumes
soll die Invariante \Knoten im lUb Key(Wurzel) Knoten im rUb\ gelten.
Der hier zugrundeliegende Ansatz bemuht sich, innerhalb einer Folge von Operationen durch Realzeit-Umorganisation der Datenstruktur moglichst weit vom worstcase zu entfernen, statt die jeweiligen worst-case-Kosten zu minimieren. Bei jedem
Zugri auf den Baum soll eine moglichst einfache Reorganisationsregel angewendet
werden, um die Laufzeit kunftiger Operationen zu vermindern. Wie bei der MFR
fur selbst organisierende Listen soll erreicht werden, da
Elemente mit haugem
Zugri moglichst nahe an der Wurzel liegen. Ein Element, auf das die Suchoperation angewendet wird, wird zur Wurzel befordet, in der i.a. berechtigten Honung,
da
weitere Zugrie auf dieses Element folgen.
KAPITEL 1. HOHERE
DATENSTRUKTUREN
42
Denition: Ein Splay-Tree ist ein interner binarer Suchbaum, d.h.
\Knoten im lUb Key(Wurzel) Knoten im rUb\
Alle Knoten tragen Elemente, denn Zeiger auf Blatter sind NILPointer.
Rotationen, um Knoten an die Wurzel zu bewegen.
Beispiele:
i) Einfach Rotation
ii) Move to root
ys
x s;;@@
;@
;
@ CJJ
J
AJ BJJ
)
e
)
)
sHH
H
d s
HHH
FJJ
s
c
HH
Hsb EJJ
J
;@@
AJ
a s;
;;@@ DJJ
BJJ CJJ
e
xs
s
;@
;
@y
J
;@
A
J ;
@
J
B
J CJJ
)
e
sHH
H
d s
HHH
FJJ
s
c
HH
Hsa EJJ
J
;
AJ
; @@sb
BJJ ;;@@
CJJ DJJ
)
)
e
sHH
sHH
s
H
s
H
a
dH
HH
H
J
F
s
H
Hsd FJJ
J c s
a
HH
;
@
J
Hs b EJ
; @ b;
s;@
@
c s
;
@
;
@
J
J
;
@
A
B
; @
; @
J
J ; @ EJJ
J
J
J
J
AJ BJ CJ DJ
CJJ DJJ
a
sXXXX
XXse
c s
HH
HHH
H
d s
AJJ
BJJ
FJJ
@
s;@
b;
;;@@ EJJ
CJJ DJJ
Beide Heuristiken benotigen fur geeignete Folgen von Zugrisoperationen (n)
amortisierte Zeit. Beim MTR (Move To Root) im probabilistischen Sinn ist dies
eine gute Komplexitat. Zugriswahrscheinlichkeiten sind fest und unabhangig.
1.6.2.2.2 Die Splaying-Operation
Ein Knoten, auf den zugegrien wird (Splay(x T )), wird durch eine Folge von einfachen und doppelten Rotationen an die Wurzel bewegt. Falle:
1. (zig): x ist Kind der Wurzel von T : einfache Rotation
KAPITEL 1. HOHERE
DATENSTRUKTUREN
ys
s
x ;;@@
;
; @@ CJJ
AJJ BJJ
)
43
xs
s
;@
;
@y
J
;@@
A
J ;
BJJ CJJ
2. (zig-zig): x hat Gro
vater g(x) (und Vater p(x)) und x und p(x) sind jeweils
linke (bzw. rechte) Kinder ihres Vaters.
x=linkes Kind x=rechtes Kind
g(x)=p(y)s
g(x)
;@@
;@
s
y =p(x) ;
bzw. ; @ p(x)
p
p
p
p
p
p
p
s
p
x s;;@@ DJJ
;
; @@ CJJ
AJJ BJJ
&
DJJ ;;@@ x
CJJ ;;@@
BJJ AJJ
s
s
Doppelrotation
x
;;@@ y
AJJ ;;@@ z
BJJ ;;@@
CJJ DJJ
s
s
s
3. (zig-zag): x hat Gro
vater g(x) und Vater p(x), x ist linkes (rechtes) Kind
von p(x), p(x) ist rechtes (linkes) Kind von g(x).
z =g(x)
y=p(x)sHH
s@ x HJ
;
; @s
DJ
;@
AJJ ;
@
J
B
J CJJ
)
s
xs
s
H
y HH z
;@
;;@@
;
@
J
J
J
A
B
C
J J J DJJ
U bung: (Splaying-Operation mit dem eingekreisten Element durchfuhren)
1)zigzig
2)zigzag
3)zigzag
4)zigzig
s
s
;
;
;
;
s
;
s;@
@s
s@;
;
@s
@
s@
@
fs
@
1)zigzig
2)zigzig
3)zigzig
4)zig
;
s
;
fs;;
;
s
;
;
s;
s
s
;
s
;
;
;
;
;
s
s@
@s
s@;
;
@s
s@;
;
@s
s@;
;
@f
s
1)zigzag
2)zigzag
3)zigzag
4)zig
1.6.2.2.3 Amortisierte Kostenanalyse der Splay-Operation
Jeder P
Knoten habe Gewicht w(x) > 0. Gewicht tw(x) des Unterbaums mit Wurzel
x ist: y w(y)
(8y im Unterbaum mit Wurzel x)
KAPITEL 1. HOHERE
DATENSTRUKTUREN
Rang r(x) = log(tw(x))
Potential eines Baumes T :
P
x2T
44
r(x)
Lemma: Sei T ein Splay-Tree mit Wurzel u, x ein Knoten in T . Die amortisierten
u)
Kosten fur Splay(x, T ) sind 1 + 3(r(u) ; r(x)) = O log tw(
tw(x) .
Beweis: Induktion uber die Folge von (Doppel)Rotationen:
Berechne r und r0 , tw und tw0 , die Rang- bzw. Gewichtsfunktion vor und nach
dem Rotationsschritt. Wir zeigen, da
die amortisierten Kosten im Fall 1 (zig)
1+3(r0 (x) ; r(x)) und in den Fallen 2 und 3 (zig-zig bzw. zig-zag) 3(r0 (x) ; r(x))
sind. y sei der Vater von x, z der Gro
vater (falls er existiert).
1. Fall:
s
y
s
H
x HH
;@
;
@
CJJ
AJJ BJJ
)
x
s
s
HH
Hy
;@
J
;
@
AJ
J
B
J CJJ
amortisierte Kosten:
1 + r0 (x) + r0 (y) ; r(x) ; r(y) 1 + r0 (x) ; r(x), da r0 (y) r(y)
1 + 3(r0 (x) ; r(x)), da r0 (x) r(x)
2. Fall:
z
p
s
p
p
;@@
y;
s
p
x s;;@@ DJJ
;
; @@ CJJ
AJJ BJJ
)
x
p
p
p
;;@@ y
AJJ ;;@@ z
BJJ ;;@@
CJJ DJJ
p
s
s
s
amortisierte Kosten:
2 + r0 (x) + r0 (y) + r0 (z ) ; r(x) ; r(y) ; r(z )
= 2 + r0 (y) + r0 (z ) ; r(x) ; r(y), da r0 (x) = r(z )
2 + r0 (x) + r0 (z ) ; 2r(x), da r0 (x) r0 (y) und r(y) r(x)
Es gilt, da
2 + r0 (x) + r0 (z ) ; 2r(x) 3(r0 (x) ; r(x))
d.h.
2r0 (x) ; r(x) ; r0 (z ) 2
Betrachte dazu die Funktion
f(x y) = log(x) + log(y)
auf dem Bereich
x y > 0 x + y 1
KAPITEL 1. HOHERE
DATENSTRUKTUREN
45
y
Punkt
2 2
s@-
16
@ max
Behauptung:
; 1 1 f(x y ) nimmt ihr eindeutiges Maximum im
an.
0 1 x
Beweis: Da die Funktion z ! log(z) streng monoton wachsend ist, kann
sich das Maximum der Funktion f(x y) = log(x) + log(y) nur auf dem Geradensegment x + y = 1, x y > 0 benden. Dadurch erhalten wir ein neues
Maximierungsproblem fur die Funktion g(x) = log(x) + log(1 ; x) auf diesem
Geradensegment. Da g(x) an den Randern gegen ;1 strebt, mu
es sich um
ein lokales Maximum handeln. Die einzige Nullstelle der Ableitung
g0 (x) = ln1a x1 ; 1 ;1 x wenn log = loga , ist x = 0:5 (unabhangig von a). Weiter ist
g00 (x) = ; ln1a x12 + (1 ;1 x)2 :
Da g00 (0:5) < 0 ist, nimmt g(x) in x = 0:5 sein globales Maximum an. Insgesamt folgt, da
die Funktion f(x y) = log(x) + log(y) ihr globales Maximum
im Bereich x y > 0, x + y 1 an der Stelle (0:5 0:5) annimmt.
3
Damit gilt:
0
tw(
x
)
tw
(
z
)
0
0
r(x) + r (z ) ; 2r (x) = log tw0 (x) + log tw0 (x) ;2
da
tw(x) + tw0 (z ) tw0 (x)
3. Fall:
s
zs
H
y HH
;@
;
@x
DJJ
;
@
J
AJ ; @
BJJ CJJ
s
)
s
xs
s
H
y HH z
;@
;;@@
;
@
AJJ BJJ CJJ DJJ
amortisierte Kosten:
2 + r0 (x) + r0 (y) + r0 (z ) ; r(x) ; r(y) ; r(z )
2 + r0 (y) + r0 (z ) ; 2r(x), da r0 (x) = r(z ) und r(x) r(y)
2(r0 (x) ; r(x)), da 2r0 (x) ; r0 (y) ; r0 (z ) 2
Letzteres folgt aus der Behauptung uber f(x y) wie im Fall 2.
Die Gesamtbehauptung des Lemmas folgt dann durch Aufaddieren der amortisierten Kosten fur die einzelnen Schritte (Beachte: Teleskop-Summe).
3
Sei T ein Splay-Tree mit n Knoten. Die Verringerung des Potentials durch eine Folge von Splay-Operationen (splay(xj T ))j=1::n , falls sich die Gewichte nicht andern,
KAPITEL 1. HOHERE
DATENSTRUKTUREN
beschrankt sich durch
n
X
n
X
i=1
i=1
(log W ; log wi ) =
log W
w
i
W :=
46
n
X
i=1
wi
wi = Gewicht von xi :
Satz: Die gesamten Kosten fur die m Zugrie sind O((m + n) log n + m).
Beweis:
amortisierte Kosten = reelle + $balance reelle Kosten = amortisierte - $balance.
Wahle wi = n1 fur alle Knoten. ) amortisierte Kosten fur einen Zugri 1+3 log n,
n
n
n
P
P
P
da W = wi = 1. Die Verringerung im Potential ist log wWi = log n =
i=1
i=1
i=1
n log n. ) reelle Kosten m(1 + 3 log n) + n log n.
3
Satz: Sei q(i) die Anzahl der Zugrie auf das Element xi (in einer Folge von m
Zugrien). Falls auf jedes Element zugegrien wird (also q(i) > 1 fur alle i), dann
sind die (reellen) Gesamtkosten fur die Zugrie
n
X
!
m
O m + q(i) log q(i)
i=1
Beweis: Setze Gewicht des i-ten Knotens gleich q(mi) .
)W=
n
X
i=1
q(i) = 1 Rest wie oben.
m
3
Satz: Betrachte Folge von Zugrisoperationen auf eine n-elementige Menge. Sei t
die dafur notige Anzahl von Vergleichen in einem operationalen statischen binaren
Suchbaum. Dann sind die Kosten in einem (anfangs beliebigen) Splay-Tree fur die
Menge O(t + n2 ).
Beweis: Sei U die Menge, d die Tiefe eines (fest gewahlten) optionalen statischen
Suchbaumes, sei fur x 2 U , d(x) die Tiefe von x in diesem Suchbaum. Deniere:
tw(x) := 3d;d(x): Sei T ein beliebiges Splay-Tree fur U :
bal(T ) X
x2U
X
x2U
tw(x) =
r(x) =
X
x2U
log 3d;d(x) =
= ((log 3)
X
x2U
3d;d(x) X
x2U
d
X
i=0
X
x2U
(log 3)(d ; dx ) =
(d ; d(x))) = O(n2 )
2i 3d;i = 3d
(T ) log 3d+1 = log 3d(x)+1:
) log tw
tw(x)
3d;d(x)
d
X
( 32 )i 3d 1 2 = 3d+1
1; 3
i=0
Damit ergibt sich fur die amortisierte Kosten fur Splay(x T ):
(T )
O(log tw
tw(x) ) = O(d(x) + 1).
n = jU j
KAPITEL 1. HOHERE
DATENSTRUKTUREN
47
Damit sind die amortisierten Kosten c: Zugriskosten (# Vergleiche) im optimalen Suchbaum (wo sie d(x)+1 sind). Die gesamten amortisierten Kosten fur die
Zugrisfolge sind daher c:t.
Damit sind reelle Kosten a:Kosten + Verringerung des Potentials = O(t + n2 ).
3
1.6.2.2.4 Worterbuchoperationen in Splay-Trees
Betrachte (Alle diese Operationen werden mit Hilfe von Splay implementiert):
Access(i, T ): p (Haben wir bereits)
Join(T1, T2 ):
gro
tes Element in T1
s
s
HH
j
;
;! ;
;! ;;@@
JJ JJ
JJ JJ
JJ JJ
T1
T10
T2
T2
| {z }
T10
beachte x 2 T1 y 2 T2 , dann gilt x < y
Split(i, T ):
i bzw. i;Hoder i+
s
T2
s
s
H
j
@
iT ) ;;@@ ;! ;;
@
bzw.
JJ ;Access(
;;;;;;
!
J
J
J
J
J
T
J J
J J
J JJ
Insert(i, T ):
Split(i, T ) ;!
;!
JJ
Delete(i, T ):
Access(i, T ) ;!
JJ
is
;@
;
@
J
J JJ
;!
is
;;@@
JJ JJ
JJ JJ
Join
;;!
JJ
T 0 = T ; fig
Denition: Sei i 2 U T ein Splay-Tree. Dann bezeichnen wir mit i;
(bzw. i+) den Vorganger (bzw. den Nachfolger) von i in der gegebenen
Ordnung in T (falls diese existieren). Falls i; bzw. i+ undeniert sind,
so setzen wir w(i;) = 1 bzw. w(i+) = 1. Weiterhin sei W das Gesamtgewicht aller an einer Worterbuch-Operation beteiligten Knoten.
KAPITEL 1. HOHERE
DATENSTRUKTUREN
48
Satz: Fur die amortisierten Kosten der Worterbuch-Operationen in Splay-Trees
gelten die folgenden oberen Schranken: (T T1 T2 =
6 0)
i; := gro
test Element in T kleiner als i
i+ := kleinstes Element in T gro
er als i
8
>
W + O(1) falls i 2 T
>
< 3 log
w(i)
Access (i T ) : >
W
>
: 3 log
minfw(i; ) w(i+ )g + O(1) falls i 62 T
8
>
>
<
Split(i T ) : >
>
:
W + O(1) falls i 2 T
3 log w(
i)
3 log minfw(i;W) w(i+ )g + O(1) falls i 62 T
Join(T1 T2 ) : 3 log
W + O(1) i maximal in T
1
w(i)
W + O(1)
W ; w(i)
+
log
Insert(i T ) : 3 log
;
+
minfw(i ) w(i )g
w(i)
i62T
Delete(i T ) : 3 log
i2T
W ; w(i)
W
w(i) + 3 log w(i; ) + O(1)
falls i nicht minimal in T
1.6.3 Weitere Arten von Datenstrukturen
Dynamische Datenstrukturen:
Referenz: Bent, S. W.: Dynamic weighted data structures, TR STAN-CS-82916, Department of Computer Science, Stanford University, 1982
Persistente Datenstrukturen:
Referenz: Driscoll, J. R., Sarnak, N., Sleater, D. D., Tarjan, R. E., Making
data structures persistent, Proceedings of the 18th Annual ACM Symposium
on Theory of Computing (STOC), 1986. p.109{121.
1.7 Radix-basierte Priority-Queue
1.7.1 Buckets
Eine relativ einfache Moglichkeit, Vorrangwarteschlangen zu implementieren, stellen
Buckets dar. Diese Implementierung beinhaltet einen Array von Buckets, wobei der
i-te Bucket alle Elemente mit den Schlusseln key(x)=i enthalt. Sobald der Schlussel
eines Elements sich andert, wird das Element vom alten Bucket entfernt und entsprechend dem neuen Schlussel in dem neuen Bucket eingefugt.
KAPITEL 1. HOHERE
DATENSTRUKTUREN
49
Dazu mussen folgende Annahmen erfullt sein:
Schlussel sind ganzzahlig
Zu jedem Zeitpunkt gilt fur die zu speichernden Elemente:
gro
ter Schlussel - kleinster Schlussel C
Diese Bedingungen sind zum Beispiel beim Algorithmus von Dijkstra erfullt. C ist
hier gleich der maximalen Kantenlange.
1.7.1.1 1-Level-Buckets
1-Level-Buckets bestehen aus:
einem Array b0 : : : C + 1] zur Aufnahme der Buckets. Jedes bi enthalt einen
Pointer auf der Liste der Elemente im Buckets,
einer Zahl minvalue, die gleich dem kleinsten gespeicherten Schlussel ist,
einer Zahl 0 minpos C , die den Index des Buckets mit dem kleinsten
Schlussel enthalt und
einer Zahl n, die die Anzahl der gespeicherten Elementen enthalt.
C =9
minvalue = 16
minpos = 6
n=6
0
?
20
1
2
3
?
23
4
?
5 -6
? ?
25 16
7
8
9
?
18
?
16
Wie bei jeder Vorrangswarteschlange mussen drei Operationen unterstutzt werden:
Insert(x): fugt das Element x in die Vorrangswarteschlange ein. Falls der
Schlussel des neuen Elements kleiner als der minvalue ist, minpos und minvalue
aktualisieren.
ExtractMin: liefert und loscht eines der kleinsten Elemente der Vorrangswarteschlange (falls das Element das kleinste ist, muss minpos und minvalue noch
aktualisiert werden).
DecreaseKey(x k): verringert Schlussel des Elements x auf den Wert k (falls
notig, minpos und minvalue aktualisieren).
KAPITEL 1. HOHERE
DATENSTRUKTUREN
50
Dazu kommt noch eine Initialisierung Initialize. Fur 1-Level-Buckets sehen die Operationen wie folgt aus:
1. Initialize(x):
n := 0 minvalue := 1
reserviere Platz f
ur
b (C
sei bekannt)
2. Insert : Fuge x in bKey(x) mod (C + 1)] ein
n := n + 1
if (Key(x) < minvalue) then
co x ist jetzt das Element mit dem
minpos := Key(x) mod (C +1)
minvalue := Key(x)
kleinsten Schl
ussel oc
fi
3. ExtractMin: Entferne ein beliebiges Element aus bminpos]
n := n ; 1
if (n > 0) then
co suche neues Element mit dem kleinsten Schl
ussel oc
while ] ist leer do
:= (
+ 1) mod ( + 1) od
:= Key eines Elements in ]
else
:= fi
b minpos
minpos minpos
minvalue
minvalue 1
C
b minpos
4. DecreaseKey(x k): verringert Schlussel des Elements x auf den Wert k
x
k
x < minvalue) then
minpos := Key(x) mod (C +1)
minvalue := Key(x)
Key( ) := if (Key( )
fi
Bei geeigneter Implementierung der Buckets, z.B. als doppelt verkettete Listen gilt:
Satz: Die worst-case reellen Kosten sind O(1) bei Insert, DecreaseKey und O(C )
(bei Initialize ) und ExtractMin Operationen.
Beweis: Wird x am Anfang der Liste eingefugt, so mussen bei Insert nur einige
Zeiger umgehangt sowie n, minpos und minvalue angepa
t werden, was wieder nur
ein paar Zeigeroperationen sind. Die Aktualisierung von n, minpos und minvalue
benotigt auch nur konstante Zeit. Fur das Finden des nachstkleinsten Elements
mussen aber moglicherweise alle weiteren Buckets betrachtet werden, im schlimmsten Falle C . Da bei DecreaseKey das Element x direkt ubergeben wird, sind neben
dem Einfugen auch nur wenige Zeigeroperationen und je eine Zuweisung an n und
Key(x) notig.
3
KAPITEL 1. HOHERE
DATENSTRUKTUREN
51
1.7.1.2 2-Level-Buckets
Bei einem gro
en Wertebereich der zu speichernden Schlussel, das hei
t beim gro
en
C , und einer geringen Anzahl tatsachlich abgelegter Datenelemente sind 1-LevelBuckets in zweifacher Hinsicht ungunstig:
Das Array b belegt statisch Speicherplatz der Gro
e O(C ), obwohl nur ein
kleiner Teil davon wirklich gebraucht wird.
Der Zeitbedarf fur ein ExtractMin nahert sich der worst-case-Komplexitat
O(C ), da der nachste nicht-leere Bucket ziemlich weit entfernt sein kann.
2-Level-Buckets versuchen demp mit folgender Idee abzuhelfen: Es gibt ein TopBucket (btop) bestehend aus j C + 1j Buckets und zu jedempBucket in btop gibt
es noch ein weiteres Bottom-Bucket (bbots), das auch aus B=j C + 1j Buckets besteht. Das i-te bbot nimmt Elemente auf, deren Schlussel im Interval iB (i + 1)B]
liegen. Um ein Element in ein Bucket einzufugen, wird zuerest das passende Bucket
in btop gesucht. Dann wird in dem dazugehorigen bbot das Element (wie bei 1-LevelBuckets) eingefugt.
C =9
minvalue = 16
minpos = 6
n=6
0
?
20
1
2
3
?
23
4
?
5 -6
? ?
25 16
7
8
9
?
18
?
16
Um sowohl Platz als auch Zeit zu sparen, kann man durch leichte Modizierung nur
ein einziges Bottom-Bucket einsetzen:
Verwende zwei Arrays (Top-Bucket und Bottom-Bucket) der Lange:
p
B = j C + 1j + 1
Dabei enthalt das Top-Bucket die meisten Elemente in grob vorsortierter Form, nur
die Elemente mit den kleinsten Schlusseln werden im Bottom-Bucket dann endgultig
sortiert vorgehalten. 2-Level-Buckets konnen mit folgenden Elementen aufgebaut
werden:
Das Array btop (0::B ;1]) nimmt in jedem Bucket Elemente mit Schlusseln aus
einem Intervall der Lange B auf die Schlussel stammen aus allen Intervallen
au
er dem niedrigsten.
Das Array bbot (0::B ; 1]) nimmt in jedem Bucket Elemente mit genau einem
Schlussel auf die Schlussel stammen nur aus dem niedrigsten.
valtop ist die linke Intervallgrenze des niedrigsten Intervalls.
postop enthalt den Index des Buckets in btop fur das niedrigste Intervall (das
aber in bbot gespeichert wird).
KAPITEL 1. HOHERE
DATENSTRUKTUREN
52
nbot ist die Anzahl der Elemente in bbot.
n ist die Anzahl der Elemente in bbot und btop.
C = 80
valtop = 6
postop = 2
btop :
bbot :
nbot = 4
?
0
1 -2
0
1
pp
pp
?
pp
86
pp
pp
pp
pp
pp
pp p p p p p p p p p p
pp
2
?
7
3
4
5
6
7
8
9
3
4
5
6
7
8
9
pp
pp ? ? ? ?
pp 35 48 57 85
pp
pp
pp ?
?
pp 26
63
pp
p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p p pp
pp
?
11
?
13
?
7
Dabei gilt:
btop(postop + i) mod B ] enthalt alle Elemente x mit:
valtop + iB Key(x) < valtop + (i + 1)B , wobei 1 i B ; 1
bboti] enthalt alle Elemente x mit:
Key(x) = valtop + i, wobei 0 i B ; 1
Dazu ist allerdings folgende Annahme zu machen:
Hat ein ExtractMin ein Element mit Schlussel k zuruckgeliefert, werden bis zum
nachsten Aufruf von ExtractMin nur Elemente mit Schlusseln k und k + C
eingefugt. Dies stellt sicher, da
ein Element aus bbot nie nach btop wandert.
Lemma: Zu jedem Zeitpunkt haben alle Schlussel Platz in der Datenstruktur.
Beweis: Am meisten Platz wird benotigt, wenn der kleinste Schlussel ganz rechts in
bbot gespeichert oder dort entfernt worden ist. Er hat dann den Wert valtop + B ; 1.
Der gro
te Schlussel, der nun vorkommen kann und also Platz nden mu
, ist
KAPITEL 1. HOHERE
DATENSTRUKTUREN
53
valtop + B ; 1 + C :
gro
tmoglicher Schlussel in btop
= valtop + BB ; 1
= valtop + B + (B ; 1)B ; 1
p
p
= valtop + B + (d C + 1e + 1)d C + 1e ; 1
p
valtop + B + C + 1 + d C + 1e ; 1
valtop + B ; 1 + C
= gro
tmoglicher erlaubter Schlussel
3
Annahme: Vor dem ersten ExtractMin werden nur Elemente mit 0 Schlussel C eingefugt.
i) Initialize :
valtop = postop = nbot = n = 0
Initialisiere bbot, btop
ii) Insert(x):
uberpr
ufe Invarianten
i := b Key(x)B;valtop c + postop mod B if i == postop then
F
uge x in bbotKey(x) ; valpop] ein
nbot := nbot + 1 n := n + 1
else
F
uge
fi
x
in
btopi]
ein
iii) ExtractMin
bbot
j
oc
co suche kleinstes Element in
:= 0 while
] == do := + 1 od
entferne ein (beliebiges) Element aus
:=
1 :=
1
if
== 0 then return fi
if
== 0 then
while
] == do
:= (
+ 1) mod :=
+ od
while
] = do
entferne beliebiges Element
aus
F
uge
im
Key( )
] ein
:=
+ 1
od
fi
j
bbot j
j
nbot nbot ; n n ;
n
nbot
btop postop
postop postop
valtop valtop B
nbot
bbot
nbot
x ; valtop
x
iv) DecreaseKey(x k)
x
enferne
aus seinem momentanen Bucket
falls n
otig, aktualisiere
Key( ) := Insert( )
x
x
k
und gib es zur
uck
B
btop postop 6 x
bbotj ]
nbot
btoppostop]
KAPITEL 1. HOHERE
DATENSTRUKTUREN
54
Lemma: Worst-case (reelle) Laufzeit p
bei 2-Level-Buckets
sind fur Insert und Dep
creaseKey O(1), fur ExtractMin O(n + C ) und O( C ) (bzw. O(1)) fur Initialize.
Beweis:
- Insert : O(1) + 1 = O(1)
- DecreaseKey : O(1) + ( 0) = O(1)
btop
p p
- ExtractMin O( C + C + # Elemente # ).
3
bbot
Potential: Anzahl von Elementen im Buckets im btop.
Satz: Amortisierte
Kosten fur 2-Level Buckets sind O(1) bei Insert und Decreasep
Key und O( C ) bei ExtractMin.
Beweis:
- Insert : s.o.
- DecreaseKey : s.o.
p
- ExtractMin: O( C + # Elemente
btop
btop
p
# ); # Elemente # = O( C )
bbot
bbot
1.7.1.3 k-Level-Buckets
3
Die Verallgemeinerung von 2-Level-Buckets
fuhrt zu k-Level-Buckets. Diese bestep
hen dann aus k-Arrays der Lange j k C j. Dadurch lassen sich die Speicher- und Zeitkomplexitat weiter verbessern, der Implementierungsaufwand steigt jedoch stark
an.
Zeitkomplexitat: O(C 14 )
Literartur:
Aluja, R.K., K. Mehlhorn, J.B. Orbin, R.E. Tarjan
Faster Algorithmus for the shortest Path Problem
J.ACM 37 (1990) p.213-223
Cherkassky, B.V., A.V. Goldberg, T.Ratzig
Shortest Path Algorithmus: Theory and Experimental Evaluation
Math. Prog. 73(1996) p.129-174
Cherkassky, B.V., A.V. Goldberg, C. Silverstein:
Buckets, Heaps, Lists and monoton Priority Queues.
p
Proc. 8th Soda, ACM p83-92, 1997 Hot-Queue O( log C )
KAPITEL 1. HOHERE
DATENSTRUKTUREN
55
1.7.2 Von-Ende-Boas-PQ
Von Ende Boas, P., R. Kaas, E.Zijlstra:
Universum U jU j = N U N
Hier: U = f0 1 : : : N ; 1g
Bessere Priority-Queue fur den Fall n log N
0
0 1 1 0 ::: 0 1 ::: 0
qq
:::
A
AU
O
0
:::
N ;1
q
; - ; ;
; Delete
p
Baum mit n Verzweigungen
Insert
01
HH
;@
;@
;
@
;
@
: 01
1 0 : :?
qq
A
AU
:::
::: 0
::: q
-
N ;1
Sei k 2 N k 2 k0 = k2 k00 = k2
x 2 0j : : : k 2k ; 1] k Bits
x0 = 2kx00 x00 := x mod 2k00 (x0 vordere Halfte, x00 hintere Halfte der Bits)
Sei S = fx1 : : : xm g 0 : : : 2k ; 1]
Denition: Eine k-Struktur T fur S besteht aus:
1. der Zahl T.size = jfx1 : : : xm gj = jS j = m
2. einer doppelt verketteten Liste T.list, die die Elemente von S in
aufsteigender Reihenfolge enthalt
3. einem Bitvektor T.b0 : : : 2k ; 1] mit T.bi] = 01 falls ii622SS einem
Zeiger (Pointer) Vektor T.p0 : : : 2k ; 1]. Falls T.bi] = 1, dann
zeigt T.pi] auf i in der Liste aus 2.
4. einer k0 -Struktur T.top und einem Feld T.bottom0 : : : 2k` ; 1] von
k00 -Strukturen. Falls m = 1, dann T.top, T.bottom und die zugehorigen k00 -Strukturen leer, T.size = 1. T.list = fxg, der Bitvektor wird nicht benotigt. Falls m > 1, dann ist T.top eine k0 Struktur fur die durch
fx01 x02 : : : x0m g gegebene Menge, und fur
0
k
jedes x 2 0 : : : 2 ; 1] ist T.bottomx] eine k00 -Struktur fur die
Menge fx00i 1 i m x = x0i g
KAPITEL 1. HOHERE
DATENSTRUKTUREN
56
Beispiel:
k = 4 S = f2 3 7 10 13g T.size = 5
N ;1
0
0011000100100100
T.b
T.p
? ? q qA ? ? ? q ? ? q ? ? q ? ?
T.list
U
A
?
?
?
2 - 3 - 7 -10 -13
0010 0011 0111 1010 1101
T.top ist 2-Struktur f0 1 2 3g
T.bottom0] ist eine 2-Struktur fur f2 3g
T.bottom1] ist eine 2-Struktur fur f3g
T.bottom2] ist eine 2-Struktur fur f2g
T.bottom3] ist eine 2-Struktur fur f1g
Operation Succ(x) ndet minfy 2 S y > xg in der k-Struktur T.
2
k=1
or T.Size
naive Suche
else
if T.size = 0 or
return(Succ(
else
k
j
if
then
x max in T.list
x) gibt's nicht)
then
x0 := 2kx00 x00 := x mod 2k00 if T.top.bx0 ] = 1 and x00 < maxfT.bottomx0 ]g
00
return(x0 2k + Succ(x00 T.bottomx0 ])
else
fi
z 0 :=Succ(x0 T.top),
then
z 0 2k00 + minfT.bottomz 0 ]g)
return(
fi
fi
T.top
H
k0
H
2
J
J HHH
h 0
J
H
k
T.Bottom0] J T.Bottom 2
succ(xJ) J
;;;;!
T.Bottom1] x
JJ
JJ
i
;1
Kosten: T(k) c + T( k2 ) = O(log k)
Lemma: Die Succ -Operation hat Zeitbedarf O(log k)
Beweis: p
Insert Operation:
falls x bereits in Priority-Queue, dann fertig
3
KAPITEL 1. HOHERE
DATENSTRUKTUREN
57
bestimme Succ(x T), fuge x davor ein
bestimme x0 und x00
behandle die entsprechende Unterstrukturen rekursiv:
Insert(x0 ,T.top), Insert(x00 ,T.bottomx0]) (nur ein nicht trivialer rekursiver Aufruf)
Zeitbedarf: naiv O(log2 k), Optimierung: das oberste Succ tut alles O(log k)
Delete Operation:
Komplexitat von Delete in k-Struktur: O(log k)
Kosten der Initialisierung: Gro
e der Datenstruktur
Platzbedarf fur k-Struktur: Sei S(k) der Platzbedarf fur eine k-Struktur.
Dann gilt:
S(1) = c
S(k) = c2k + S(k0 ) + 2k0 S(k0 ) fur k 2
Wir ersetzen zur Vereinfachung: S(k) = c2k + S( k2 ) + 2 k2 S( k2 )
Lemma: S(k) = O(2k log k)
Beweis:
Setze: S(k) := c0 2k log k (besser: Zeige S(k) := c0 2k log k funktioniert)
Fur k = 1 klar
Rekursionsschritt:
Platz fur k-Struktur c2k + c0 2 k2 (log k ; 1) + 2 k2 c0 2 k2 (log k ; 1)
= c2k + c0 2 k2 (1 + 2 k2 )(log k ; 1)
= c2k + c0 2 k2 (2 k2 log k + log k ; 2 k2 ; 1)
c2k + c0 2 k2 (2 k2 log k + log k ; 2 k2 )
c0 2k log k falls
c2k + c0 2k log k + c0 2 k2 log k ; c0 2k c0 2k log k
, c0 2 k2 log k (c0 ; c)2k
0
, c c;0 c log2kk (Gilt fur c0 gro
genug.)
3
Satz: Sei N = 2k , Universum U = f0 : : : N ; 1g. Wird eine Teilmenge S U
durch eine k-Struktur dargestellt, dann benotigen die Operationen Insert, Delete
und FindMin jeweils Zeit O(log log N ), die Initialisierung Zeit O(N log log N ). Der
Platzbedarf ist ebenfalls O(N log log N ).
Beweis: s.o.
3
Literatur zu van Emde Boas-Priority Queue:
1. Mehlhorn Bd. 1, S.290-296
2. van Emde Boas, P., R. Kaas, E. Zijlstra: Design and Implementation of an
e"cient priority queue, Math. Systems Theory 10 (1977), S. 99-127
KAPITEL 1. HOHERE
DATENSTRUKTUREN
58
1.7.3 Radix-Heaps
Radix-Heaps stellen eine Moglichkeit zur e"zienten Realisierung von Priority-Queues
dar, wobei ahnliche Randbedingungen wie bei den 2-Level-Buckets vorausgesetzt
werden. Dabei wird die amortisierte Laufzeit der
p langsamsten Zugrisfunktion im
Vergleich zu diesen verbessert, ahnlich von O( C ) auf O(log C ). C bezeichne wie
bei den 2-Level-Bauckets die maximale Dierenz zwischen zwei Schlusseln im Heap.
Die Grundidee besteht darin, anstelle einer Hierarchie von Buckets konstanter Gro
e,
Buckets mit exponentiell zunehmender Gro
e zu verwenden. Somit sind nur noch
O(log C ) Buckets zur Verwaltung der Elemente im Heap notig. Wie bei 2-LevelBuckets hangt die Laufzeit der \teueren\ Operationen direkt von der Anzahl der
Buckets ab.
1
1
2
4
8
z }| { z }| { z }| { z }| { z }| {
0
1
2
log C
4
8
16
pppppppppp
Randbedingung:
Schlussel 2 N0
max-Schlussel - min-Schlussel stets C
Monotonie von ExtractMin
Implementierung:
B:= dlog(C + 1)e + 1
Buckets b0::B]
Schranken fur Backets u0::B + 1] uB + 1] = 1
Bucket-Nr b nox] Index der aktuellen Buckets fur x
Invarianten:
i) ui] Schlussel in bi] ui + 1]
ii) u1] = u0] + 1 0 ui + 1] ; ui] 2i;1 fur i = 1 : : : B ; 1
Operationen:
1. Initialize : Leere Buckets erzeugen und die Bucketsgrenzen ui] entsprechend
der Invariante ii) setzen.
for i = 0 to B do bi] := od
u0] = 0 u1] = 1
for i = 2 to B do ui] := ui ; 1] + 2i;2
od
2. Insert(x): Um ein neues Element einzufugen, wird linear nach dem richtigen
Buckets gesucht, wobei die Suche beim gro
ten Bucket beginnt.
KAPITEL 1. HOHERE
DATENSTRUKTUREN
i :=B
u i > Key(x)
bi] ein
while ]
f
uge x in
do
i := i ; 1
59
od
3. DecreaseKey(x K ): Hierbei wird analog zur Prozedur Insert linear nach dem
Bucket gesucht, in den das Element mit dem veranderten Schlussel eingeordnet
werden mu
. Der einzige Unterschied besteht darin, da
die Suche in diesem
Fall beim aktuellen Bucket des Elements beginnen kann, da der Schlussel erniedrigt wird und das Element deshalb nie in einen gro
eren Bucket wandern
kann. Aus diesem Grund war es notwendig, zu jedem Element x die dazugehorige Bucketnummer in b nox] zu speichern.
i := b nox]
entferne x aus bi]
x
k
ui >k
x bi
Key( ) := co Uberpr
ufung, das alles stimmt oc
while ( ]
) do := 1 od
f
uge
in ] ein
i
i;
4. ExtractMin: Hierbei wird zuerst nach dem kleinsten nicht leeren Bucket gesucht
und der kleinste dort enthaltene Schlussel k festgestellt. Wenn der kleinste
Bucket bereits ein Element enthalt, so kann dieses ausgegeben werden und es
ist sonst nichts zu tun.
Anderfalls wird u0] auf k gesetzt und die Bucketgrenzen gema
der Invarianten neu gesetzt. Danach wird ein minimales Element aus dem kleinsten
Bucket, der nun nicht mehr leer sein kann, ausgelesen und entfernt. Von dieser \Aufraumarbeit\ sind nur der kleinste nicht-leere Bucket und die davor
liegenden leeren Buckets betroen.
i := 0
Entferne und (und gib zur
uck) ein beliebiges Element in bi]
if # Elemente in Radix-Heap = 0 then return
while bi] == do i := i + 1
k := kleinster Schl
ussel in bi]
u0] = k
u1] = k + 1
for j = 2 to i do
uj ] = minfuj ; 1] + 2j;2 ui + 1]g od
od
verteile alle Elemente aus
Beispiel:
0
1. ExtractMin
0
0
1
2
bi]
4
@
;
0
;
@
0
0
1
2
4
6
6
7
6
6
7
auf
b0] b1] : : : bi ; 1]
8
16
pppppppp
8
16
pppppppp
KAPITEL 1. HOHERE
DATENSTRUKTUREN
2. ExtractMin
0
@
;
0
;
@
1
2
6P
iP 7
8
6
6
7
4
6
6
7
8
1
P@
I
;
P
@
;
60
8
16
pppppppp
8
16
pppppppp
neu gesetzte Intervallgrenzen
bi] 6= ) Intervallgro
e 2i;1
Innerhalb bi] stehen i ; 1-Buckets zur Verfugung mit Intervallen k k +1 k +
2 k + 4 : : : k + 2i;2 k + 2i;1 bzw. hochstens ui + 1]. Da alle Schlusseln in
bi] aus dem Intervall k minfk + 2i;1 ; 1 ui + 1] ; 1g] sind, passen sie alle
in b0] b1] : : : bi ; 1].
Analyse der amortisierten Kosten:
Potential:
X
x2Radix-Heap
b nox]
Amortisierte Komplexitat:
i) Initialize : O(1) bzw. O(B )
ii) Insert : O(B )
iii) DecreaseKey :O($b nox] ; $b nox] + 1) = O(1)
P
P
iv) ExtractMin: O(B + x2bi] $b nox] ; x2bi] $b nox]) = O(B ) = O(1)
Satz: Ausgehend von einem leeren Heap betragt die worst-case (reelle) Lauf-
zeit fur k-Insert, l-DecreaseKey und ExtractMin Operatinen bei Radix-Heap:
O(k log C + l)
1.8 Union-Find-Datenstrukturen
1.8.0 Motivation
'
r r r r $
Union(T1 T2): Vereinige T1 und T2
'
$
T1 \ T2 = ' r $
x): Finde den Reprasentanten
r - r 3 6 r r r Find(
der
gr
o
ten Menge, in der sich x ger
rade
bendet.
& % %
&
&
%
KAPITEL 1. HOHERE
DATENSTRUKTUREN
61
1.8.1 Union-Find-Datenstruktur
1.8.1.1 Intrees
1. Initialisierung: x ! x: Mache x zur Wurzel eines neuen (einelementigen)
Baumes.
r
;@
r
;@
2. Union(T1 T2):
; T1 @ ; T2 @
)
1r
;;
r
T@
1@
;@
; T2 @
3. Find : Suche Wurzel des Baumes, in dem sich x bendet.
Bemerkung: Naive Implementation: worst-case-Tiefe = n
Zeit/Find = (n)
Zeit/Union = O(1)
1.8.1.2 Gewichtete Union (erste Verbesserung)
Mache die Wurzel des kleineren Baumes zu einem Kind der Wurzel des gro
eren
Baumes. Die Tiefe des Baumes ist dann O(log n)
Zeit fur Find = O(log n)
Zeit fur Union = O(1)
Es gilt auch: Tiefe des Baumes in worst-case :
(log n)
1.8.1.3 Pfad-Kompression mit gewichteten Union (zweite Verbesserung)
Problem: Folge von k Find - und Union-Operationen auf einen Operation mit n
Elementen, darunter n ; 1 Union.
Implementierung: Gewichtete Union, Find 's fur Pfad-Kompression:
s
x
s
s
@
I
y ;; @ z
@
I
;
a;
@b
@
I
;
c;
@d
;
e;
s
s
s
s
s
x
s
s
t
;
;@
I
;
;
@
y;
;
@z
@
@
;
I
@
; @
a;
@
@b
;
;@
I
;
;
@
c;
;
@d
;
;
e;
t
t
t
t
A
s
s
@
I
;
B;
@E
@
I
;
C;
@D
t
t
t
s
)
Union
Find(c)
(Pfadkompression)
)
s
x
s
sA
s s
s
s
s s
s
s
s
s
xt
3
kQ
Q
KQ
A
A QQ
Q c
y
b t Atz Q
Qt
t
;
K
A
a;
t ; AAtd e t
@
I
;
@
I
;
@ z B;
@E
@
I
;
C;
@D
y;
@
I
;
a;
@b
@
I
;
c;
@d
;
e;
KAPITEL 1. HOHERE
DATENSTRUKTUREN
62
Bemerkung: Nach der Denition ist log = minfi 1 log
log log
: : : log n} 1g.
{z
|
i;log 's
Beispiele:
log 0 = log 1 = 1
log 2 = 1
log 3 = 2 2
log 16 = 22 = 32
2
log 265536 = 222 = 5
Satz: In der obigen Situation ergibt sich eine amortisierte Komplexitat von
O(log n) pro Operation.
Beweis: Sei T 0 der (endgultige) In-Baum, der durch die Folge der Union's, ohne
die Find 's entstehen wurde (also keine Pfad-Kompression). Ordne jedem Element x
drei Werte zu:
rank(x):= Hohe des Unterbaums in T 0 mit Wurzel x
class(x):=
i 1 falls ai;1 < rank(x) ai ist (i 1)
0
falls rank(x) = 0
Dabei gilt: a0 = 0 ai = 2
2
2:: i;20 en
fur i 1
p 6p p p p p p p
p
p
p
p
p p 5 t * tp HYpHp pHp pt0p p p p p
p
p
p
p
p
p
class 2 X
p p *p p p HYpHp pHp t0 p p p p p
y Xp p p
p
4 t
p
p
p
pp
* p p p p
p
p
p
p
p
3 t
p
p
p
p
class 1 X
p
p
p
p
y Xp p
p *2 tpp *pp pp p p p p p p p p p p p
p
p
p
p
pp 1
p
X
p
pp p pp pp p p 0 ptp p *p p tp p p p p p p p p p p p p p p Xz class 0
ppppp ppppp
ppp pp
class 3
XX
y
dist(x) ist die Distanz von x zu einem Vorfahr y im momentanen Union-Find-
Baum (mit Pfad-Kompression) mit class(y) > class(x) bzw. y ist Wurzel des
Baumes.
Deniere eine geignete Potentialfunktion:
Potential := c Px dist(x) c ist eine geignete Konstante > 0
Beobachtungen:
i) Sei T ein Baum in der aktuellen Union-Find-Stuktur (mit Pfad-Kompression),
seien x y Knoten im T , y Vater von x ) class(x) class(y).
ii) Aufeinander folgende Find(x) besitzen (bis auf eine) verschiedene Kanten.
Diese Kanten sind (im wesentlichen) eine Teilfolge der Kanten in T 0 auf dem
Pfad von x zur Wurzel.
KAPITEL 1. HOHERE
DATENSTRUKTUREN
63
Amotisierte Kosten Find(x):
Sei x0 ! x1 ! x2 : : : xk = r die Pfad von x0 zur Wurzel. Kanten (xi;1 xi ) mit
class(xi;1 ) = class(xi ). Es gibt hochstens log n-Kanten (xi;1 xi ) mit class(xi;1 ) <
class(xi ). Ist class(xi;1 ) = class(xi ) und i < k (also xi =
6 r), dann ist dist(xi;1 ) vor
der Find(x)-Operation 2, nachher gleich 1.
Damit konnen die Kosten fur alle Kanten (xi;1 xi ) mit class(xi;1 )=class(xi ) aus
dem Potentialverringerung bezahlt werden und es ergeben sich amortisierte Kosten:
O(log n)
Amortisierte Kosten aller (n ; 1)-Union's zusammen:
cgp sp rp
p p
pp p p p cgsx p p p p p
T1 <
cgp sp rp 0
p p
pp p p p p p p p p
T
2
)
cg sp r0
cgp s
rp p p p
p p
p
pp p p cp gsx p p p p p T2 p p p
T1
Die gesamte Potentialerhohung durch alle Union's ist nach oben durch das Potential
von T 0 beschrankt (Beobachtung ii).
Potential(T 0 ) log
Xn
ai
X
dist(x) log
Xn
ai
X
n
2j ai
rank(x)=j =ai;1 +1
i=0 rank(x)=j =ai;1 +1
i=0
log
n
log
n
X
X
1 = O(n log n)
n ai 2a1i;1 =
i=0
i=0
3
1.8.1.4 Erweiterung
1) Bessere obere Schranke (k n) k n. Ackermannfunktion: A(m n):
A(0 n) = 2n n 0
A(m 0) = 2 m 1
A(m + 1 n + 1) := A(m A(m + 1 n))
n
m 0
?
2
2
2
2
-
2
4
4
8
;
;
6
8
s
pp
Die Ackermannfunktion steigt asymptotisch schneller als jede primitiv-rekursive
Funktion.
KAPITEL 1. HOHERE
DATENSTRUKTUREN
64
Denition: Die Klasse der primitiv rekursiven Funktionen2 (auf
den naturlichen Zahlen) ist induktiv wie folgt deniert:
1. Alle konstanten Funktionen sind primitiv rekursiv.
2. Alle identischen Abbildungen (Projektionen) sind primitiv rekursiv.
3. Die Nachfolgerfunktion auf den naturlichen Zahlen ist primitiv
rekursiv.
4. Jede Funktion, die durch Einsetzung (Komposition) von primitiv rekursiven Funktionen entsteht, ist selber primitiv rekursiv.
5. Jede Funktion, die durch sog. primitive Rekursion aus primitiv
rekursiven Funktionen entsteht, ist primitiv rekursiv. Primitive
Rekursion bedeutet, da
die denition von f (n +1 ) zuruckgefuhrt wird auf f (n ). Formaler, f mu
ein Gleichungssystem der folgenden Form erfullen:
f (0 ) = g( )
f (n + 1 ) = h(f (n ) )
wobei g h bereits primitiv rekursive Funktionen sind.
(n n) = minfi A(i i) ng
Ebenso entsprechend die untere Schranke.
2) Varianten
s
;
x;
s
2
;
;
s
;
;
s
;
;
s
sr
;
;
s
s
Gro
vater
-
s
s
-
s
s
;
;
6
6
U.Schoning, Theoretische Informatik kurz gefat, BI-Verlag, 1993 ', p. 105.
Kapitel 2
Selektieren und Sortieren
2.1 Einleitung
Gegeben: Menge S von n Elementen aus einem total geordneten Universum U ,
i 2 N, 1 i n.
Gesucht: i-kleinstes Element in S
Bekannt: Falle i = 1 n (Minimum, Maximum bestimmen)
Standardalgorithmus: n ; 1 Vergleiche
Zeigen: Diese Anzahl ist optimal:
Beweis: Interpretiere jeden Algorithmus als Turnier. Ein Spiel wird vom kleineren Element gewonnen. Beobachtung: Jedes Element au
er dem Gesamtsieger mu
mindestens ein Spiel verloren haben ) n ; 1 Vergleiche notwendig.
Nun: Bestimmung des Vize-Meisters (bzw. zweitkleinstes Element)
3
Satz: Das zweitkleinste Element kann mit n + dlog2 ne ; 2 Vergleichen bestimmt
werden.
Beweis: einem K.O. Turnier: (n ; 1) Vergleiche. Beobachtung: Das zweitkleinste
Element ist unter den "Verlierern\ gegen das Minimum zu suchen. Deren Anzahl
ist dlog2 ne. Bestimme unter diesen Elementen wiederum das Minimum zweitkleinstes Element (dlog2 ne ; 1)
3
Literatur:
Carroll, Lewis: Lawn Tennis Tournaments. St. Jones Garzette (Aug. 1, 1883),
p. 5-6. Reprinted in the complete work of lewis Carroll. New York. Modern
Librarry 1947.
Pratt, V.R. and F.F. Yao: On lower bounds for computing the i-th largest
element. Proc. 14. Anm IEEE. Swat (1973), p. 70-81.
Knuth, D. E. Vol. 3
Deniere: i = d n2 e : Median (das mittlere Element) = d n2 e - kleinstes Element.
65
KAPITEL 2. SELEKTIEREN UND SORTIEREN
66
2.2 Der Blum-Floyd-Pratt-Rivest-Tarjan SelektionsAlgorithmus
Blum, M. and RW. Floyd and V.R. Pratt and R.L. Rivest and R.E. Tarjan: Time
bounds for selection. JCSS (1973), p. 448-461.
Sei m eine kleine ungerade Zahl (etwa 5 m 21). Sei S := fa1 : : : an g. Suche
i-kleinstes Element in S . Wir betrachten folgenden Algorithmus BFPRT:
1. Teile S in mn Blocke auf, mn davon mit m Elementen
2. Sortiere jede diese Blocke
3. Sei S 0 die Menge der mn lMediane
der Blocke Bestimme rekursiv den Median
0j m
j
S
dieser Mediane (also das 2 -kleinste Element). Nenne diesen Median s.
4. Partitioniere S ; fsg in S1 := fx 2 S : x < sg, S2 := fx 2 S : x > sg.
Bemerkung: jS1 j jS2 j n4 , falls n 3m ; 1
S2 r
>s
r
r
r r
r r
r
r
r
r r
rs r
r rg g
r
r
J
^ g
r r
r r r r r g
r rg r
r
r
r r
gr rg rg
r r
r
r r r
r r
r
<s
r r
S1
5. Falls i jS1 j, bestimme rekursiv das i-kleinste Element in S1
Falls i = jS1 j + 1, gib s als Losung zuruck.
Sonst (falls jS2 j > n ; i) bestimme rekursiv das (i ;jS1 j; 1)-kleinste Element
in S2
Komplexitatsbetrachtung (# Vergleiche im worst-case):
Sei T(n) die worst-case Anzahl von Vergleichen fur jS j = n des Algorithmus BFPRT.
Sei Cm die # von Vergleichen, um m Elemente zu sortieren (z.B. C5 = 7 C11 = 26).
Es gilt:
l m
l n m
n C + jnk
3
T(n) T m + T 4 n + m
m
2
| {z } |
|{z}
{z
} | {z }
3:
5:
2:
4:
Satz: Der Selektions-Algorithmus BFPRT bestimmt das i-kleinste Element von
n Elementen mit O(n) Vergleichen (und Zeit).
Beweis: Behauptung:
T(n) c n
wobei c = c(m) konstant ist.
KAPITEL 2. SELEKTIEREN UND SORTIEREN
67
Behauptung ist ok, falls
n m + T 3 n + l n m C + j n k cn, dies gilt, falls
T(n) T m
4
m m 2
lnm
3 n c + l n m C + j n k cn j 1 (Ind.A.)
c
+
m
4
m m 2
n
, (bis auf d e b c ) mc + 34 c + Cmm + 12 c
, ; mc ; 43 c + c Cmm + 21
l
Cm
1
, c 1 ;m 3 +; 2 1
4
Schlu
bemerkung: m = 11
m
3
c = c(m) 20
2.3 Randomisierter-Median-Algorithmus
Problem: Bestimme den Median von n Elementen:
1. Wahle n 43 Elemente zufallig aus dem n Elementen aus.
2. Sortiere diese n 34 Elemente mit einem n log n-Algorithmus.
3. Setze
p1 := maxf n24 ; pn 1g-kleinsten Element der n 43 Elemente.
3
p2 := minf n24 + pn n 43 g-kleinsten Element der n 43 Elemente.
3
z
S0
}|
{
S1
z
ppp
}|
pp
p1
4. Partitioniere n Elemente in
S0 := fElemente < p1 g
S1 := fp1 Elemente p2 g
S2 := fp2 < Elementeg
n
n 43
{
p
ppp
p
z
S2
}|
{
p2
5. Falls jS0 j n2 oder jS2 j n2 oder jS1 j 4 n 43 dann wiederhole den
Algorithmus
ansonsten sortiere S1 und liefer das n2 ; jS0 j-kleinste Element davon ab.
Satz: Obiger Algorithmus
bestimmt den Median von n-Elementen mit einer er3
warteten Anzahl von 2 n + o(n) Vergleichen.
Beweis:
i) Korrektheit: klar.
KAPITEL 2. SELEKTIEREN UND SORTIEREN
68
ii) Anzahl
der Vergleichen einer Iteration:
O(n 34 log n 34 ) + Kosten der Partitionierung
Kosten der Partitionierung: zu naiv, bessere Ansatz:
S0
S1
p1
S2
p2
n-Elemente
Wahle zuerst mit der Wahrscheinlichkeit je 12 aus, ob Element x mit p1 oder
p2 verglichen wird, mache zwei Vergleiche nur, falls notig. Erwartete Anzahl
Vergleiche dafur ist gleich:
jS2 j 2 + n 1 jS2 j 1 + jS0 j + jS1 j 2 =
= n 21 jSn0 j 1 + jS1 j +
n
2 n
n
0
z
n
}|
{
1
jS0 j + jS2 j + 2 jS0 j + jS1 j + jS2 j +jS1j C =
= n2 B
@
A
n
n
B
C
= n2 (1 ; n 14 + 2 + 2 n; 41 ) = 32 + o(n)
Wir zeigen, da
der Algorithmus mit der Wahrscheinlichkeit 1 ;O(n; 14 ) nur eine
Iteration benotigt (daraus folgt, da
insgesamt Anzahl der Vergleiche 32 n + o(n)
ist). Dafur verwenden wir Hilfsmittel aus der Stochastik:
Zufallsvariable (ZV): X , Werte 2 f0 1g (binare Zufallsvariable) mit
X=
1 mit WS p
0 mit WS q = 1 ; p
Erwartungswert einer ZV: E(X ) = Px2 WertebereichWS(X = x)x
(X ist diskret, d.h. der Wertebereich von X ist endlich)
Markov-Ungleichung : WS(X t) E(tX ) fur X nicht negativ
Tschebysche-Ungleichung : WS(jX ;E(x)j t) Var(t2X )
Binomialverteilung : Seien X1 Xn unabhangige, identisch gleichverteilte Zufallsvariablen mit Wertebereich f0 1g, WS(Xi = 1) = p
X :=
n
X
i=1
Xi
X ist gema
der Binomialverteilung verteilt, Wertebereich = f0 1 ng:
WS(X = k) = nk pk (1 ; p)n;k
E(X ) = n p
Var(X ) = n p (1 ; p) = n p q:
X ist verteilt gema
der Binomialverteilung mit den Parametern n und p, in
Zeichen X B(n p).
KAPITEL 2. SELEKTIEREN UND SORTIEREN
69
wird wiederholt, falls jS0 j n2 . Dies passiert gdw.
Auswahl der n 34 Elemente
p
3
1
wir hochstens 2 n 4 ; n Elemente aus der Halfte der aller Elemente Median
auswahlen.
Was ist also die Wahrscheinlichkeit dafur, da
keine neue Auswahl der n 43 Elemente
stattnden mu
?
Setze Binare Zufallsvariable fur jedes Xi Xn mit:
Xi =
1 ,falls Element i ausgewahlt und in der unteren Halfte der Wert liegt
0 ,sonst
P
X = Xi binomialverteilt mit Parametern n und 12 n; 14
1
E(X ) = 21 n 34 , Var(X ) = n 12 ; 4 (1 ; 21 n; 14 ) = 21 n 34 (1 ; o(1))
Die Wahrscheinlichkeit hierbei ist:
p
p
WS(jS0 j n2 ) = WS(X 12 n 34 ; n) WS(jX ; E(X )j n) 1 n 43 (1 ; o(1)) 1 1
2 n
2 n; 4 (1 ; o(1))
Die Wahrscheinlichkeit fur den Fall, da
man von vorne anfangen mu
:
1
1
;
4
WS ) 1 ; 2 n (1 ; o(1))
Die anderen beiden Wahrscheinlichkeitsbedingungen (WS(jS2 j n2 ) und WS(jS1 j 4 n 43 )) ergeben analoge Abschatzungen ) Widerholung mit WS O(n; 14 ) 3
2.4 Der Schonhage-Paterson-Pippenger-Median-Algorithmus
Denition: Sei k 2 Nnf0g: Pk ist die folgende partielle Ordnung:
k
s@: : : s: :;: s
@g
s;
;@
s;: : : s: :@: s
z
}|
{
|
{z
}
k
2k + 1 Elemente
s
s@ ;s
@g
s;
;
s
;
s
;
s; P3
Spezielle Binomialbaume mit "Zentren\.
Denition:
1. Der Baum H0 besteht aus einem Knoten und dieser ist auch das
Zentrum.
2. H2h (h > 0) besteht aus zwei H2h;1 , deren Zentren durch eine neue
Kante verbunden sind. Das Zentrum des H2h ist das kleinere der
beiden Zentren der H2h;1 :
KAPITEL 2. SELEKTIEREN UND SORTIEREN
70
3. H2h+1 (h 0) besteht aus zwei H2h , deren Zentren durch eine neue
Kante verbunden sind, sein Zentrum ist das gro
ere dieser beiden
Zentren.
H0
H1
Hg
s0
H2
H3
sg s
;s s
s
;
H0
;
;s ss
s
H4
s s
;s s
;
s ;s
gss ;
;s s s s
;
;
s s
;
s s
gs
sg s
s s
' ss ss $
gss ss ss ss gs
# & % gs
"!
Das Zerlegungslemma:
;
; ;
;
;
; A
;
s
s
;
A sA
H2
s
H0 H1
H3
A
>
<
(Zentrum)
(Zentrum)
Abtrennung von
Wildwuchs
a) Hh hat 2h Knoten, es werden 2h ; 1 Vergleiche benotigt, um Hh zu konstruieren.
b) H2h kann zerlegt werden in
sein Zentrum
KAPITEL 2. SELEKTIEREN UND SORTIEREN
71
eine Menge fH1 H3 : : : H2h;1 g von disjunkten Teilbaumen, deren Zen-
tren alle gro
er sind als das Zentrum von H2h .
eine Menge fH0 H2 H4 : : : H2h;2 g von disjunkten Teilbaumen mit Zentren kleiner als das von H2h .
c) H2k+1 kann so zerlegt werden, da
die Zusammenhangskomponente des Zentrums genau 2k Knoten dem Zentrum enthalt, indem hochstens 2k+1 ; 1
Kanten entfernt werden.
H2k kann so zerlegt werden, da
die Zusammenhangskomponente des Zentrums genau 2k Knoten enthalt, die alle dem Zentrum sind, indem hochstens
2k ; 1 Kanten entfernt werden.
d) Falls k 2h ; 1, dann kann H2h so zerlegt werden, da
die Zusammenhangskomponente des Zentrums genau 2k +1 Elemente enthalt, von denen k gro
er
und k kleiner als das Zentrum sind () Pk ).
Dazu genugt es, hochstens 3k + 2h Kanten zu entfernen. Die restlichen Zusammenhangskomponenten sind wieder Hi .
Bemerkung: Bei jedem Konstruktionsschritt wird ein Vergleich durchgefuhrt, um
zu bestimmen, welcher der beiden Teilbaume das kleinere Zentrum hat. Im Algorithmus von Schonhage, Paterson und Pippenger werden aus Teilstucken Hr gro
ere
Baume Hr+1 zusammengebaut, wodurch schrittweise eine partielle Ordnung auf den
Eingabewerten bestimmt wird. Wurde ein Baum H2h hinreichender Gro
e hergestellt, so wird er durch Zerlegung in einen Baum umgewandelt, der nur noch sein
altes Zentrum, sowie k daruberliegende und k darunterliegende Elemente enthalt,
wobei k 2h ; 1. Im folgenden Beispiel wollen wir H4 zerlegen und wahlen k = 3:
s
;
; s
;s
s s ;
g
s
;
s
s s
; s
H4
s
s
;;
s
s
s
s
Um einen H4 derart zu zerlegen, mussen wir 5 Kanten aufbrechen. Dabei werden
drei H0 , ein H1 sowie ein H2 abgespalten.
ss
s
s
g
;
s
;
;; gs gs gss
s
s
s
s
H1 H0
s
H2
s g
g
s
H0 H0
U brig bleibt die gewunschte Struktur mit k Knoten uber dem Zentrum und k unter
dem Zentrum, wodurch eine partielle Ordnung auf 2k + 1 Eingabewerten bestimmt
wurde:
KAPITEL 2. SELEKTIEREN UND SORTIEREN
k
72
s@: : : s: :;: s
@s;
s;: :;: @s: :@: s
z
}|
{
|
{z
}
k
2k + 1 Elemente
Die bei der Zerlegung angefallenen Reststucke werden beim Aufbau weiterer Baume
benutzt. So geht das bereits angesammelte Wissen uber die Ordnung der Elemente
nicht verloren. Beweis der Teile a) bis d) des Zerlegungslemmas:
a) Lemma 1: Hr hat 2r Knoten, es werden 2r ; 1 Vergleiche benotigt, um Hr
aufzubauen.
Beweis: In jedem der r Konstruktionsschritte wird die Anzahl der Knoten
verdoppelt. Da wir mit einem Knoten beginnen, hat Hr folglich 2r Knoten.
Die Anzahl der notwendigen Vergleiche Cr unterliegt folgender Rekursionsgleichung (r 1): Cr = 1+2Cr;1 und C0 = 0. Damit folgt sofort Cr = 2r ;1. 3
b) Lemma 2: Hr kann in folgende disjunkte Bereiche unterteilt werden:
{ sein Zentrum,
{ eine Reihe H1 , H3, ..., Hr;1 (r gerade) bzw. ..., Hr;2 (r ungerade) von
Unterbaumen, deren Zentren uber dem von Hr liegen,
{ eine Reihe H0 , H2, ..., Hr;2 (r gerade) bzw. ..., Hr;1 (r ungerade) von
Unterbaumen, deren Zentren unter dem von Hr liegen.
Beweis: durch Induktion uber r. Induktionsanfang: fur H0 gilt die Behauptung. Induktionsannahme: die Behauptung gelte fur Hr;1.
1. Sei r = 2h h > 0. H2h besteht aus zwei H2h;1 , wobei das kleinere der
beiden alten Zentren das neue Zentrum z bildet. Wende auf den H2h;1 ,
der z enthalt, die Induktionsannahme an. Wir konnen diesen Unterbaum
also in z , sowie H1 , H3 , ..., H2h;3 (Zentren uber z ) und H0 , H2 , ..., H2h;2
(Zentren unter z ) partitionieren. Zusammen mit dem H2h;1 , dessen Zentrum uber z liegt, ergibt sich die Induktionsbehauptung fur H2h .
2. Sei r = 2h + 1 h 0. H2h+1 besteht aus zwei H2h , wobei das gro
ere
der beiden alten Zentren das neue Zentrum z bildet. Wende auf den H2h ,
der z enthalt, die Induktionsannahme an. Wir konnen diesen Unterbaum
also in z , sowie H1 , H3 , ..., H2h;1 (Zentren uber z ) und H0 , H2 , ...,
H2h;2 (Zentren unter z ) partitionieren. Zusammen mit dem H2h , dessen
Zentrum unter z liegt, ergibt sich die Induktionsbehauptung fr H2h+1 .
3
Wir bezeichnen im folgenden mit H2;h den Baum, der entsteht, wenn wir H2h so
zerlegen, da alle Elemente oberhalb des Zentrums wegfallen. Mit H2+h+1 bezeichnen
wir den Baum, der entsteht, wenn wir H2h+1 so zerlegen, da alle Elemente unterhalb
des Zentrums wegfallen.
c) Lemma 3: H2;h und H2+h+1 haben jeweils 2h Knoten. Bei der Herstellung
aus H2h bzw. H2h+1 werden 2h ; 1 bzw. 2h+1 ; 1 Kanten aufgebrochen. Die
wegfallenden Teile haben die Form Hs s < 2h bzw. s < 2h + 1.
KAPITEL 2. SELEKTIEREN UND SORTIEREN
73
Beweis: Durch Induktion uber r. Induktionsanfang: fur H0 und H1 gilt die
Behauptung. Induktionsannahme: die Behauptung gilt fur alle Hp p < r.
1. Sei r = 2h h > 0. Wir betrachten die Partitionierung von H2h mit Zentrum z wie in Lemma 2. Die Unterbaume H1 , H3 , ..., H2h;1 haben ihre
Zentren oberhalb von z . Wir trennen sie von H2h , indem wir h Kanten aufbrechen. Die abgetrennten Teile haben oensichtlich die Form
Hs s < 2h. Bei den Unterbaumen H0 , H2 , ..., H2h;2 , mit Zentren unterhalb von z , wenden wir jeweils die Induktionsannahme an, d.h. wir
erzeugen H0; , H2;, ..., H2;h;2 . Als Ergebnis erhalten wir H2;h . Damit gilt
fur die Zahl der aufzubrechenden Kanten K ;(2h) zur Herstellung von
H2;h :
K ;(2h) = h +
hX
;1
i=0
K ;(2i) I:A:
= h+
hX
;1
i=0
(2i ; 1) =
hX
;1
i=0
2i = 2h ; 1:
Fur die Zahl E ; (2h) der Elemente in H2;h gilt:
E ; (2h) = 1 +
hX
;1
i=0
E ; (2i) I:A:
= 1+
hX
;1
i=0
2i = 1 +
h
X
i=1
2i;1 = 2h :
| {z }
2h ;1
2. Sei r = 2h + 1 h > 0. Wir betrachten die Partitionierung von H2h+1 mit
Zentrum z wie in Lemma 2. Die Unterbaume H0 , H2 , ..., H2h haben ihre
Zentren unterhalb von z . Wir trennen sie von H2h+1 , indem wir h + 1
Kanten aufbrechen. Die abgetrennten Teile haben oensichtlich die Form
Hs s < 2h + 1. Bei den Unterbaumen H1 , H3 , ..., H2h;1 , mit Zentren
oberhalb von z , wenden wir jeweils die Induktionsannahme an, d.h. wir
erzeugen H1+ , H3+ , ..., H2+h;1 . Als Ergebnis erhalten wir H2+h+1 . Damit
gilt fur die Zahl der aufzubrechenden Kanten K + (2h +1) zur Herstellung
von H2+h+1 :
h
X
K +(2h + 1) =h + 1 + K +(2(i ; 1) + 1)
i=1
h
h
X
X
I:A:
= h + 1 + (2i ; 1) = 1 + 2i
i=1
i=1
hX
+1
=1 + 2i;1 ;1 = 2h+1 ; 1:
i=1
| {z }
2h+1 ;1
Fur die Zahl E + (2h + 1) der Elemente in H2+h+1 gilt:
E + (2h + 1) = 1 +
h
X
i=1
E + (2(i ; 1) + 1) I:A:
= 1+
h
X
i=1
2i;1 = 2h:
| {z }
2h ;1
3
KAPITEL 2. SELEKTIEREN UND SORTIEREN
74
d) Lemma 4: Falls k 2h ; 1, dann kann H2h so zerlegt werden, da
die
Komponente des Zentrums genau 2k + 1 Elemente enthalt, k davon uber und
k unter dem Zentrum. Dazu mussen 3k + 2h Kanten entfernt werden. Die
entfernten Teile sind von der Form Hs s < 2h.
Beweis: Betrachte die Binardarstellung von k = k020 + k121 +::: + kh;12h;1
und die Partitionierung von H2h mit Zentrum z wie in Lemma 2.
{ Fur jedes i mit ki = 1, betrachte H2i+1 aus der Sequenz H1, H3, ...,
H2h;1 von Unterbaumen deren Zentren oberhalb von z liegen und schneide alle Elemente aus H2i+1 , die kleiner als sein Zentrum sind (bilde
also H2+i+1 ). Dazu mussen hochstens 2k Kanten aufgebrochen werden,
denn jedes ki = 1 steht fur 2i in k, kostet uns aber nach Lemma 2
K + (2i + 1) = 2i+1 ; 1 Kanten, also:
hX
;1
i=0
ki K + (2i + 1) 2k:
Fur jedes i mit ki = 0, schneide H2i+1 ganz weg. Dabei werden hochstens
h Kanten aufgebrochen. Genau k Elemente oberhalb von z bleiben zuruck,
da jedes ki = 1 fur 2i in k steht, und ein H2+i+1 genau E + (2i + 1) = 2i
Elemente enthalt, also:
hX
;1
i=0
ki E + (2i + 1) = k:
{ Fur jedes i mit ki = 1, betrachte H2i aus der Sequenz H0, H2, ..., H2h;2
von Unterbaumen, deren Zentren unterhalb von z liegen und schneide
alle Elemente aus H2i , die gro
er als sein Zentrum sind (bilde also H2;i ).
Dazu mussen hochstens k ; 1 Kanten aufgebrochen werden, denn jedes
ki = 1 steht fur 2i in k und kostet uns nach Lemma 3 K ;(2i) = 2i ; 1
Kanten, also:
hX
;1
i=0
ki (2i ; 1) k ; 1:
Fur jedes i mit ki = 0, schneide H2i ganz weg. Dabei werden hochstens h
Kanten aufgebrochen. Genau k Elemente unterhalb von z bleiben zuruck,
da jedes ki = 1 fur 2i in k steht, und ein H2;i genau E ; (2i) = 2i Elemente
enthalt, also:
hX
;1
i=0
ki E ; (2i) = k:
Damit ergibt sich fr die Gesamtanzahl aufzubrechender Kanten eine obere
Schranke von 3k + 2h. Lemma 3 liefert uns daruberhinaus die gewunschte
Aussage ber die Form der abgetrennten Teile.
3
Betrachte H2h
"gro
er\: H2h;1 H2h;3 : : : H1
"kleiner\: H2h;2 H2h;4 : : : H0
ss s s
gss ss ss ss
ss ss
KAPITEL 2. SELEKTIEREN UND SORTIEREN
75
;;
;; H h;
;;H
H2h
2
;
;
2
2h;2
U(h) := Anzahl der Elemente in H2h Zentrum: U(h) = 2U(h ; 1) = 2hU(0) = 2h
D(h) := Anzahl der Elemente in H2h Zentrum: D(h) = 2D(h ; 1) = 2hD(0) = 2h
Anzahl der Kanten, die entfernt werden mussen:
Cu (h) 2 + 2Cu (h ; 1)
= 2 + 4 + 23 + : : : + 2h
= 2h+1 ; 2
Cd(h) 1 + 2Cd (h ; 1)
= 2h ; 1
Kette von Pk 's:
9
>
>
>
>
=
>
>
>
>
CH 2h+1 ; 2 + 2h ; 1 3 2h
J ps
p J top
p
p
p
J
J sp p p p p p
Pk
J
J s
bottom J
J
Pk
|
J
Pk
{z
t
}
Gesamtzahl der Elemente:
n
t(2k + 1) in den Pk 's
r = n ; t(2k + 1) Rest
Wenn r < t ; 1, dann wissen wir, da
top gro
er ist als
k + (t ; 1)(k + 1) > k + (k + 1) 2nk++12 ; 1 = n ;2 1
) top > Median
j
k
k := n 41
h sdg. 2h;1 k < 2h
KAPITEL 2. SELEKTIEREN UND SORTIEREN
¾
76
¾ $ %
"
!
"
& #
Deniere: r := Anzahl der noch im H2h Produktionsproze
steckenden Elemente.
2hP
;1 2h
(fur jedes i < 2h hochstens ein Hi ) r = 2 ; 1)
i=0
R := Anzahl der im letzten Schritt zu sortierenden Elemente. Es gilt: t r +1, und
damit
R = t(2k + 1) + r 22h(2k + 1) + 22h ; 1
m := Gesamtzahl der im Algorithmus produzierten Pk 's.
m = t + 2 2(nk;+R1) = t + nk ;+ R1
Gesamtzahl der vom Algorithmus durchgefuhrten Vergleiche =
1. Anzahl der Kanten in allen Pk 's
2. + Anzahl der Kanten, die geloscht werden, um die Pk 's zu formen
3. + Anzahl der Kanten, die zum Schlu
in ubriggebliebenen Hi 's (i < 2h)
stecken
4. + Anzahl der Vergleiche, um jedes Zentrum der Pk 's in die (sortierte) Kette
einzufugen
5. + Anzahl der Vergleiche, um die zum Schlu
ubriggebliebenenen R Elemente
zu sortieren
3
2
nk ;+ R1 + t
n
7
6
7 + log +
6 2 + 3 + 2 + log
5 | {z } |{z}
4|{z} | {z }
2
+
1
{z
}
|
3
1
2
5
k
k
h
k
4
R
R
r
KAPITEL 2. SELEKTIEREN UND SORTIEREN
77
k
j
k := n 14 , h so da
2h;1 k < 2h
Damit r = O(k2 )
t = O(k2 ) zum Schlu
R = O(k3 ), und damit die
Anzahl der Vergleiche = T(n) 5n + o(n)
Verbesserte Version: T (n) = 3n + o(n)
Dor/Zwick: 2 95n + o(n)
Bester bekannter Algorithmus: K.Zwick ( 2:95n + o(n) )
Literatur: SPP: Finding the Median. JCSS 13(1976) p.84-199
2.5 Eine untere Schranke fur die Medianbestimmung
Satz: Jeder
otigt in worst-case min (vergleichsbasierte) Medianalgorithmus ben
destens 32n ; 2 Vergleiche
Beweis: Gegenspielerargument (adversary argument)
n Elemente, o.B.d.A. n ungerade, alle Elemente paarweise verschieden. Die Menge
aller Elemente wird in drei Teilmengen partitioniert: U enthalt die Kandidaten fur
den Median, G enthalt Elemente, die sicher gro
er als der Median sind und L enthalt
Elemente, die sicher kleiner als der Median sind. Anfangs sind alle Elemente in U .
Der Algorithmus stellt nun Fragen der Form ai < aj . Der Gegenspieler gibt konsistente Antworten, die den Algorithmus jedoch dazu zwingen, moglichst viele Fragen
zu stellen bevor die Antwort feststellen kann(d.h. U soll moglichst ungeordnet blei?
ben). Durch die (konsisten!) Antworten des Gegenspielers auf die \ <\-Queries des
Algorithmus entsteht ein DAG. Gegenspieler halt DAG \einfach\.
(Angenommen y > z und y > x ) y soll sehr gro
sein ) y ! G)
G
U
a1
an
| {z }
saj
s ai
ai < aj
L
G
U
L
a1
{z }
|
%
an
s
bs
G
;@
;
@
s
KAPITEL 2. SELEKTIEREN UND SORTIEREN
G
n +2 1 ; 1
U
a1
L
78
s s Solange ein Element unverglichen ist,
s ist nicht klar, welches Median ist.
an
| {z }
n +2 1 ; 1
Solange jLj jGj < n+1
2 , kann der Algorithmus annehmen, da
der Median in U
ist. Solange U mindestens zwei unverglichene Elemente und keine Zusammenhangskomponente mit > 2 Elementen enthalt, kann der Algorithmus den Median nicht
bestimmen.
Strategie des Gegenspielers: Zwei Phasen
?
Erste Phase: Query sei x < y:
i) x y 2 G bzw. x y 2 L: irgendeine konsistente Antwort
ii) x 2 G ^ y 2 L U (bzw. x 2 L ^ y 2 G U ): Antwort: y < x (bzw. x < y).
iii) x y 2 U
!
Die erste Phase endet, wenn jLj = n;2 1 oder jGj = n;2 1 . Wahrend der Phase 1
enthalt U mindestens zwei (in U ) maximale und mindestens zwei (in U ) minimale
Elemente (bzgl. des DAGs). ) Wahrend Phase 1 kann der Algorithmus den Median
mit Sicherheit nicht bestimmen.
Der Gegenspieler beginnt mit Phase 2:
jLj wird n;2 1 oder jGj wird n;2 1
o.B.d.A.:
jLj = n ;2 1
KAPITEL 2. SELEKTIEREN UND SORTIEREN
79
Der Gegenspieler zwingt nun den Algorithmus, das minimale Element in U bzgl.
der gesamten totalen Ordnung zu bestimmen (da dieses unter den Vorgaben der
Median ist).
Analyse:
C := Anzahl der Vergleiche
P := Anzahl der Paare in U
i) In der Phase 1 gilt folgende Invariante: C ; P + 2jU j 2n
Beweis: vollstandige Induktion:
Induktionsanfang: 0 ; 0 + 2n 2n
Induktionsschritt: Gema
der Tabelle.
3
ii) Sei C # der Vergleiche am Ende der Phase 1, U die am Ende der Phase 2:
In der Phase 2 werden noch jU j ; 1 ; jP j Vergleiche notig. Die Anzahl der
Vergleiche fur alle Phasen:
Anzahl der Vergleiche C + jU j ; 1 ; jP j.
Am Ende der Phase 1 gilt ja C 2n + jP j ; 2jU j (wg. Invariante).
) Anzahl der Vergleiche:
2n + jP j ; 2jU j + jU j ; 1 ; jP j = 2n ; jU j ; 1
32 n ; 32 =
#
$
3
1
= 2 n ; 2 da jU j n +
2
3
2.6 Eine bessere untere Schranke
Literatur: Samuel W. Bent, John W. John: \Finding the median requires 2n comparisons." Proceedings of the 17th Annual ACM Symposium on Theory of Computing 1985, p.213{216.
Satz: Sei T ein Entscheidungsbaum hf;ur die Bestimmung
des i-kleinsten von n
i
n
1
2
verschiedenen Elements, mit i log i n;i+1 + 3. Dann gilt, mit
s
% &
p := 2 log ni n ; 1i + 1 + 3 ; 2
% &
2n;p
Hohe(T ) log ni n ;
i+1
Bemerkung: i = n2 ! ;d nn2 e O( p2nn ) ) Hohe(T ) 2n ; o(n) (untere Schranke
fur Median).
Beweis: Gegenspielerargument + Abzahlargument:
T hat viele Blatter\, A Teilmenge der Schlussel, jAj = i
T" A Teilbaum von T , alle Blatter von
TA sind auch Blatter von T .
Zu zeigen: TA hat viele Blatter. (;ni Moglichkeiten, TA's zu konstruieren, Anzahl
Blatter in TA: 2n;p , jedes Blatt von T kommt in hochstens n ; i + 1 TA 's vor)
KAPITEL 2. SELEKTIEREN UND SORTIEREN
80
Beobachtungen: Jedes Blatt w von T liefert folgende Informationen:
liefert
answer(w) ;;;!
i-kleinstes Element x
liefert
little(w)
;;;! i ; 1 Elemente < x
liefert
big(w)
;;;!
n ; i Elemente > x
Wahle A als beliebige Teilmenge der n gegebenen Schlussel, mit jAj = i. Wir
geben fur den Gegenspieler eine Strategie an, welche dazu fuhrt, da
wir durch
Zurechtschneiden aus T einen Baum TA konstruieren konnen, so da
gilt:
TA ist Binarbaum
jedes Blatt von TA ist auch Blatt von T (keine zus. Blatter durch Abschneiden)
fur jedes Blatt w von TA gilt: little(w) A
Setze A* das Komplement von A,
s
% &
r := log ni n ; 1i + 1 + 3
s := r ; 1
Es gilt: p = r + s ; 1
Die Konstruktion (das \Zurechtstutzen\) von T erfolgt in zwei Phasen:
r
r
;@
PPP
P
P
r
;
r Wurzel
r xi <? yi
r xj <? yj
rx
;
@
@
r
'
$
r
r Ar
r gppr
A c(x) p A*
pp
grp grp Agrp
ppp p p p p p p
pp %
&
pp ;;;;;; Vergleiche
pp
pp p p
p p pp $
pp p p
'
p p pp pp p p
pr pr
pr
r
A
A
A
C(
x
)
# = s(x a)
r
Ar
r
fur a 2 A fest
&
%
Erste Phase von der Wurzel nach unten (Breitensuche)
Betrachte Knoten x. Deniere:
C(x) sind die Elemente a 2 A fur die es kein b 2 A gibt und einen Knoten
auf dem Pfad von der Wurzel von T zu x, an dem kein Vergleich mit einem
anderen Element b 2 A erfolgt ist mit dem Ergebnis a < b.
KAPITEL 2. SELEKTIEREN UND SORTIEREN
81
c(x) sind entsprechend die in x bekannten Minima in A*.
s(x a) (a 2 A) ist die Anzahl der Elemente 2 A* (genauer: 2 c(x)) mit denen
a auf dem Pfad von Wurzel von x verglichen wurde.
Regeln fur Phase 1:
Es werden in Knoten x die Elemente a und b verglichen:
Regel 1.1: Falls a 2 A und b 2 A behalte x in TA bei.
Regel 1.2: Falls a 2 A* und b 2 A* behalte x in TA bei.
Regel 1.3: Sei o.B.d.A. b 2 A*, a 2 A. Ersetze den Unterbaum in T mit Wur-
zel x mit dem Unterbaum, dessen Wurzel das Kind von x ist, das dem Ergebnis
entspricht (d.h. lasse den Vergleich a < b aus, nach Voraussetzung A < A*).
Phase 1 lauft solange jC(x)j r. Ein Knoten auf einem Pfad in T von der Wurzel,
bei dem jC(x)j erstmals = r wird, hei
t kritisch.Jeder Pfad in T von der Wurzel zu
einem Blatt enthalt genau einen kritischen Knoten.
Betrachte in TA einen Pfad von der Wurzel zu einem kritischen Knoten x. Sei y
ein Knoten auf diesem Pfad, z sein Kind.
r Wurzel
ry
rz
rx
Dann gilt:
C(y) + c(y)
C(z ) + c(z )
jC(z )j + jc(z )j jC(y)j + jc(y)j ; 1
Da jC(Wurzel)j = jAj = i und jc(Wurzel)j = jA*j = n;i, mussen
uberhalb eines jeden kritischen Knoten x mindestens
i ; jC(x)j + n ; i ; jc(x)j = n ; r ; jc(x)j
Vergleiche erfolgen. Von jedem kritischen Knoten abwarts arbeitet der Gegenspieler nach einer Strategie fur Phase zwei. Sei
x ein solcher kritischer Knoten. Dann ist jC(x)j = r.
Phase 2: Sei a 2 C(x) ein Element mit minimalem s(x a).
'
$
rA r r
A
rpgp Arppg p rpg r r r A*
c(x)
&p p p ppp p p p
%
p p pp p p
$
' pp p p
p pp p
r
r r r
AAa
A # = s(x a)
C(
x
)
r
Ar
r
fur a 2 A fest
&
%
Fall 1: s(x a) s.
Betrachte irgendeinen Pfad von der Wurzel durch x zu einem Blatt w. Jeder solche Pfad mu
mindestens n ; 1 Vergleiche enthalten, um answer(w)
KAPITEL 2. SELEKTIEREN UND SORTIEREN
82
zu verizieren: n ; i, fur die answer(w) sich (direkt oder indirekt) als das
kleinere Element ergibt, und i ; 1, wo es sich als das gro
ere ergibt.
Damit sind (r ; 1)s Vergleiche redundant (namlich alle die, die zwischen
Elementen aus C(x) n fanswer(w)g und Elementen in A* erfolgt sind).
Also:
Tiefe(T ) n ; 1 + s(r ; 1)
= n ; r ; s ; 1 + (s + 1)r
"
;n
#
= n ; r ; s + 2 + log n ; ii + 1
% n;p &
> log ni n ;2 i + 1
In diesem Fall folgt also die Behauptung direkt!
Fall 2: s(x a) < s
Fall 2.1:
$
'
rA r
A
r
Apg
rp gppr r r r A*
c(x)
& p p p ppp
%
p p pp
S
' p p pp
$
rA p ppr
r r
A
A # = s(x a)
C(
x
)
r
Ar X
r XXr
fur a 2 A fest
&
%
jc(x)j p. Sei S := c(x) fagnElemente, die in s(x a) gezahlt werden.
Der Gegenspieler antwortet nun so, da
das Ergebnis das kleinste Element in S wird. Ist w ein Blatt in TA unter x, so ist little(w)= A ; fag
Der Entscheidungsbaum T wird also gema
folgender Regeln gestutzt
(sei y der aktuelle Knoten und seien a und b die beiden Elemente, die in
y verglichen werden):
Regel 2.1: falls a b 2 S , dann bleibt y erhalten.
Regel 2.2: andernfalls, sei oBdA. a 2 A n S oder b 2 A* n S ersetze y
mit seinem Unterbaum durch das Kind von y und dessen Unterbaum,
das der Antwort von a < b entspricht.
Also, da uberhalb des kritischen Knoten x keine zwei Elemente in S
verglichen wurden, mu
der Unterbaum von TA unterhalb von x Tiefe
jS j ; 1 haben.
Zusammen mit Phase 1 ergibt sich eine Tiefe von TA:
n ; r ; jc(x)j + jS j ; 1
n ; r ; jc(x)j + jc(x)j + 1 ; (s ; 1) ; 1
=n;r;s+1
=n;p
KAPITEL 2. SELEKTIEREN UND SORTIEREN
83
Fall 2.2: jc(x)j < p. S := C(x)
Regeln so, da
der Algorithmus als Antwort das Maximum von S bestimmt. Tiefe von TA :
n ; r ; jc(x)j + jS j ; 1
n ; r ; (p ; 1) + r ; 1
=n;p
In Wirklichkeit: Jeder Pfad in TA von x zu Blatt hat mindestens die Lange n ;
p. Also entha;lt jedes TA mindestens 2n;p Blatter (von T ). Alle TA's zusammen
enthalten ni 2n;p Blatter von T , wobei jedes Blatt von T hochstens n ; i + 1
mal vorkommt: Sei w Blatt von T , dann ist little(w) eindeutig bestimmt und mu
,
falls TA w auch enthalt, little(w) A sein. Fur das Element; in A; little(w) gibt es
nh; i +1 Moiglichkeiten ) Anzahl Blatter von T n;1i+1 ni 2nn;p ) Tiefe(T ) ; n;p
log ni n2;i+1 .
3
Einige Referenzen:
1. L. Hyal: Bounds for selection. SIAM J.Compute 5(1976), p.109-114.
2. S. Beut and John W. John: Finding median requires 2n compression. Proc
17. STOC (1985), p.213-216.
3. John Welliaveetil John: A new lower bound for the set-partitioning problem.
SIAM J. Compute 17 (1988), p. 640-647.
4. Doris Dor and Uri Zwick: Median selection requires (2 + ")n compression.
Proc 37 FOCS (1996), p. 125-134
5. Doris Dor and Uri Zwick: Selecting the median Proc 6 SODA (1995), p. 28-37
2.7 Untere Schranke fur (vergleichbasiertes) Sortieren
?
Gegeben n-Schlusseln, Queries ai < aj . Dies entspricht einen Entscheidungsbaum.
ai <r aj
ja;@nein
r
r
@
;
R
;
;@
ak < ai ;
; @
ja;@nein
@
;
R
r
r
;@
; @
0
(Permutationen)
r
;@
;
@000
00
Beobachtung: Jede Permutation 2 Sn kommt in mindestens einem Blatt des
Entscheidungsbaums vor (jSn j = n!).) Tiefe des Entscheidungsbaums log2 n!.
KAPITEL 2. SELEKTIEREN UND SORTIEREN
84
p ; Stirling: n! 2n ne n
hp
n i
) Also Tiefe log2 2n ne = n log2 n ; n log2 e + 12 log 2n
= n log2 n ; O(n)
Satz: Jeder Vergleichsbasierter Sortieralgorithmus benotigt mindestens
n log2 n ; O(n)
Vergleiche.
2.8 Bucketsort im Schnitt
Gegeben n-Schlusseln 2 0 1]. Schlusseln gleichverteilt. Um diese zu sortieren:
1. Initialisiere Buckets b0 b1 bn
2. Lege ai in Bucket dn ai e
3. Sortiere Schlussel innerhalb jedes Buckets
4. Kankataniere Buckets
Satz: Wird zum Sortieren Sortieralgorithmus mit der Zeitkomplexitat von O(n2 )
verwendet, dann hat obiger Bucketsort-Algorithmus im Durchschnitt eine lineare
Laufzeit.
Beweis: Sei ni die Anzahl der Elemente im Bucket bi (nach Schritt 2). Die Schritte
1,2 und 4 benotigen zusammen die Zeit O(n). Die Zeit fur Schritt 3 betragt:
n
X
O(
i=0
n2i )
P
Die Erwartungswert fur
E
n
X
i=0
n2
i
!
c
n2i la
t sich folgenderma
en abschatzen:
X
0i<j n
0
WS(ai und aj enden in gleichen Bucket)
1
1 A = O(n):
= c@
0i<j n n + 1
X
3
2.9 Quicksort
Wie bei vielen anderen Sortierverfahren (Bubblesort, Mergesort, usw.) ist auch bei
Quicksort die Aufgabe, die Elemente eines Array a1::n] zu sortieren. Quicksort ist
zudem ein Divide-and-Conquer-Verfahren.
Devide: Wahle ein Pivot-Element p (z.B. das letzte) und partitioniere al::r] gema
p in zwei Teile al::i ; 1] und ai + 1] (durch geeignetes Vertauschen der Elemente),
wobei anschlie
end ai] = p.
Conquer: Sortiere al::i ; 1] und ai + 1::r] rekursiv.
KAPITEL 2. SELEKTIEREN UND SORTIEREN
85
Algorithmus:
a l r)
proc qs(
f
lr
then return fi
if
#ifdef Variante 2
vertausche random( )] mit ] #endif
:= ] := := repeat
while
and ]
do + + od
while
and
] do
od
if
then vertausche ] und ]
until == vertausche ] und ]
qs(
1)
qs(
+ 1 )
a
l r
ar
p ar
i lj r
g
i<j
i<j
i<j
i j
ai
a l i ;
a i r
ai p
paj
i
j;;
ai
aj
ar
Bemerkung: Der oben formulierte Algorithmus benotigt pro Durchlauf in der Regel n +1 Schlusselvergleiche. Lediglich wenn die beiden Indizes zusammenfallen (was
nur bei einem Pivotduplikat passieren kann), benotigt er nur n Vergleiche. Durch
geschicktes Einstreuen von if-Abfragen kann man auch in jedem Fall mit n ; 1
Schlusselvergleichen auskommen.
Komplexitat von Quicksort:
Best-case-Analyse: Quicksort lauft naturlich am schnellsten, falls die Partitio-
nierung moglichst ausgewogen gelingt, im Idealfall also immer zwei gleichgro
e
Teilintervalle entstehen, das Pivot ist dann stets der Median.
n
Anzahl der Schlusselvergleiche: log
i=1 (n + 1) = log n(n + 1) n log n
P
Worst-case-Analyse: Z.B. bei eine aufsteigend sortierte Eingabe.
Anzahl der Schlusselvergleiche: (n2 )
Average-case: Da die Laufzeit von Quicksort sehr stark von den Eingabedaten
abhangt und sich demnach keine scharfe allgemeingultige Schranke angeben
la
t, kann man die Frage stellen, wie lange der Algorithmus \im Mittel\ zum
sortieren von n Elementen braucht. Um jedoch uberhaupt eine derartige Analyse durchfuhren zu konnen, mu
man zuerst die genaue Bedeutung von \im
Mittel\ festlegen. Eine naheliegende Annahme ist, da
alle moglichen Permutationen der Eingabedaten mit gleicher Wahrscheinlichkeit auftreten.
Satz: Die durchschnittliche Anzahl von Schlusselvergleichen betragt unter
der Annahme , da
alle Permutationen fur die Eingabe gleichwahrscheinlich
sind, hochstens:
Cn = 2(n + 1)(Hn+1 ; 1) 2n ln n ; 0:846::n + o(n) 1:386n log n
P
wobei Hn := ni=1 i;1 die n-te Harmonische Zahl ist.
KAPITEL 2. SELEKTIEREN UND SORTIEREN
86
Beweis: (Variante mit n ; 1 Vergleiche pro Durchlauf)
Sei Cn die Anzahl der Vergleichen bei dem Feld der Lange n. C0 = C1 = 0.
Cn = n ; 1 + n1
n
X
j =1
(Cj;1 + Cn;j )
Da
i) fur festes j 2 f1 ng das Produkt (in beiden Varianten) das j kleinstes Element ist und
ii) auch fur die rekursiven Aufrufe wieder alle Eingabepermutationen gleichwahrscheinlich sind:
)
Cn = n ; 1 + n2
nX
;1
nCn = n2 ; n + 2
Cj j =0
nX
;1
j =0
Cj (n ; 1)Cn;1 = (n ; 1)2 ; (n ; 1) + 2
nX
;2
j =0
Cj nCn ; (n ; 1)Cn;1 = 2n ; 1 ; 1 + 2Cn;1 nCn = 2n ; 2 + (n + 1)Cn;1 = n(n1+ 1)
n ; 1 Cn;1
Cn
n + 1 = 2 n(n + 1) + n =
= 2 n(nn;+11) + 2 (nn;;1)2 n + nCn;;12 =
= 2 n(nn;+11) + + C32 =
2
3
n j;1
X
= 2 4 j (j + 1) 5 =
j =2
=
2
n X
4
2
2
j =2
j
1
j (j + 1) ; j (j + 1)
3
5
=
3
n 1
X
3
4
= 2 Hn+1 ; 2 ;
; (j +1 1) 5 =
j
j =2
%
&
3
1
1
= 2 Hn+1 ; 2 ; 2 ; (n + 1) =
%
&
1
= 2 Hn+1 ; 2 + (n + 1)
1 Hn ln n + 0:57721 + o(1)
) Cn = 2(n + 1) Hn+1 ; 2 + n+1
) Cn 2n ln n ; 4n + o(n) 1:386n log n
3
Kapitel 3
Minimale Spannbaume
3.0 Grundlagen
Ein Graph G = (V E ) besteht aus einer Menge von Knoten V und einer Menge
Kanten E . Die Anzahl der Knoten bezeichnen wir mit n (jV j = n), die Anzahl
der Kanten mit m (jE j = m). Eine Kante (v v) 2 E hei
t Schlinge. Falls E
eine Multimenge ist, spricht man von Mehrfachkanten. Kanten (u v) und (v u)
hei
en antiparallel. Graphen ohne Schlingen und Mehrfachkanten bezeichnen wir
mit einfachen Graphen (eng. simple). Formal deniert:
E
V
2
=: fX V jX j = 2g
In diesem Fall bezeichnet man G = (V E ) als einen ungerichteten Graphen.
Graphische Darstellung:
v4t
K5
Vollstandiger bipartit, K33
v3 t
PP
PP
D
Z
v5
D ZZ PP
v3DD ZZAA
```
D````
ZZA v2
J
J
D
``Z
`A
J D
J D J D v1 JD
t
t
tv6
H
;
@HH
;
@ H
;
HH
v2 @
; HH v5
HH @
;@ H
;H
H@
;
H@
H@
v1 ;
H v4
t
t
t
t
t
t
Ist E V V , dann hei
t G gerichteter Graph, fur (u v) 2 E :
s
u
-
s
v
Der zu G gehorige ungerichtete Graph ist G0 = (V E 0 ). E 0 erhalt man, indem man
in E die Richtungen wegla
t und Mehrfachkanten beseitigt. Sei v 2 V , unter der
Nachbarschaft N (v) := fw (v w) 2 E g eines Knotens v versteht man die Menge
der direkten Nachbarn von v. Der Grad eines Knotens ist deniert als:
N (v)j
falls G ungerichtet und
deg(v) = jindeg
(v) + outdeg(v) falls G gerichtet.
87
KAPITEL 3. MINIMALE SPANNBAUME
88
Dabei sind indeg(v) die Anzahl aller Kanten, die v als Endknoten haben, und
outdeg(v) die Anzahl aller Kanten, die v als Startknoten haben.
P
Beobachtung: v2V deg(v) = 2jE j
Korollar: In jedem Graphen ist die Anzahl der Knoten mit ungeradem Grad eine
gerade Zahl.
Das Komplement G = (V V2 ; E ) eines Graphen G = (V E ) besitzt die
gleiche Knotenmenge V und hat als Kantenmenge alle Kanten des vollstandigen
Graphen ohne die Kantenmenge E .
Ein Graph H = (V 0 E 0 ) hei
t Teilgraph (aka. Subgraph, Untergraph, ...) von
G = (V E ), falls V 0 V und E 0 E . H hei
t (knoten-)
induzierter Teil
0 V
0
graph, falls H Teilgraph von G ist, und es gilt E = E \ 2 .
Ein Kantenzug ist eine Folge e1 := fv0 v1 g el := fvl;1 vl g, wobei alle ei
verschieden sind. v0 und vl bezeichnen wir als Endknoten. Die Lange des Kantenzuges bezeichnen wir mit l. Sind bei einem Kantenzug auch alle vi verschieden, so
sprechen wir von einem Pfad. Ein Kantenzug mit vl = v0 hei
t Zykel. Ein Zykel,
in dem alle vi verschieden sind, hei
t Kreis.
Ein Graph G hei
t zusammenhangend, wenn es fur alle u v 2 V einen Pfad
gibt, der u und v verbindet. Ein (kanten-) maximaler zusammenhangender Teilgraph hei
t (Zusammenhangs-)Komponente.
$
K4 '
$
s ;s
K1 AA
;
A
;
s s
s As
s; s
&
%
& %
3
K2 s K'
s
Ein Graph G ist azyklisch, wenn er keine Kreise enthalt. Wir bezeichnen diesen
dann als Wald. Ist dieser auch zusammenhangend, so sprechen wir von einem
Baum. Ist der Teilgraph T = (V E ) G = (V E ) ein Baum, dann hei
t T ein
Spannbaum.
Satz: Ist T = (V E ) ein Baum, dann ist jE j = jV j ; 1.
Beweis: Induktion uber die Anzahl der Knoten:
n = 0 1 : klar.
n ! n + 1 : Sei v 2 V , jV j = n + 1 V 0 = V ; fvg deg(v) = 1.
Solche Knoten mussen existieren, denn ansonsten wurde ein Zykel entstehen, und
das ware ein Widerspruch zur Denition eines Baumes.
3
Korollar: Ein Graph G ist zusammenhangend, g.d.w. G ein Spannbaum hat.
KAPITEL 3. MINIMALE SPANNBAUME
89
3.1 Traversierung von Graphen
Sei G = (V E ) ein ungerichteter Graph. Anhand eines Beipiels betrachten wir die
zwei Algorithmen DFS (Tiefensuche) und BSF (Breitensuche).
3.1.1 DFS-Algorithmus
9
v
unvisitet
do
pick(random) unvisited node
push
onto stack
while stack = do
:= pop the top element
if not visited
then
mark
visited
push all neigbour's of
onto stack
DFS Ops( )
fi
od
while
r :=
r
v
6 v
v
v
v
od
Beispiel fur DFS:
1t
g2t 1gQBB QQ
Q
2Q
B Q
B
Q 8g
Q
B
B Q
*t7
Q B
B
g
Q 7
QB
t
B
8H
6HH
B g
g
Bt6
t 3
gt?
9H
3A
9@
I
;6
;
@
A
@g ;
A g
5@
t
-;
AUt4
4
5
Die markierten Kanten bilden einen Spannbaum:
s 1g
2g s
s 3g Ruckwartskanten
s 4g
s 5g
;@
;
s 6g @s 7g
s 8g
s 9g
Wir betrachten nun den Stackzustand: Im Zustand g) sind die Elemente 2, 3 und
5 als visited markiert (siehe Zustande b), c) und e)). Deswegen werden sie aus dem
KAPITEL 3. MINIMALE SPANNBAUME
90
Stack entfernt und so wird das Element 8 zum obersten Stackelement. Im Zustand
j) sind alle Elemente markiert, so da
eins nach dem anderen aus dem Stack entfernt
werden.
: Oberstes Stackelement
: Nachbarn
h : Schon besuchte Knoten
Zustand:
g)
j)
a) b) c) d)
e)
f) visited h)
i) visited
? ? ? ? ? ?6h ? ? ?6h
Stack: 1
2
8
7
3
9
8
1
8
7
4
9
2
9
8
1
8
7
5
3
9
2
9
8
1
8
7
9
8
6
4
3
9
2
9
8
1
8
7
2
3h
5h
8
6
4
3
9
2
9
8
p 1p p
p
7
6
5
2
1
6
4
3
9
2
9
p 8p p
p
3.1.2 DFS-Algorithmus
while
9
v
unvisitet
do
pick(random) unvisited node
push
into queue
while queue = do
:= remove front element of queue
if not visited
then
mark
visited
append all neigbour's of
to end of queue
BFS Ops( )
fi
od
r :=
r
v
6 v
v
v
v
od
Beispiel fur BFS:
tg
1
gt
Q
1B Q
2
B Q
Q
2BQQ
B
Q 4
B Q
B
s
Q
7
Q
B
B
Q 3
QBN
B
8 HHH
B
6
BN 5
j
7H
3A
9@
;6
@
;
A
@
;
A
@;
?8
AU 9
t g tg
tg
4
tg
5
tg
tg
gt
6
8
1
6
5
2
1
6
4
3
9
p 2p p
p
7
8h
5h
8h
1h
6h
5h
2h
1h
6h
4h
p 3php
p
KAPITEL 3. MINIMALE SPANNBAUME
91
Die markierten Kanten bilden einen Spannbaum:
1
gs
gpsp p p p p p p p p p p p p p p p p sp gp p p p p p p p p p p s4g
pp
p
p
gpsp p p p p p p p p psp gp p p p p gp p sp p p p p p p p p p sp p g
pp
p
p
p
g ps p p
H
B HH
B
HH
2 B3
H
J
J
J
J
6
J5 8
J 7
J
;
YH ;
H
J
R
u
ckwartskanten
J
9
Wir betrachten nun den Queuezustand: Im Zustand e) sind die Elemente 1 und
8 als visited markiert (siehe Zustande a) und c)). Deswegen werden sie aus der
Queue entfernt, und so wird das Element 9 das vorderste Queueelement. Das gleiche
passiert in den Zustanden g), h) und i). Im Zustand j) sind alle Elemente markiert,
so da
sie eins nach dem anderen aus der Queue entfernt werden.
: Vorderstes Queue-Element
: Nachbarn
i : Schon besuchte Knoten
Queue: Zustand:
1
(a
2 8 7
(b
8 7 1 8 9 3
(c
7 1 8 9 3 1 2 6 7 5
(d
visited 1ii
8 9 3 1 2 6 7 5 1 8 6
3 1 2 6 7 5 1 8 6 5 3 2
visited 1ii
2 6 7 5 1 8 6 5 3 2 4 9 2
visited 7i5 1 8 6 5 3 2 4 9 2 7 8 5
visited 1iiiiii
8 6 5 3 2 4 9 2 7 8 5 6 8 9 4
visited 9iiiiiiiiiii
2 7 8 5 6 8 9 4 5 3
3.2 Minimale Spannbaume
(e
(f
(g
(h
(i
(j
Sei G = (V E ) ungerichteter einfacher Graph gegeben mit folgenden Eigenschaften:
w : E ! R eine Gewichtsfunktion,
E 0 E : w(E 0 ) = Pe2E0 w(e),
T = (V 0 E 0 ) ein Teilgraph von G mit w(T ) = w(E 0 ),
sei o.B.d.A. G zusammenhangend, dann deniere:
KAPITEL 3. MINIMALE SPANNBAUME
92
Denition: T hei
t minimaler Spannbaum (MSB) von G, falls T Spannbaum von G ist und gilt:
w(T ) w(T 0 )
Beispiel:
q
7
1
q@
4
2
q@ 6
q
;
8@
;3
@;
q
moglicher
q Spannbaum
@
@
;
;
;5
q
q
q
;
;
;
;
q;;
Anwendungen:
Telekom: Telefonvermittlungen
Leiterplatinen
q
q
3.2.1 Konstruktion von minimalen Spannbaumen
Es gibt zwei Prinzipien fur die Konstruktion von minimalen Spannbaumen(Tarjan):
"blaue\ Regel
"rote\ Regel
Satz: Sei G = (V E ) ein zusammenhangender, ungerichteter Graph, w: E ! R
eine Gewichtsfunktion, C = (V1 V2 ) ein Schnitt (d.h. V = V1 V2 , V1 \ V2 = ,
V1 6= 6= V2 ). Sei EC = E \ (V1 V2 ) die Menge der Kanten "uber den Schnitt
hinweg\. Dann gilt: ("blaue\ Regel)
1. Ist e 2 EC die einzige Kante minimalen Gewichts (uber alle Kanten in EC ),
dann ist e in jedem minimalen Spannbaum fur (Gw) enthalten.
2. Hat e 2 EC minimales Gewicht (uber alle Kanten in EC ), dann gibt es einen
minimalen Spannbaum von (Gw), der e enthalt.
Beweis: durch Widerspruch
1. Sei T ein minimaler Spannbaum von (Gw), sei e 2 EC die minimale Kante.
Annahme: e 2= T . Da T Spannbaum ) T \ EC 6= .
Sei T \ EC = fe1 e2 : : : ek g k 1. Dann enthalt T feg einen eindeutig
bestimmten Kreis (den sogenannten durch e bzgl. T bestimmten Fundamentalkreis). Dieser Kreis mu
mindestens eine Kante 2 Ec \ T enthalten, da die
beiden Endpunkte von e auf verschiedenen Seiten des Schnitts C liegen.
Tr
Ar
Ar
Ar
V1
e
e
0
r rj
j
r
j
V2
r
HH
H
AH
H
0
HA
e
;@
;
@
A
;
@
; @A
e
;@
;
@
r
j
r
r
r
r
r
j
KAPITEL 3. MINIMALE SPANNBAUME
93
Sei e0 2 Ec \ T . Dann gilt nach Vorraussetzung w(e0 ) >w(e). Also ist T 0 :=
T ; fe0g feg ein Spannbaum von G, der echt kleineres Gewicht als T hat,
Widerspruch zu T ist minimaler Spannbaum.
2. Sei e 2 Ec minimal. Annahme: e kommt in keinem minimalen Spannbaum
vor. Sei T ein beliebiger minimaler Spannbaum von (Gw).
rj jr
r
V1
e
rj rjr
V2
e2
=
T \ E 6= c
e 2= T \ Ec 6= . Sei e0 2 Ec \ T eine Kante auf dem durch e bezuglich T
erzeugten Fundamentalkreis. Dann ist T 0 = T ; fe0g feg wieder ein Spannbaum von G, und es ist w(T 0) w(T ). Also T 0 minimaler Spannbaum und
e 2 T 0.
3
Satz: Sei G = (V E ), w : E ! R, ein gewichteter, zusammenhangender Graph.
Dann gilt: ("rote\ Regel)
1. Gibt es zu e 2 E einen Kreis C in G, der e enthalt und w(e) > w(e0 ) 8e0 2
C n feg erfullt, dann kommt e in keinem minimalen Spannbaum vor.
2. Ist c1 = e1 : : : ek ein Kreis in G und w(ei ) = maxfw(ej )j1 j kg, dann
gibt es einen minimalen Spannbaum, der ei nicht enthalt.
Beweis:
1. Nehmen wir an, da
es einen minimalen Spannbaum T gibt, der e = fv1 v2 g
enthalt. Wenn wir e aus T entfernen, so zerfallt T in zwei nicht zusammenhangende Teilbaume T1 und T2 mit vi 2 Ti , i = 1 2. Da aber e auf
einem Kreis in G liegt, mu
es einen Weg von v1 nach v2 geben, der e nicht
benutzt. Mithin gibt es eine Kante e^ 6= e auf diesem Weg, die einen Knoten in
T1 mit T2 verbindet. Verbinden wir T1 und T2 entlang e^, so erhalten wir einen
von T verschiedenen Spannbaum T^. Wegen w(^e) < w(e) folgt w(T^) < w(T ).
Ein Widerspruch.
2. Wir nehmen an, ei liege in jedem minimalen Spannbaum (MSB) von G, und
zeigen die Behauptung durch Widerspruch.
Sei T ein beliebiger MSB von G. Entfernen wir ei aus T , so zerfallt T in
zwei nicht zusammenhangende Teilbaume T1 und T2 . Da ei auf einem Kreis
c1 = e1 : : : ek in G liegt, konnen wir wie unter 1. ei durch eine Kante ej des
Kreises c1 ersetzen, die T1 und T2 verbindet. Dadurch erhalten wir einen von
T verschiedenen Spannbaum T~, der ei nicht enthalt. Da nach Voraussetzung
w(ej ) w(ei ) gilt, folgt w(T~) w(T ) (und sogar w(T~) = w(T ), da T nach
Annahme ein MSB ist). Also ist T~ ein MSB von G, der ei nicht enthalt, im
Widerspruch zur Annahme, ei liege in jedem MSB von G.
3
Literatur: R.E. Tarjan: \Data Structures and Network Algorithms", SIAM CBMSNSF Reihe Bd. 44.
KAPITEL 3. MINIMALE SPANNBAUME
94
3.2.2 Generischer minimaler Spannbaum-Algorithmus
Initialisiere Wald F von Baumen, jeder Baum ist ein singularer Knoten.
(jedes v 2 V bildet einen Baum)
while Wald F mehr als einen Baum enthalt do
wahle einen Baum T 2 F aus
bestimme eine leichteste Kante e = fv wg aus T heraus
sei v 2 T w 2 T 0 vereinige T und T 0, fuge e zum minimalen Spannbaum hinzu
od
T
T0
#
#
qHq Hqq q q q
q
"!
"!
T 00 #
T 000
Wald F
#
q q q qq q
"!
"!
V1
V2
3.3 Kruskals Algorithmus
algorithm Kruskal
p
(Gw):=
G
F fT i : : : ng
V E V fv : : : v g
T
i
fv wg L
x
2F
y
2F
x6 y
v
w
y
n jV j
T
fv g
L
v
w
x
y
ffv wgg
jxj jyj
x
v
w
x y
x
x
L
sortiere die Kanten nach aufsteigendem Gewicht in eine Liste initialisiere
= i =1
Wald ( =
) mit i = i co
= ( ), = 1
oc
n
co implementiere i 's als in-Trees mit den jeweiligen Wurzeln als
Repr
asentanten allgemein: Unio-Find-Problem oc
MSB:= for := 1 to length( ) do
:= i := Baum
, der
enth
alt co
:=Find( ) oc
:= Baum
, der
enth
alt co :=Find( ) oc
if
= then
co
und
in verschiedenen B
aumen oc
MSB:=MSB
if
then
co Baum
enth
alt
Knoten als Baum y oc
co :=Union(
) oc
else
vereinige
und , mit
neues Kind der Wurzel von fi
fi
od
y
y
x
KAPITEL 3. MINIMALE SPANNBAUME
95
Korrektheit: Falls die Gewichte eindeutig sind (w() injektiv), folgt die Korrektheit
direkt aus der \blauen\ und \roten\ Regel. Ansonsten Induktion uber die Anzahl
der Knoten (jV j):
p
Ind. Anfang: jV j klein:
Sei r 2 R, Er := fe 2 E w(e) < rg.
Es genugt zu zeigen:
Sei r 2 R, sei T1 Tk ein minimaler Spannwald (d.h. Spannwald minimalen Gewichtes) fur Gr := fV Er g (d.h.betrachte nur Kanten mit Gewicht > r). Sei T ein
MSB von G, dann:
Hilfsbehauptung: Die Knotenmenge eines jeden Ti im T induziert einen zusammenhangenden Teilbaum.
Beweis der Hilfsbehauptung: Sei Ti =: (Vi Ei) und sei e 2 Vi Vi . Falls
e 2 Ti , dann ist nichts zu zeigen. Fur den Fall e 62 Ti betrachte den Fundamentalkreis C , den e in Ti erzeugt. Gewicht aller Kanten auf C ;feg < r . Falls die beiden
Endpunkte von e in T durch einen Pfad verbunden sind, der eine Kante e0 2 E ; Er
enthalt, dann liefert die \rote\ Regel, da
T nicht minimal ist.
) Die beiden Endpunkte und e sind in T durch einem Pfad aus lauter Kanten mit
3
Gewicht < r verbunden.
Zeitkomplexitat: (mit n = jV j m = jE j)
Sortieren
m log m = O(m log n)
O(m) Find -Operationen O(m log n)
n ; 1 Unions
O(n)
Satz: Kruskal's MSB-Algorithmus hat die Zeitkomplexitat von O((m + n) log n)
Beweis: s.o.
3
Beispiel fur Kruskals Algorithmus:
t
4
t
8
11
7
t
8
2
t
1
6
t
7
4
t
+
t 8 t
4 h
2 h
4
2
t 11 t
6
7h 7
8
h
t 11 t
t
14
t
9
t
10
2
minimaler
Spannbaum
7 t
6h
9
5h 8h
14 t
4
10
3h t
2
KAPITEL 3. MINIMALE SPANNBAUME
96
3.4 Prim's Algorithmus, erste Variante
algorithm PRIM-MSB
p
(Gw) :=
V
initialisiere Priority Queue PQ mit Knotenmenge
und Schl
ussel
w
ahle Knoten
als Wurzel (beliebig)
Schl
ussel ] := 0
Vorg
anger ] := nil
while
= do
:= FindMin( )
DeleteMin( )
for alle Knoten , die in
zu
benachbart sind do
if
and w(
) Schl
ussel ] then
Vorg
anger ] := Schl
ussel ] := w(
)
fi
od
od
r
r
r
u
PQ 6 PQ
PQ
v
v 2 PQ
x
G
v
v
u
fu vg <
u
v
fu vg
Beispiel fur Prim's Algorithmus (erste Variante):
1t
v
+
v0
0
t
4
1tv
7
tv
+1
4t
1
v7
t
8
1
;;t
8
v1
;;ti
v7
8
t
8
v1
2
v8
6
8
1
6
5
tv
+1
+1
t
2
v8
2
7
v6
6
t
tv
+1
+1
t
7
v2
t
+1
+1
t
10
9
2
Ausgangszustand:
1
alle Schl
ussel = +
aktueller Knoten (= u):
Startknoten: r (= v0 )
it
10
14
t
t +1
v4
9
+1
v3
PQ
u
PQ
PQ
u v
v
<
v
v
suche
:= FindMin( )
und entferne aus
setze Schlussel der Nachbarn
in
mit
w(f g) Schlussel ]:
( 6 = 8)
u
t +1
v4
10
suche
:= FindMin( )
und entferne aus
setze Schlussel der Nachbarn
in
mit
w(f g) Schlussel ]:
( 1 = 8 7 = 4)
u
v3
v5
4
t
4
14
2
tv 1
+
3
v5
v6
+1
9
14
4
+1
8t
6
1t
v
+
4
v2
1
7
7
2
1
+1t
11
1t
v
8
+1
;;ti 11 7 t
8
v0
2
+
11
8
v0
7
4
+
8
PQ
u
PQ
PQ
u v
v
<
v
+1 8v 2 V KAPITEL 3. MINIMALE SPANNBAUME
1
v0
;;t
;;t
11
8
t
7
v1
8
1
v0
;;t
;;t
v7
11
8
t
7
v1
7
1
v0
;;t
;;t
v7
11
8
t
7
v1
7
1
v0
;;t
;;t
v7
11
8
t
7
v1
1
1
v0
;;t
8
2
v7
;;t
v7
11
7
t
;;i
v1
2t
2
v8
;;ti
7
v6
6
7t
v5
14
4
t
v2
t
1
+1
2
4
2
3
;;t
7
7t
;;ti 6
v6
v8
t
v2
6
2
3
;;t
;;t
v8
6
v6
t
v2
2
2
3
;;t
v8
v6
;;ti
2
3
;;t
v2
v8
6
7t
2
;;ti
7
7t
v6
;;t
v2
;;t
5
t10
v4
suche
:= FindMin( )
und entferne aus
setze Schlussel der Nachbarn
in
mit
w(f g) Schlussel ]:
( 1 = 7 2 = 6)
PQ
u
PQ
PQ
u v
<
v
v
suche
:= FindMin( )
und entferne aus
setze Schlussel der Nachbarn
in
mit
w(f g) Schlussel ]:
( 2 = 2 4 = 10)
PQ
u
PQ
PQ
u v
<
v
v
suche
:= FindMin( )
und entferne aus
setze Schlussel der Nachbarn
in
mit
w(f g) Schlussel ]:
( 1 = 1)
PQ
u
PQ
PQ
u v
<
v
v
suche
:= FindMin( )
und entferne aus
setze Schlussel der Nachbarn
in
mit
w(f g) Schlussel ]:
solche Nachbarn existieren
nicht
u
9
14
;;t
v
v
u
v3
7t
<
v
v
10
v5
4
6
10
14
7
t10
v4
9
u v
u
v3
v5
PQ
v
v3
14
5
t +1
v4
9
PQ
u
10
v5
4
6
1
;;t
7
4
1
;;t
t
4
PQ
u
v
v3
14
2
t +1
v4
9
suche
:= FindMin( )
und entferne aus
setze Schlussel der Nachbarn
in
mit
w(f g) Schlussel ]:
( 3 = 4 5 = 7 8 = 2)
u
10
v5
4
1
9
97
t10
v4
10
v3
PQ
u
PQ
PQ
u v
<
v
KAPITEL 3. MINIMALE SPANNBAUME
1
v0
;;t
8
1
v0
;;t
8
;;t
11
;;t
v8
7
;;t
v1
;;tv
7
11
;;t
2
3
v7
7
v6
6
;;t
2
3
;;t v
v2
8
7
;;t v
1
6
5
7
6
;;tv 6
2
;;t
5
t9
10
t
8
;;itv
;;t v
10
PQ
u
PQ
PQ
u v
<
v
v
v3
;
v;
5
suche
:= FindMin( )
und entferne aus
setze Schlussel der Nachbarn
in
mit
w(f g) Schlussel ]:
( 4 = 9)
u
v4
14
4
;;tv
9
14
4
6
;;ti
v5
98
Endzustand:
4
suche u := FindMin(P Q)
und entferne u aus P Q,
damit ist P Q leer und der
Algorithmus beendet
3
Korrektheit: ist klar.
Zeitkomplexitat:
n ; 1 DeleteMin
O(m) sonstige Operationen inclusive DecreaseKey
Implementierung der Priority Queue mittels Fibonacci-Heaps:
Initialisierung
O(n)
Find + DeleteMins O(m) ( m Stuck)
DecreaseKeys
O(m) ( m Stuck)
Sonstige Overhead O(1)
) Laufzeit:
O(n) + O(n log(n)) + m O(1) + m O(1) = O(m + n log n)
Satz: Sei G = (V E ) ein ungerichteter Graph (zusammenhangend, einfach) mit
Kantengewichten w. Prim's Algorithmus berechnet, wenn mit Fibonacci-Heaps
implementiert, einen minimalen Spannbaum von (G w) in Zeit O(m + n log n)
(hier: n = jV j m = jE j). Dies ist fur m = (n log n) asymptotisch optimal.
3.5 Prim's Algorithmus, zweite Variante
Idee: Lasse die Priority Queues nicht zu gro
werden.
Sei G = (V E ) jV j = n jE j = m, w Gewichtsfunktion, k Parameter, der unten
festgelegt wird.
Der Algorithmus wird in den folgenden Phasen abgearbeitet:
1. Initialisiere eine Schlange von Baumen, jeder Baum anfangs (Super-) Knoten. Zu jedem Baum: Priority Queue (Fibonacci-Heap) mit den Nachbarn der
Knoten im Baum, die selbst nicht im Baum sind. Schlussel: Gewicht einer
leichtesten Kante zu einem Knoten im Baum.
KAPITEL 3. MINIMALE SPANNBAUME
99
2. Markiere jeden Baum in der Schlange mit der Nummer der laufenden Phase
3.
while vorderster Baum in der Schlange hat laufende Phasennummer do
lasse ihn wachsen, solange seine Priority Queue weniger als
k Elemente enthalt (und noch was zu tun ist)
if Priority Queue zu gro
then
fuge Baum mit Phasennummer + 1 am Ende der Schlange ein
od
4. Falls "Phasensprung\: Schrumpfe alle Baume zu Superknoten, reduziere Kantenmenge (Behalte zwischen zwei Knoten, jeweils nur die leichteste Kante).
5. nachste Phase!
t It t t t t t j
t
t
t
t
t
t
t
wenn ?gro genug
hinten anstellen
.
.
.
Endemarkierung
Endemarkierung
falls
Phasensprung
?
schrumpfen und
nachste Phase
Betrachte Schlange von Baumen:
vr
r
Ti Tt
T1
T2
r @r
;
r
(Arbeit pro Phase # Knoten, au
er Vereinigung zweier Superknoten T1 und T2 .)
Fur jeden (Super-)Knoten v in T2 's Priority Queue:
p
1. v 2 T1 : (nichts zu tun)
2. v in Priority Queue von T1, einfugen bzw. conditional DecreaseKey. Hilfsdatenstruktur: fur alle Knoten in den Priority Queues ein Zeiger auf den Superknoten, in dessen Priority Queue der Knoten letztmals am Anfang der
Schlange stand.
3. sonst: Einfugen
Betrachte Knoten mit "Halbkanten\: jede Halbkante kommt nur 1x in den Baumen
vor. Mit m Kanten ergeben
sich 2m Halbkanten, d.h. Anzahl proportional zu m.
KAPITEL 3. MINIMALE SPANNBAUME
vr
e;;
;
rm
!
vr
e;;
und
;
e;; =b
;
r
2m
Halbkanten
Kanten
100
vr
e;;
;
r
Kante aus zwei
Halbkanten
Zeitaufwand pro Phase: (+ Superknoten zu Beginn)
Initialisierung: O(m)
Delete und DeleteMin: t
sonstige Priority Queue-Operationen, Overhead: O(m)
Da die Priority Queues hochstens k Elemente enthalten, wenn darauf eine Priority
Queue-Operation durchgefuhrt wird, sind die Kosten pro Phase
O(t log k + m)
Setze k = 2 2mt (damit t log k = m). Damit sind die Kosten pro Phase O(m).
Wieviele Phasen? Sei t die Anzahl der Superknoten am Anfang einer Phase, t0
diese Zahl zu Beginn der nachsten Phase. Sei a die durchschnittliche Anzahl ursprunglicher Knoten in den t Priority Queues zu Anfang der Phase, a0 entsprechend
zu Beginn der nachsten Phase.
Wir haben:
1. a = 2m
t
2
0
2. t km (mit Ausnahme ev. der letzten Phase)
Also:
a0 = 2m k = 2 2tm = 2a
t0
Fur die erste Phase ist a = 2nm , a ist fur jede Phase n ; 1. Also ist die Anzahl
der Phasen
1 + min i log(i) (n ; 1) 2m
2
n
n
o
Setzen wir (m n) := min i log(2i) n mn , dann gilt
(m n) log n fur n m n2
Satz: Fur gewichtete, zusammenhangende Graphen mit n Knoten, m Kanten
kann ein minimaler Spannbaum in Zeit O(minfm (m n) m + n log ng) bestimmt
werden.
Euklidische minimale Spannbaume stellen ein Problem dar, fur das es speziellere
Algorithmen gibt. Literatur hierzu:
A.C.-C. Yao: Constructing Minimum Spanning Trees in k-dimensional spaces and
related problems. SIAM Journal on Computing 11(4) p. 721{736 (1982).
Kapitel 4
Kurzeste Pfade
4.1 Grundlegende Begrie
Betrachte Digraph G = (V A) oder Graph G = (V E ).
r
Kante von
ungerichtetem
Graph
r
r6
=b
r?
Entgegengesetzte
(antiparallele) Kanten
Distanzfunktion:
d : A ;! R+ (bzw. ;! R)
O.B.d.A.: A = V V , d(x y) = +1 fur Kanten, die eigentlich nicht vorhanden
sind.
dis(v w) := Lange eines kurzesten Pfades von v nach w 2 R+ f+1g
Arten von kurzeste-Pfade-Problemen:
1. single-pair-shortest-path ( spsp). Beispiel: Kurzeste Entfernung von Munchen
nach Frankfurt.
2. single-source-shortest-path: gegeben G, d und s 2 V , bestimme fur alle v 2 V
die Lange eines kurzesten Pfades von s nach v (bzw. einen kurzesten Pfad
von s nach v) ( sssp). Beispiel: Kurzeste Entfernung von Munchen nach allen
anderen Gro
stadten.
3. all-pairs-shortest-path ( apsp) . Beispiel: Kurzeste Entfernung zwischen allen
Gro
stadten.
Bemerkung: Es gibt keinen Algorithmus, der das single-pair-shortest-path berechnet, ohne nicht gleichzeitig das single-source-shortest-path-Problem zu losen.
4.2 Das single-source-shortest-path-Problem
Zunachst nehmen wir an, da
d 0 ist. Alle kurzesten Pfade von a nach b sind
o.B.d.A. einfache Pfade.
101
KAPITEL 4. KURZESTE
PFADE
102
4.2.1 Dijkstra's Algorithmus
r
Gegeben: G = (V A) (A = V V ) Distanzfunktion d : A ! R+ f+1g. Startknoten s.
G durch Adjazenzlisten dargestellt.
0
rs
A
A
A
CC
;
;
C
r
r
r
r
rr
algorithm sssp:=
p
S
fsg
s
v 2 V n fsg
v 2 V ; fsg
v s
PQ, die
s v)
:= dis ] := 0 initialisiere eine Priorityqueue
alle Knoten
enth
alt mit Schl
ussel dis ] := d(
for alle
do
from ] :=
od
while
= do
:= ExtractMin( )
:=
for alle
, d(
)
do
if dis ] + d(
) dis ] then
DecreaseKey(
] + ( ))
co DecreaseKey ver
andert dis ] oc
from ] := fi
od
od
v
S
v
S6 V
PQ
S fvg
w 2 V ; S v w < 1
v
v w < w
w dis v d v w
w
w
v
x
Seien n = jV j und m := Anzahl wirklicher Kanten:
Laufzeit (mit Fibonacci-Heaps):
Initialisierung:
O(n)
ExtractMin:
n O(log n)
Sonstiger Aufwand: m ; O(1) (z.B. DecreaseKey )
) Zeitbedarf also: O(m + n log n)
Korrektheit: Wir behaupten, da
in dem Moment, in dem ein v 2 V ;fsg Ergebnis der FindMin Operation ist, der Wert disv] des Schlussels von v gleich der Lange
eines kurzesten Pfades von s nach v ist.
Beweis: durch Widerspruch: Sei v 2 V ; fsg der erste Knoten, fur den diese
Behauptung nicht stimmt und sei
sr
sr
-1
s r : :: srr
-2
vr
-1
v r : :: vqr
-2
vr
-
ein kurzester Pfad von s nach v, mit einer Lange < disv]. Dabei sind s1 : : : sr 2 S ,
s -s1 : : : sr -v1 v1 2= S r = 0 und/oder q = 0 ist moglich]. Betrachte Pfad
seine Lange ist < disv], fur q 1 (ebenso fur q = 0) ist also disv1 ] < disv], Widerspruch zur Wahl von v.
3
r r r r
KAPITEL 4. KURZESTE
PFADE
103
Beispiel fur Dijkstra-Algorithmus:
1s v
2
v31s
5
@
@
@ 1
6 @
@
@
1
0
@ 3
@
@
3
@
v@
1
v7
@
@2
@
@ 1
@
4
v4 3 @ v6
v@@
2
s
s
s
s
1
s
1
v3 6s
5
3@
@
@
@ 1
6
@
@
1
0
@ 3
@
@
3
@
v@
1@
v7
@
@
@2
@
1
@
@ @ 4
3
v
@
@
4
R
@
@
v2
v6
sf
s
s
s
s
1
2
v3 5s
1
1s
2
v
5
@
@
@ 1
6 @
@
@
1
0
@ 3
@
@
3
@
v@
1@
v7
@
@
@2
@
1
@
@ @
4
3
v
@
4
R
@
@
v@
v
2
6
s
s
sf
s
2
s
1
6
v3 5sf
s
s
s
s
s
s
6
markiere (v3 v5 )
setze disv5 ]=2+3+5=7
markiere (v3 v6 )
setze disv6 ]=2+3+3=8
setze v5 als Bezugsknoten, da
d(v3 v5 ) < d(v3 v6 )
fs
s
5
7
s
s
s
markiere (v2 v3 )
unmarkiere (v1 v3 ), da
d(v1 v2 ) + d(v2 v3 ) < d(v1 v3 )
setze disv3 ]=2+3=5
markiere (v2 v4 )
setze disv4 ]=2+4=6
setze v3 als Bezugsknoten, da
d(v2 v3 ) < d(v2 v4 )
8
2 - v5
v3
@
@
@
@
@
@
@ 1
6 @
@
@
@
0
@ 3
@
@
R8
@
3
@
v@
1@
v7
@
@2
@
@
@ @
1
@
4
3
v
@
@
4
@
R
@
R
@
v2
v6
2
markiere (v1 v2 )
setze disv2 ]=2
markiere (v1 v3 )
setze disv3 ]=6
setze v2 als Bezugsknoten, da
d(v1 v2 ) < d(v1 v3 )
7
2 - v5
@
@
@
@
@ 1
6 @
@
@
1
0
@ 3
@
@
3
@
v@
1@
v7
@
@
@2
@
@
@ 1
@
4 - v4 3 @
@
R
@ v6
R
@
v@
2
2
setze disRest]=+1
1
1s v
2
gegeben Graph G
v1 ist der Startknoten
setze v1 als Bezugsknoten
setze disv1 ]=0
s
6
s
8
markiere (v5 v7 )
setze disv7 ]=2+3+2+1=8
alle Knoten wurden erreicht:
) Algorithmus zu Ende
KAPITEL 4. KURZESTE
PFADE
104
Beobachtung:
ExtractMin liefert eine monoton steigende Folge von Schlusseln dis ]
Die Schlussel in PQ sind stets disv]+ C , wobei v das Ergebnis der vorangehenden ExtractMin-Operation (bzw. s zu Beginn) und C := maxuv2A fd(u v)g
ist.
Satz: Dijkstra's Algorithmus (mit Fibonacci-Heaps) lost das Single-SourceShortest-Path-Problem in Zeit O(m + n log n).
Bemerkung:
1. Verwendet man Dijkstra's Algorithmus mit d-Heaps, so erhalt man Laufzeit
O(m log2+ mn n)
2. Mikkel Thorup (STOC '98): O(m)
4.2.2 Dikstra's Algorithmus mit Radix-Heaps
S
s
r
vr vr0
r r r
r
+1
-
H
Y
6 HH
disv0 ]
d(v) 2 0 ::: C ] (alle Werte sind zwischen
disv] und nC )
disv]
r
r
r
r
r
disv]
e
r
r
disv0 ]
Einstuge Radix-Heaps:
Menge von B = dlog2 (C + 1)e + 2 Buckets (jeder Bucket als doppelt verkettete
Liste implementiert). Jeder Bucket hat Gro
e size, mit
8
<
1
fur i = 1
fur i = 2 : : : B ; 1
size(i) = : 2i;2
nC + 1 fur i = B
Beobachtung:
j ;1
X
i=1
size(i) minfsize(j ) C + 1g fur j = 2 : : : B
Wir ordnen den Buckets Intervalle zu, indem wir fur jeden Bucket i eine obere
Intervallgrenze u(i) angeben. Das Intervall fur Bucket i ist dann u(i ; 1) + 1u(i)].
KAPITEL 4. KURZESTE
PFADE
105
Setze zu Beginn u(0) := ;1. Die u(i) andern sich im Algorithmus, die size(i) bleiben
konstant. Zu Beginn:
+
Gro
e des dem Bucket i
u(i) := 2i;1 ; 1 fur i = 1 : : : B ; 1
zugeordneten Intervalls:
u(B ) := nC + 1
u(i) ; u(i ; 1) size(i)
Initialisierung: Einfugen aller Schlussel in die Buckets: Durchlaufe, fur Schlussel
k, die Buckets B , B ; 1, : : : bis wir Bucket j nden mit u(j ) < k. Fuge k in
Bucket j + 1 ein. Kosten: n log C .
DecreaseKey : Wie bei Insert, beginne Suche mit momentanem Bucket des
Schlussels. Kosten fur alle DecreaseKey Operationen: O(1) pro DecreaseKey
+O(n log C ).
DeleteMin: Suche von links den ersten nicht leeren Bucket j . Falls j = 1 ist alles
ok (wegen size(1)=1). Falls j 2: Suche minimales Element v im Bucket j (v
wird als FindMin zuruckgegeben und aus der Priority Queue geloscht), verteile
alle anderen Elemente im Bucket j auf die Buckets 1 : : : j ; 1, nachdem die
u(i)'s, wie folgt, aktualisiert wurden:
u(0) := disv] ; 1
u(1) := disv]
u(i) := minfu(i ; 1) + size(i)u(j )g fur i = 2 : : : j ; 1
verkettete Liste
disv] minimal
von Elementen
A
;
;
1 2
3
4
AU
r r vsr r r
@
I
KA ;
;
@A
@A;
disw] disv]
1
r i 2r i r Y3 r i
4
+
s
@
;
;
@
v
Kosten fur alle DeleteMins : O(log C ) pro DeleteMin + O(n log C ).
Gesamtkosten fur Dijkstra's Algorithmus mit einstugen Radix-Heaps damit:
O(m + m + n log C + n log C + n log C ) = O(m + n log C )
Satz: Dijkstra's Algorithmus mit einfstugen Radix-Heaps hat Zeitkomplexitat
O(m + n log C ).
Verbesserungen:
1. zweistuge Heaps: O(m + n logloglogCC )
p
2. mehrstuge Heaps (+Fibonacci-Heaps): O(m + n log C )
Literatur: Akuja, Mehlhorn, Orlin, Tarjan Faster Algorithms for the Shortest
Path Problem. J ACM 37(1990), S. 213-223).
KAPITEL 4. KURZESTE
PFADE
106
4.2.3 Bellman-Ford-Algorithmus
Dieser Algorithmus ist ein Beispiel fur dynamische Programmierung.
Sei Bk i] := Lange eines kurzesten Pfades von s zu Knoten i, der hochstens k
Kanten enthalt.
Gesucht ist Bn;1 i] fur i = 1 n, Menge der Knoten V = f1 ng
Initialisierung:
8
<
d(s i) falls d(s i) < 1 i 6= s
falls i = s
+1 sonst
B1 i] := : 0
Iteration:
for
k = 2 to n ; 1 do
i = 1 ton do
Bk i] := 0min
for
od
j 2N (i) fBk;1 i] Bk;1 j ] + d(j i)g
falls i = s
sonst
od
Korrekheit: klar (Beweis durch vollstandige Induktion)
Zeitbedarf: Wenn die innere Laufschleife durch eine Schleife uber alle Kanten
ersetzt wird:
Zeitbedarf: O(n m)
4.3 Floyd's Algorithmus fur das All-pairs-shortestpath-Problem
Auch genannt "Kleene's Algorithmus\. Dieser Algorithmus ist ein weiteres Beispiel
fur dynamische Programmierung.
Sei G = (V E ) mit Distanzfunktion d:A ! R+0 gegeben. Sei o.B.d.A. V = fv1 : : : vn g.
Sei ckij := Lange eines kurzesten Pfades von vi nach vj , der als innerer Knoten (alle
bis auf ersten und letzten Knoten) nur Knoten aus fvi vk g enthalt.
algorithm floyd:=
p
co
8i : dii = 0
i j
od
c(0) := dij
for alle ( ) do ij
for
:= 1 to do
for alle ( ),n 1
k
c(k)
od
n
i j
i j n
c(k;1) ij := min ij
od
x
Laufzeit: O(n3 )
od
do
c(k;1) + c(k;1)
ik
kj
1 i j n
o
KAPITEL 4. KURZESTE
PFADE
107
Korrektheit:
(k)
Zu zeigen: cij des Algorithmus = ckij (damit sind fur k = n die Kosten der kurzesten
Pfade durch c(ijk) gegeben).
Beweis: Richtig fur k = 0. Induktionsschlu
: Ein kurzester Pfad von vi nach
vj mit inneren Knoten 2 fv1 : : : vk+1 g enthalt entweder vk+1 gar nicht als inneren
Knoten, oder er enthalt vk+1 genau einmal als inneren Knoten. Im ersten Fall wurde
dieser Pfad also bereits fur c(ijk) betrachtet, hat also Lange c(ijk) . Im zweiten Fall
setzt er sich aus einem kurzesten Pfad P1 von vi nach vk+1 und einem kurzesten
Pfad von P2 von vk+1 nach vj zusammen, wobei alle inneren Knoten von P1 und
P2 2 fv1 : : : vk g sind. Also ist die Lange des Pfades = c(ikk)+1 + c(kk+1) j .
3
Satz: Floyd's Algorithmus fur das All-pair-shortest-path-Problem hat Zeitkomplexitat O(n3 ).
4.4 Digraphen mit negativen Kantengewichten
4.4.1 Grundsatzliches
Betrachte Startknoten s und einen Kreis C mit Gesamtlange < 0 und C ist von s
aus erreichbar.
k4 t
st 1 - t 3 - tp p p p p
k
;5 Q
Q 1
Q
+
t
k0 J
J1
J
^
J
k1 t
2-
C
1
Q
t
Q
k3
1
-
t
-v
tk2
Sollte ein Pfad von s nach C und von C nach v existieren, so ist der kurzeste Pfad
nicht deniert. Falls aber die Gesamtlange des Kreises C 0 ist,
k4 t
st 1 - t 3 - tp p p p p
k
Q 1
;3 Q
Q
+
t
k0 J
J1
J
^
J
k1 t
2-
Q
1
t
Q
k3
1
-
t
-v
tk2
dann ist der kurzeste Pfad wohl deniert. Probleme gibt es also nur dann, wenn es
einen Zyklus negativer Lange gibt. Nichtsdestotrotz funktioniert Dijkstra-Algorithmus
bei negativen Kantenlangen nicht.
ws
s;
s
3;
;
;@
;
4
@ ;2
@
v
@
@
s
KAPITEL 4. KURZESTE
PFADE
108
Bei diesem Beispielgraphen (der nicht einmal einen negativen Kreis enthalt) berechnet der Dijkstra-Algorithmus die minimale Entfernung von s nach w falchlicherweise
als 3 (statt 2).
4.4.2 Modikation von Bellman-Ford-Algorithmus
Bk i] gibt nun die Lange eines kurzesten gerichteten s-i-Pfades an, der aus hochstens
k Kanten besteht. Jeder beliebige Kantenzug, der keinen Kreis enthalt, besteht aus
maximal n ; 1 Kanten. In einem Graphen ohne negative Kreise gilt daher:
8i 2 V : Bn i] Bn;1 i]
Gibt es dagegen einen (von s aus erreichbaren) negativen Kreis, so gibt es einen
Knoten i 2 V , bei dem ein Kantenzug aus n Kanten mit der Lange Bn i] diesen
Kreis hauger durchlauft als jeder Kantenzug aus maximal n ; 1 Kanten der Lange
Bn;1 i]. Demnach gilt:
Bn i] < Bn;1 i]
Man kann also in den Algorithmus aus Bellman-Ford einen Test auf negative Kreise
einbauen, indem man in der Rekursion auch 8i 2 V : Bn i] berechnet und direkt
vor der Ausgabe den folgenden Befehl einfugt:
for
i
n do
B i] < Bn;1 i]
1 to
if n then stop.
4.4.3 Modikation von Floyd's-Algorithmus
Falls kein negativer Kreis existiert, funktioniert der Algorithmus weiterhin korrekt.
v1
t
vt2
6
* HH
H
1
1
;6
t
t
H
j v3
H
1
Y
HH1
v6 H
tv5
t
?
1 v4
HH c616 = 5 = c516
c661 = ;6 = c561
c611 = minfc511 c516 + c561 g = ;1
) der Graph enthalt einen negativen Kreis, g.d.w. ein cnii < 0 existiert.
Man kann also in den Algorithmus von Floyd einen Test auf negative Kreise einbauen, indem man direkt vor der Ausgabe den folgenden Befehl einfugt:
for
i
n do
c < 0 then
1 to
if n
ii
stop.
4.4.4 Der Algorithmus von Johnson
Denition: Sei d : A ! R eine Distanzfunktion. Eine Abbildung
r : V ! R hei
t Rekalibrierung, falls gilt:
8(u v) 2 A : r(u) + d(u v) r(v)
KAPITEL 4. KURZESTE
PFADE
109
Beobachtung: Sei r eine Rekalibrierung (fur d). Setze d0(u v) := d(u v) + r(u) ;
r(v). Dann gilt:
d0 (u v) 0
Sei u = v0 ! ! v1 = v ein Pfad. Dann ist:
d-Lange =
r
X
i=1
Demnach ist:
d0 -Lange =
=
=
d(vi vi;1 )
r
X
i=1
r
X
i=1
r
X
i=1
d0 (vi vi;1 )
(d(vi vi;1 ) + r(vi ) ; r(vi;1 )) =
d(vi vi;1 ) + r(vr ) + r(v0 )
Also ist ein d-kurzester Pfad von u(v0 ) nach v(vr ) auch ein d0 -kurzester Pfad und
umgekehrt. Man kann jetzt mit Hilfe von d0 beliebige Algorithmen (Dijkstra, Floyd,
etc.) anwenden.
Berechnung einer Rekalibrierung: a-Algorithmus.
s
s
0
0
0
'
$
sw
d:A!R
su
Graph G
&
v
s
Fuge einen neuen Knoten s
hinzu und verbinde s mit jedem
anderen Knoten v 2 V durch
eine Kante der Lange 0.
%
Berechne sssp von s nach allen anderen Knoten v 2 V (z.B. mit Floyd). Sei r(v)
die dadurch berechnete Entfernung von s zu v 2 V . Dann r Rekalibrierung, denn
es gilt:
r(u) + d(u v) r(v)
4.5 Zusammenfassung
d0
d allgemein
ASSP Dijkstra (Fibonacci): O(mp+ n log n)
Bellman-Ford: O(n m)
Dijkstra (Radix) O(m + n log C )p
apsp Dijkstra: O(n m + n2 minflog n log C g) Johnson: O(n m + n2 log n)
Floyd: O(n3 )()
Floyd: O(n3 )
Bemerkung(): In der Praxis ist der Floyd-Algorithmus bei kleinen n besser als
Dijkstra-Algorithmus.
KAPITEL 4. KURZESTE
PFADE
110
4.6 Transitive Hulle
4.6.1 Min-Plus-Matrix-Produkt und Min-Plus-Transitive Hulle
Ring R(+ )
% -
Semiring N(+ )
% -
Gruppe Halbgruppe
Halbgruppe Halbgruppe
Semiring uber R f1g mit Operationen min und +, jeweils Halbgruppe.
Distributivgesetz a + minfb cg = minfa + b a + cg
Normale Matrixmultiplikation:
A = (aij )1ijn B = (bij )1ijn I = (ij )1ijn
C = A B = (cij )1ijn cij =
Entsprechend fur Min-Plus:
cij = minfaik + bkj 1 k ng
ur1
Z
ur2 Z
r
r
n
X
k=1
aik bkj
aik = d(vi uk )
= d(uk wj )
HHZ
bkj
Z
.XXH
HZ
X
XH
..
XZ
X
H
vi XXX
wj
u
n
XXX
r
r
Anwendung: A = B
kurzeste Wege von vi nach wj in einem Graph (A = B )
0
Imin+ = B
@
0
1
...
11
0
C
A
Sei A Entfernungsmatrix, A = (aij )1ijn = (d(vi vj ))1ijn . Setze aii = 0 fur
i = 1 : : : n.
Betrachte A2 (Min-Plus-Produkt):
A2 = (a(2)
ij )1ij n .
Dann ist a(2)
ij die Lange eines kurzesten Pfades von vi nach vj , der hochstens zwei
Kanten enthalt. Induktion: a(ijk) ist die Lange des kurzesten Pfades von vi nach vj
mit hochstens k Kanten.
Falls die d(vi vj ) alle 0, gibt es immer kurzeste Pfade, die n ; 1 Kanten enthalten.
Alternative Losung des All-Pairs-Shortest-Path-Problems: Berechne An;1 (MinPlus). Es genugt auch A2dlog(n;1)e (nicht A2 A3 A4 : : : berechnen, sondern wiederholt quadrieren).
A := mini0 fAi g hei
t Min-Plus-Transitive Hulle.
Bemerkung: Min wird Komponentenweise gebildet. Wenn d 0, dann A = An;1 .
KAPITEL 4. KURZESTE
PFADE
111
4.6.2 Boolesche Matrixmuliplikation und Transitive Hulle
Ersetze in 4.6.1. Distanzmatrix durch (Boolesche) Adjazenzmatrix und ersetze MinPlus durch _ ^, d.h.:
C = A B cij =
n
_
k=1
aik ^ bkj
Setze aii = 1 1 i n
Dann gilt fur Ak (Boolesches Produkt, A0 = I )
8
>
>
<
aij = >
>
:
1 falls es im Graphen einen Pfad von vi nach vj bestehend aus k Kanten gibt
0 falls es im Graphen keinen Pfad von vi nach vj bestehend aus k Kanten gibt
Transitive Hulle
A :=
_
i0
Ai
ist damit die Adjazenzmatrix der transitiven Hulle des zugrundeliegenden Graphen
(= An;1 ).
Satz: Sei M(n) die Zeitkomplexitat fur das Boolesche Produkt zweier n n Matrizen, T(n) die Zeitkomplexitat fur die transitive Hulle einer n n Booleschen
Matrix.
Falls T(3
n) {z
cT(n}) und |M(2n) {z
4M(n}), dann gilt:
|
sicher erfullt, falls
T polynomiell
sicher erfullt, falls
M(n) n2
T(n) = !(M(n))
Beweis:
Matrixmultiplikation "1 transitive Hulle:
Gegeben: A B Gesucht: C = A B (Boolesches Produkt) Setze:
19
0
0 A 0 =
L = @0 0 B A 3n
0 0 0
|
{z
3n
}
L ist Adjazenzmatrix eines tripartiten, gerichteten Graphen, denn:
u
v
w
ur1
vr1
wr1
u v w
:
XXX
XX
u 0 A 0
z X
*..
..
A ...
B v 0 0 B
.
.
w 0 0 0
r
un
1x
y bedeutet "reduziere x auf y\
r
- vn
r
wn
KAPITEL 4. KURZESTE
PFADE
112
Daher kann L leicht bestimmt werden:
0
1
I A AB
L = @0 I B A
0 0 I
Also gilt: M(n) T(3n) = O(T(n)).
Transitive Hulle " Matrixmultiplikation
Gegeben: L nn Boolesche Matrix gesucht: L Annahme: n ist Zweierpotenz.
Teile auf:
B
L = CA D
|{z} |{z}
n2
g n2 L = E F
g n2
G H
n2
Dann gilt:
E = (A _ BD C ) betrachte alle Pfade von der ersten Halfte
F = EBD
G = D CE
H = D _ GF
der Knoten zur ersten Halfte der Knoten
analog
analog
analog
Um L zu berechnen, benotigen wir zwei Transitive-Hulle-Berechnungen und
sechs Matrixprodukte fur Matrizen der Dimension n2 n2 , plus Aufwand fur
_, der c0 n2 ist. Also:
T(n) 2T( n2 ) + 6M( n2 ) + c0 n2
jBehauptung:
jBeweis:
j
2cM( n2 ) + 6M( n2 ) + c0 n2 jVorauss.:
j
41 (2c + 6 + 4c0 )M(n)
cM(n)
T(n) cM(n)
durchpInduktion:
n=1
M(2n) 4M(n)
M(n) n2
falls c 41 (2c + 6 + 4c0 ), also falls c 3 + 2c0 .
Also T(n) = O(M(n)).
3
4.6.3 Der 4-Russen-Algorithmus fur Boolesche Matrixmultiplikation
Autoren:
V.L. Avlazarov, E.A. Dinic, M.A. Kronod, I.A. Faradzev : \On economical construction of the transitive closure of a directed graph", Soviet Math. Doklady 11
(1970), p. 1209{1210.
Gegeben zwei Boolesche n n Matrizen A, B gesucht: C = A B .
Sei l := blog nc, o.B.d.A. gelte ljn (l ist Teiler von n).
KAPITEL 4. KURZESTE
PFADE
113
j-te
Spalte
C
cij
ppp
=i-te
Zeile
A
ppppppppppppppppppp
Teile A auf (setze m := nl ):
B
n
B1
B2
l l l l
n A1 A2 A nl
ppp pp
ppp ppp
ppp ppp
pp
l
l
l
l
..
.
Bm
Sei A = A01 _ A02 _ _ A0m Ci := Ai Bi fur i = 1 : : : m. Dann gilt
C=
m
_
i=1
Ci da
C =AB =
m
_
i=1
A0i
!
m
_
i=1
!
Bi0 =
_
1im
1jm
A0i Bj0 =
m
_
i=1
Ai Bi da Ai Bj = 0 fur i 6= j (fasse Ai und Bj als n n Matrizen auf mit 0 au
erhalb des
jeweiligen Streifens). Gegeben die Ci 's, benotigen wir Zeit O(mn2 ).
Betrachte eine Zeile von Ci :
Ai
Ci
c(ki) =
=
c(ki)
k-te
Zeile
k
010110
n
Bi
b(ji)
0
1
0
1
1
0
n
l
l
_
j =1
l
a(ki) b(ji)
Der Algorithmus berechnet einfach zunachst alle Booleschen Linearkombinationen
der Zeilen von Bi (Prozedur bcomb) und damit c(ki) fur jedes mogliche a(ki) .
Betrachte A, B und C als Matrizen von Zeilenvektoren:
0
a1
1
0
b1
1
0
c1
1
B.C
B.C
.C
A=B
@ .. A B = @ .. A C = @ .. A
an
bn
cn
i
proc bcomb(int ) =
p
: : : 0]
j
2blog nc ; 1 do
p := blog j c co p Index der vordersten
combj ] :=combj ; 2p ] _ b(i;1)blog nc+p+1
comb0] := 0
for := 1 to
od
x
1 von
j
oc
KAPITEL 4. KURZESTE
PFADE
114
Zeitbedarf:
(a) sequentiell: O(n2 )
(b) Vektoroperationen der Breite n: O(n)
algorithm four-russians(array
p
a b c
a b c)
=
sind als Vektor von
co die Matrizen
const = log
co wir nehmen
an oc
array comb0 2l;1] of boolean-vector
l b nc
::
for
for
i := 1
to
n
do
ljn
ci] := 0 : : : 0]
n
Zeilenvektoren organisiert oc
od
to nl do
co Berechne die i 's oc
bcomb( )
for := 1 to n do
co Bitmuster in der -ten Zeile von i in Bin
arzahl wandeln oc
:= 0
for
:=
downto (
1) + 1 do
if ] then := + + 1 else := + fi
od
] := ] comb ]
od
i := 1
j
C
i
nc
cj
j
k
il
a j k
cj_
nc
A
i; l
nc nc
nc
nc nc
nc
od
x
Beispiel:
..
.
Ai
..
.
k-te 010110
Zeile
6
6
Spalte
Spalte
(i ; 1)l + 1
il
0
1
0
1
1
0
Bi
Zeitbedarf:
(a) sequentiell:
;
;
O nl n2 + n(l + n) = O nl3 = O logn3n
(b) Vektorrechner der Breite n (Interpretation eines Bitintervalls als Zahl in O(1)
Zeit):
;
O nl (n + n(1 + 1)) = O logn2n (Vektoroperationen)
Satz: Der 4-Russen Algorithmus
berechnet das Produkt
zweier Boolescher Ma3 2 n
n
trizen sequentiell in Zeit O log n bzw. mit O log n Vektoroperationen.
Beweis: p (s.o.)
3
KAPITEL 4. KURZESTE
PFADE
115
4.6.4 Transitive Hulle und DFS
Tiefensuche(DFS):
proc DFS-visit(node
p
v
v)
=
markiere num ] := ++
for alle Nachbarn
von
do
if
unmarkiert then DFS-visit(
od
v
count
u
u
v
u)
fi
x
algorithm DFS =
p
v)
num(
for alle Knoten
do
if
unmarkiert then DFS-visit(
od
fi
for alle Knoten
count := 0
v
do unmarkiere(
v
v
v)
v) := 0
od
x
Bemerkung: Funktioniert fur Graphen und Digraphen.
Nachbarn in Graphen und Digraphen:
vr
ur
u Nachbar von v
v Nachbar von u
vr
r
-u
u Nachbar von v
Beispiele fur DFS:
Graph G1 :
q
q
q
1
q q
q
q5 9q
;
;;
!
q
q q q
q
q 4 q ;q8
q
q 10q; 11q
q
q
6
Digraph G2 :
1q
qI
;@
;I
q; ;@q6 q DFS ;2 q@; q65 7q
;@
q;@I @R; q;- q ;q?@;;;!6 qI; @R3q -4 q ;q@?8
@q;
q; @R10q
q; @R q 11q
9
;@
;
@
DFS
;@
;
@
@
;
;@
@;
;
@
;
2;
@
3
7@ @
;
@;
Bezeichnungen:
-
Baumkan.
Ruckwartskan.
Querkan.
Vorwartskan.
Bemerkung: Alle Baumkanten zusammen ergeben den DFS-Wald (Spannwald).
KAPITEL 4. KURZESTE
PFADE
116
'
SZK1
qI $
;@
qkSZK5
;
q
@q
q
;@
;
?q ;
Rq -;
@
k
q
q
&
%
SZK2
;@
;@
I
;
Rk
@
;
q
k
q
q
@q
SZK3
SZK4 SZK6
+
Schrumpfen der SZK's
DAG (Directed Acyclic Graph)
5
1
@
Senke
+
2 @
Quelle
? @
R
?
3
4
6
q
qk qk qk
q
qk
e
Bemerkung: SZK: starke Zusammenhangskomponente (in Digraphen)
DFS in ungerichteten zyklischen Graphen, n Knoten, m Kanten, n ; 1 Baumkanten,
m ; n + 1 Ruckwartskanten.
Zeitaufwand: O(n + m)
A
SZK1
SZK2
SZK1 SZK2
0
B
B
B
B
B
B
B
B
@
11 11
1 1 1
1
1
11 11
1
0
0
C
C
C
C
C
C
C
C
A
A aus DFS mit Aufwand !(n2 ) in ungerichteten Graphen (Anm.: SZK = ZK).
DFS in gerichteten Graphen (Digraphen), n Knoten, m Kanten, Baum-, Vorwarts-,
Ruckwarts- und Querkanten:
r
1
3
;@
@
;
2;
R5
@
;I
;
?
;
-
r
r
r
r r6
4
Bezeichnungen:
-
Baumkanten
Ruckwartskanten
Querkanten
Zeitaufwand: O(n + m)
Es gilt: u ist von v aus auf einem gerichteten Pfad erreichbar g.d.w. u Knoten in
dem DFS-Baum (DFS-visit(v)) mit Wurzel v ist.
Also: Transitive Hulle in Zeit O(n (m + n)) bzw. O(n m). Sehr gut fur dunne
Graphen (also solche mit relativ wenigen Kanten).
KAPITEL 4. KURZESTE
PFADE
117
4.7 Ein besserer Algorithmus fur das All-pairsshortest-distance (bzw. paths)-Problem in ungewichteten Digraphen
(dij )0ij<n Distanzmatrix
alle Kantenlangen = 1
D Distanzmatrix fur Transitive
H
u
lle
falls dij l
D(l) = (d(ijl) )oij<n mit d(ijl) = d1ij sonst
algorithm 1 =
p
dij 1
A = (aij )0ij<n mit aij = 10 falls
sonst
co Sei B die Boolsche Einheitsmatrix oc
for l := 2 to r + 1 do
B := A B for 0 i j < n do
(l)
(l)
if bij = 1 then dij := l else dij := 1 fi
(
l
;
1)
(
l
)
(
l
;
1)
l then dij := dij fi
if dij
co Sei
oc
od
od
x
Dieser Algorithmus berechnet D(1) = D D(2) D(3) : : : D(r) .
Sei ! eine Zahl 2, so da
die Matrixmultiplikation in der Zeit O(n! ) durchgefuhrt
werden kann (Winograd/Coppersmith: ! 2 376).
Zeitaufwand fur Algorithmus 1: O(rn! )
algorithm apsd =
p
D(l)
f
ur l = 1 : : : r
l := r
l
m
for s := 1 to log 3 n
do
2 r
for i := 0 to n ; 1 do
finde in der i-ten Zeile von D(l) den Wert d, 2l d l, so da d in der
i-ten Zeile am wenigsten oft vorkommt
Si := Menge der Spaltenindizes, in denen dieses d in der i-ten Zeile von
D(l) vorkommt
Berechne, mit Algorithmus 1,
od
l1 := 32 l
for
0 i j < n do
Si 6= then mij := kmin
fd(l) + d(kjl) g
2Si ik
(l)
(l )
(l)
if dij l then dij1 := dij
(l )
elseif mij l1 then dij1 = mij
(l )
else dij1 := 1
if
fi
od
od
x
l := l1 else
mij := 1
fi
KAPITEL 4. KURZESTE
PFADE
118
apsd berechnet:
Zunachst D(1) : : : D(r), dann D(l) fur
# $ # # $$
n0
l = r 32 r 32 32 r : : : |{z}
n
ir
k 2 Si
r
d
z
}|
{?
z
d 32 le;d l
}|
{
rj
Da fur d 2l Werte zur Auswahl stehen, gilt:
jS j 2n
i
l
Damit 0
ist die Laufzeit:
B
!
OB
Brn +
@
log 32 nr
X
s=1
1
n3
( 32 )s r
C
C
C
A
3
= O rn! + nr
Setze r so, da
die beiden Summanden
gleich sind, also r = n 3;2 ! , dann ergibt sich
damit fur apsd die Laufzeit O n 3+2! .
Satz: Das All-Pairs-Shortest-Distance-Problem
fur Digraphen mit Kantenlange
= 1 la
t sich in Zeit O(n 3+2! ) losen (! Exponent fur Matrixmultiplikation).
Beweis: p
3
Bemerkung: apsp: Problem: Ausgabegro
e kann (n3 ) sein:
n Knoten q
- q - q - q q - q - q n Knoten
3
3
|
{z
n Knoten
3
}
Kurzeste Pfade-Nachfolger-Matrix N 2 0 : : : n ; 1]nn
nij = Nummer des zweiten Knoten auf "dem\ kurzesten Pfad von Knoten i zu
Knoten j . So eine Matrixdarstellung
fur die kurzesten Pfade zwischen allen Knotenpaaren kann in Zeit O(n 3+2! logc n) fur ein c > 0 bestimmt werden.
Satz: Fur Digraphen mit Kantenlangen 2 f1 2 : : : M g M 2 N, kann APSD in
Zeit O((Mn) 3+2! ) gelost werden.
Idee: Ersetze
ru M 0M-vr durch:
u = ru0 -ur1 -ur2 r
u-Mr0 = v
4.8 Ein Algorithmus fur die transitive Hulle in Digraphen mit linearer erwarteter Laufzeit
Die Wahrscheinlichkeit eines Digraphen mit n Knoten und m Kanten ist (nur) eine
Funktion von n und m. Daraus folgt (wir lassen der Einfachheit halber Schleifen
KAPITEL 4. KURZESTE
PFADE
119
(=Kanten v ! v) zu), da
jede Kante (u v) mit Wahrscheinlichkeit nm2 vorhanden
ist, falls wir Graphen mit n Knoten und m Kanten betrachten.
Einschub: Breitensuche (BFS): Schlange, queue, FIFO:
FIFO
Durchlaufe Graphen, indem wir, solange moglich den vordersten Knoten v aus der
Queue nehmen, ihn behandeln und die Liste seiner noch nicht behandelten Nachbarn in die queue hinten einfugen.
Beispiel:
12q
q q10
@
q
q q q q?13@@R- q14
q
q q8
4q
5
6
q?
7
1
;@ @
I
@
;
@
2;
R 3 @9 - 11
@
;@
@ 6
;
@
@
;
R
@
R
@
- -?
Bezeichnungen:
- Baumkanten
- Querkanten
algorithm exp-lin-transitive-closure
(C.P. Schnorr, An Algorithm for Transitive Closure with Linear Expected Time,
SIAM Journal on Computing 7 (1978), pages 127-133.)
Phasen:
0. Konstruiere die linear geordneten Adjazenzlisten Lri i = 1 : : : n des Graphen
Gr (entsteht aus G durch Umkehrung aller Knoten).
Beispiel:
= 4 1 2 Lr1 = 1 2 4
= 1 4 3 Lr2 = 1 3 4
= 3 2
Lr3 = 2 3
= 1 4 2 Lr4 = 1 2 4
Ersetze ebenfalls alle Li durch Lrr
i (! sortierte Adjazenzlisten)
1. Berechne fur jeden Knoten i in BFS-Art eine Liste Si von von i aus erreichbaren Knoten, so da
(i) oder (ii) gilt:
(i) jSi j < b n2 c + 1 und Si enthalt alle von i aus erreichbaren Knoten
(ii) jSi j = b n2 c + 1
2. Entsprechende Listen Pi von Vorgangern von i
3.
for i := 1 to n do
Li := Si fj i 2 Pj g fj jSi j = jPj j = b n2 c + 1g
L1
L2
L3
L4
od
Bilde (Li )rr fur i = 1 : : : n
Korrektheit: j 2 Li g.d.w. (i j ) in transitiver Hulle.
Satz: Sei die Wahrscheinlichkeit eines Graphen (lediglich) eine Funktion der Anzahl n seiner Knoten und der der Anzahl m seiner Kanten. Dann ist der Erwartungswert fur die Laufzeit des Schnorr'schen Algorithmus O(n + m ), wobei m
der Erwartungswert fur die Anzahl der Kanten in der transitiven Hulle ist.
KAPITEL 4. KURZESTE
PFADE
120
Beweis: Das Durchlaufen des Graphen (von V1 aus fur die Konstruktion von S1) in
BFS-Manier liefert eine Folge (at )t1 von Knoten. Sei L( ) die -te Adjazenzliste,
die in der BFS erkundet wird,
L( ) = (at h( ) < t h( + 1))
Sei $L( ) die Menge der at in L( ) , und sei
Si (t) := fa1 a2 : : : at g
Wie bereits gezeigt, ist
WS(j 2 Li ) = nm2 8i j
Alle n-Tupel von geordneten Listen L1 L2 ::: Ln mit
m=
n
X
i=1
jLi j
sind aufgrund der Voraussetzungen uber die Wahrscheinlichkeitsverteilung gleich
wahrscheinlich.
Also:
Beobachtung 1: Die Mengen $L( ) = 1 2 : : : sind (paarweise) unabhangig.
Beobachtung 2: Die $L( ) sind gleichverteilt, d.h. fur alle A f1 : : : ng gilt:
WS($L( ) = A) = ( nm2 )jAj (1 ; nm2 )n;jAj
Lemma: Sei A f1 : : : ng mit jAj = k. Sei (*at)t1 eine Folge von unabhangigen
gleichverteilten Zufallsvariablen mit Wertemenge f1 : : : ng. Dann gilt:
minft a*t 62 Ag hat Erwartungswert 1 + n ;k k :
Beweis: WS(*a1 : : : a*r 2 A und a*r+1 62 A) = ; nk r (1 ; nk ).
Also ist der Erwartungswert fur minft a*t 62 Ag:
1
X
r
1 ; nk
r nk
r=0
r;1
X
k
k
=1+ n 1; n
r nk
r1
k
k
= 1 + n 1 ; n ; 1 k 2
1; n
1+
k
=1+ n k
1; n
= 1 + n ;k k
Anmerkung:
1
X
r=0
d 1 = 1
rz r;1 = dz
1 ; z (1 ; z )2
3
KAPITEL 4. KURZESTE
PFADE
121
Lemma: Sei 3(*at )t1 wie oben, k n2 . Dann hat minft ja*1 a*2 : : : a*tj > kg Erwartungswert 2 (k + 1).
Beweis: Wegen der Additivitat des Erwartungswertes gilt: Der gesuchte Erwartungswert ist
k
X
1+ n;
=0
k
X
k + 1 + n
=1 2
k + 1 + k(k n+ 1)
32 (k + 1)
Wenn wir jedes L( ) in sich zufallig permutieren, erhalten wir eine Folge (*at )0t3
1
von Zufallsvariablen, so da
jfa1 : : : at gj = jfa01 : : : a0t gj fur t = h( ) 8
Da die a0t innerhalb eines jeden Intervalls h( ) < t h( +1) paarweise verschieden
sind, gilt fur sie die vorhergehende Abschatzung erst recht. Daher sind (jS1 (t)j)t1
und (jS1 (t)0 j)t1 gleichverteilte Folgen von Zufallsvariablen, denn dies gilt zunachst
fur alle Zeitpunkte der Form t = h(y) da aber fur diese Zeitpunkte S1 (t) = S10 (t)
ist, und h() zufallig verteilt ist, ist auch die Verteilung der beiden Folgen zwischen
diesen Intervallgrenzen identisch.
Sei s der Erwartungswert und sei jSi j die tatsachliche Gro
e von Si nach der Phase
1. Dann
s=
b nX
2 c+1
k=1
k WS(jSi j = k)
Die erwartete Anzahl der Schritte (und damit die Kosten) in der BFS sei q. Dann
gilt:
q
b nX
2 c+1
k=1
WS(jSi j = k) 32 k = 32 s:
Also ist der Aufwand des Algorithmus fur die Phasen 1 und 2 im Erwartungswert
3sn. Da ns = m , und da die Kosten der anderen Phasen oensichtlich durch
O(n + m + m ) beschrankt sind, folgt die Behauptung.
3
4.9 Matrizenmultiplikation a la Strassen
a11 a12 b11 b12 = c11 c12 c = a b + a b
ij
i1 1j
i2 2j
a21 a22
b21 b22
c21 c22
KAPITEL 4. KURZESTE
PFADE
Bilde:
m1
m2
m3
m4
m5
m6
m7
122
:= (a12 ; a22 )(b21 + b22 )
:= (a11 + a22 )(b11 + b22 )
:= (a11 ; a21 )(b11 + b12 )
:= (a11 + a12 )b22
:= a11 (b12 ; b22 )
:= a22 (b21 ; b11 )
:= (a21 + a22 )b11
Dann gilt:
c11
c12
c21
c22
:= m1 + m2 ; m4 ; m6
:= m4 + m5
:= m6 + m7
:= m2 ; m3 + m5 ; m7
Sei n = 2k und M(n) die Anzahl arithmetischer Operationen (Mult, Add, Sub), die
Strassen's Algorithmus bei n n Matrizen benotigt:
M(1) = 1 ; ; M(n) = 7M n2 + 18 n2 2
Expansion dieser Rekursionsgleichung !
M(n) = 7k+1 ; 6n2 = 7 2k log2 7 ; 6n2 = 7nlog2 7 ; 6n2 < 7n281 ; 6n2
procedure Matmult(
A B n)
=
kill
p
A
n<
nn
B
und
sind
Matrizen oc
co
if
16 then berechne
mit klassischer Methode
gerade then
elseif
n
spalte
und
in je 4 n
2 2 Matrizen auf und wende Strassen's Formeln
an. F
uhre die Multiplikationen rekursiv mit Matmult aus.
else
spalte
und
in je eine (
1) ( 1) Matrix ( 11 11 ) und
drei verbleibende Bl
ocke auf. Wende Matmult rekursiv auf 11 , 11 an
und berechne die anderen Produkte mit klassischer Methode.
fi
fi
n
A
B
A
B
AB
n; n;
A B
A
B
x
Satz: Der Matmult-Algorithmus hat folgende Eigenschaften:
1. Fur n < 16 ist die Anzahl der arithmetischen Operationen genauso hoch wie
bei der klassischen Methode.
2. Fur n 16 ist die Anzahl der arithmetischen Operationen echt kleiner als
bei der klassischen Methode.
3. Matmult braucht nie mehr als 4:8nlog2 7 arithmetische Operationen.
Beweis:
p
1.
KAPITEL 4. KURZESTE
PFADE
123
2. Sei n gerade und seien A, B zwei n n Matrizen. Wir wenden Strassen's
Formeln an, fuhren aber die 7 Multiplikationen der n2 n2 Matrizen mit klassischer Methode aus.
Gesamtzahl arithmetischer Operationen:
3
2 2
n
n
2
7 2 2 ; 2
+ 18 n2 = 74 n3 + 11
4n
Dies ist besser als die klassische Methode, falls:
7 n3 + 11 n2 < 2n3 ; n2 , 15 n2 < 1 n3 , 15 < n , n 16
4
4
4
4
Sei n ungerade. Multiplizieren wir A B mit klassischer Methode, so auch
A11 B11 . Also brauchen wir durch Anwendung von Strassen's Formeln auf
die (n ; 1) (n ; 1) Matrizen (n ; 1 gerade) weniger Operationen, wenn
n ; 1 16 ist.
Durch Induktion uber die Anzahl der rekursiven Anwendungen von Strassen's
Formeln folgt die Behauptung.
3. Sei M0 (n) die Anzahl arithmetischer Operationen. Dann ist:
8
<
2n3 ;; n2
falls n < 16
falls n 16 gerade
M0 (n) = : 7M0 ; n2 + 184 n2
7M0 n;2 1 + 424 n2 ; 17n + 152 falls n 16 ungerade
Wir denieren fur x 2 R+ :
x3 ;; x 2
falls x < 32
M(x) = 27M
x + 42 x2 falls x 32
2
4
Dann gilt:
M(n) M0 (n) fur alle n 2 N
Weiterhin ist
kP
;1 h
M0 (x) =
7i 42 xi
i+=0, x 4 -2
k := min l , 2l < 32
;
2 i
; ; + 7k 2 2xk 3 ; 2xk 2 fur x 32, wobei
Mit k = blog2 xc ; 4 = log2 x ; t fur t 2 4 5] erhalten wir:
M(x) 7log2 x
t
13 47
t !
+ 2 87
Fur x < 32 direkt nachrechnen.
4 8 7log2 x fur x 32.
3
Kapitel 5
Matchings in Graphen
5.1 Grundlagen
Denition: Sei G = (V E ) ein ungerichteter, schlichter Graph. Ein
Matching M in G ist eine Teilmenge von E , so da
keine zwei Kanten
aus M einen Endpunkt gemeinsam haben.
r
r
r
r
@
@
@
r
r
Matching:
Variante 1
Variante 2
Denition:
1. Ein Matching M in G = (V E ) hei
t perfekt (oder vollkommen),
falls
jM j = jV2 j
2. Ein Matching M hei
t "Matching maximaler Kardinalitat\ (engl.
maximum matching) in G, falls es in G kein Matching M 0 mit
jM 0 j > jM j gibt. (! durchgehend geringelt (rot) im Beispiel)
3. Ein Matching M hei
t maximal in G, falls es bezuglich "\ maximal ist. (engl. maximal matching, ! gepunktet geringelt (grun)
im Beispiel)
Denition:
1. Ein einfacher Pfad (Kreis) v0 v1 : : : vr hei
t alternierend bzgl.
eines Matchings M , falls die Kanten fvi vi+1 g, 0 i < r, abwechselnd in M und nicht in M liegen.
124
KAPITEL 5. MATCHINGS IN GRAPHEN
vr0
vr1
vr2
vr3
125
vr4
gerade Lange
vr0
vr1
vr3
vr2
2. Ein alternierender Pfad hei
t augmentierend, falls er bzgl. "\ maximal ist und an beiden Enden ungematchte Kanten hat.
A
?
vr0
vr1
vr2
vr3
ungerade Lange
vr4
rv5 ?
Bemerkung: Es kann keine augmentierenden Kreise geben.
Denition: Sei G = (V E ) ein Graph. Wenn V in zwei nichtleere Teilmengen V1 und V2 partitioniert werden kann (V1 V2 = V , V1 \ V2 = ),
so da
E V1 V2 ist, so hei
t G bipartit (G = (V1 V2 E )).
Heiratssatz: (Frobenius, Hall, Rado, Konig)
Sei G = (V1 V2 E ) ein bipartiter Graph. G enthalt ein Matching der Kardinalitat
jV1 j genau dann, wenn gilt:
8V V1 : jN (V )j jV j
wobei N(V ) die Nachbarschaft von V (in V2 ) bezeichnet.
rPP
r rPPPP;PP;;Pr
rPP;PPPr r PVr2
;
V1
Satz: Ein Graph G = (V E ) hat ein perfektes Matching genau dann, wenn jV j
gerade ist und es kein S V gibt, so da
der durch V n S induzierte Teilgraph
mehr als jS j Zusammenhangskomponenten ungerader Gro
e enthalt.
r r
r r
r r
Satz:(Berge, 1957)
r '$
r r
&%
r
r
S
r r
Ein Matching hat maximale Kardinalitat genau dann, wenn es keinen augmentierenden Pfad dafur gibt.
KAPITEL 5. MATCHINGS IN GRAPHEN
126
Denition: Seien S , T zwei Mengen, dann bezeichne S # T die symmetrische Dierenz von S und T , d.h. S # T = (S ; T ) (T ; S ).
Lemma: Sei M ein Matching, P ein augmentierender Pfad bzgl. M . Dann ist auch
M # P ein Matching und es gilt jM # P j = jM j + 1.
Beweis:
"(\
q q q q q q q q q Pq
")\ Satz von Berge
M #P
M
3
Lemma: Seien M , N Matchings in G, und sei jN j > jM j. Dann enthalt N # M
mindestens jN j ; jM j knotendisjunkte augmentierende Pfade bzgl. M .
Beweis: Der Grad eines Knotens in (V N # M ) ist 2.
Die Zusammenhangskomponenten von (V N # M ) sind also
1. isolierte Knoten
2. einfache Kreise (gerade Lange)
3. alternierende Pfade
Seien C1 : : : Cr die Zusammenhangskomponenten in (V N # M ) dann gilt:
M # C| 1 # C2 {z
# : : : # C}r = N
N M
Nur die Ci 's die augmentierende Pfade bzgl. M sind, vergro
ern die Kardinalitat
des Matchings und zwar jeweils um genau 1. Also mu
es mindestens jN j;jM j Ci 's
geben, die augmentierende Pfade bzgl. M sind (ev. knotendisjunkt da ZHK's). 3
Korollar: Satz von Berge
Lemma: Sei M ein Matching der Kardinalitat r, und sei s die maximale Kardinalitat eines Matchings in G = (V E ). Dann gibt es einen augmentierenden Pfad
bzgl. M der Lange 2b s;r r c + 1, wobei s > r vorausgesetzt sei.
Beweis: Sei N ein Matching maximaler Kardinalitat in G, jN j = s. N # M
enthalt s ; r augmentierende Pfade bzgl. M , die alle knotendisjunkt und damit auch kantendisjunkt sind. Einer dieser augmentierenden Pfade enthalt daher
b s;r r c Kanten aus M .
3
Lemma: Sei P ein kurzester augmentierender Pfad bzgl. M und sei P 0 ein augmentierender Pfad bzgl. des neuen Matchings M # P . Dann gilt:
jP 0 j jP j + 2jP \ P 0 j
KAPITEL 5. MATCHINGS IN GRAPHEN
127
Beweis: N = M # P # P 0, also N = jM j + 2. Also enthalt M # N mindestens 2
knotendisjunkte augmentierende Pfade bzgl. M , etwa P1 P2 . Es gilt:
N # M = P # P 0 , also
jP # P 0 j Def.
= j(P ; P 0 ) (P 0 ; P )j = jP j + jP 0 j ; 2jP \ P 0 j jP1 j + jP2 j 2jP j,
also jP j + jP 0 j ; 2jP \ P 0 j 2jP j also
jP 0 j 2| jP j{z; jP}j +2jP \ P 0 j
3
jP j
Schema fur Matching Algorithmus:
1. Beginne mit Matching M0 := .
2. Berechne Folge M0 P0 M1 P1 : : : Mi Pi : : : Wobei jeweils Pi ein kurzester
augmentierender Pfad bzgl. Mi ist und Mi+1 = Mi # Pi .
Es gilt: jPi+1 j jPi j
Lemma: Seien Pi und Pj in obiger Folge zwei augmentierende Pfade gleicher Lange.
Dann sind Pi und Pj knotendisjunkt.
Beweis: Annahme: es gibt eine Folge (Pk )k0 mit jPi j = jPj j, j > i, Pi \ Pj 6= 0,
j ; i minimal gewahlt. Durch die Wahl von j sind die Pfade Pi+1 : : : Pj knotendisjunkt. Also ist Pj ein augmentierender Pfad bzgl. M 0 , dem Matching nach dem
augmentieren mit P0 P1 : : : Pi . Mit vorigem Lemma: jPj j jPi j + 2jPi \ Pj j
also Pi Pj kantendisjunkt. Da in M 0 jeder Knoten in Pi gematcht ist (und auch in
M 0 # Pi+1 # Pi+2 # : : : # Pj;1 ) konnen Pi und Pj auch keinen Knoten gemeinsam
3
haben.
Satz: Sei s die maximale Kardinalitat eines
p Matchings in G = (V E ). Dann
enthalt die Folge jP0 j jP1 j : : : hochstens b2 s + 1c verschiedene Werte.
Beweis: Sei r := bs ; psc. Per Konstruktion ist jMij = i, also jMr j = r. Mit
dem Lemma uber die maximale Lange eines kurzesten augmentierenden Pfades
folgt
psc b
s
;
s
jPr j 2 s ; bs ; psc + 1 2 ps + 1 = 2bpsc + 1:
p
F
ur i r ist also jPi j eine der ungeraden Zahlen in 1 2 s + 1], alsop eine von
p
b sc +1 ungeraden Zahlen. Pr+1 : : : {s;1 tragen hochstens s ; r ; 1 < s zusatz
3
liche Langen bei.
Verfeinertes Schema:
M := while 9 augmentierender Pfad bzgl. M do
l := L
ange des k
urzesten augmentierenden Pfades bzgl. M bestimme eine bzgl. \ maximale Menge fQ1 : : : Qm g
"
augmentierender Pfade bzgl. M , die alle L
ange l haben und
M := M # Q1 # : : : # Qm
knotendisjunkt sind
od
Korollar: In obiger while-Schleife nden hochstens O jV j 12 Durchlaufe statt.
KAPITEL 5. MATCHINGS IN GRAPHEN
128
5.2 Matchings maximaler Kardinalitat in bipartiten Graphen
Gegeben: G = (V1 V2 E ) bipartiter Graph.
Simultane BFS zur Bestimmung der Lange eines kurzesten augmentierten Pfades.
p
v 2 V1 V2
labelv] := 0
for alle
od
do
rHH r
rHHHHHr
r HHHHr
rXXXX Hr
XXr
r
R := l := 1
v 2 V1 do
fv wg 2 E do
labelw] := 1 R := R fwg
for alle freien Knoten
for alle Kanten
od
od
while
R 6= and R enth
alt keinen
L := l++
for alle w 2 R fv wg 2 M do
L := L fvg
labelv] := l
freien Knoten do
V1
L
od
R := l++
for alle v 2 L fv wg 2 E n M
if labelw] = 0 then
R := R fwg
labelw] := l
do
fi
od
od
R :=
x
Menge der freien Knoten in R
V1
Kopie der
Knoten von
V2
rHH
r
HH
rHH HHr
H
H
rH@H HHr
@H
H
@
r @HHr
@
r
@r
V1
frei
V2
V1
V2
r
r r r
rQm r r r freie
Q
Knoten
Q
Q
r Qr r@A r ;in R
R
A@;
r
r r AA@rm;
L
r
r r AAr
V2
R