Kap. 7: Dynamische Algorithmen für kürzeste Wege

Kap. 7: Dynamische Algorithmen
für kürzeste Wege
Professor Dr. Petra Mutzel
Lehrstuhl für Algorithm Engineering, LS11
Fakultät für Informatik, TU Dortmund
27./28. VO
A&D
WS 08/09 3./5. Februar 2009
Petra Mutzel
Alg. & Dat.
WS 08/09
1
Ankündigung für SS09
•  LVAs von Petra Mutzel
–  (VO DAP2)
–  SE Algorithm Engineering
•  LVAs von Christian Sohler (NEU an LS2,
Nachfolge Fritz Eisenbrand)
–  VO Sublineare Algorithmen 4VO+2UE
–  SE Datenstromalgorithmen
Petra Mutzel
Alg. & Dat.
WS 08/09
2
Ankündigung für SS09
•  Beate Bollig (LS2)
–  Effiziente Algorithmen für den Primzahltest
(2 VO)
–  SE OBDD-basierte Graphalgorithmen
•  Jan Vahrenhold, LS11
–  Erst im WS09/10: Algorithmische
Geometrie 4VO+2UE
Petra Mutzel
Alg. & Dat.
WS 08/09
3
Überblick
7.1 Einführung
–  Dynamische Graphalgorithmen
–  Dynamische Komplexitätsmaße
–  Dijkstra´s SSSP-Algorithmus
–  Analyse: Korrektheit und Laufzeit
7.2 SSSP von Ramalingam & Reps
–  Einführung SP-Teilgraph für SSSP
–  Algorithmus Dynamic SSSP
–  Laufzeit-Analyse
Petra Mutzel
Alg. & Dat.
WS 08/09
4
Literatur für diese VO
•  G. Ramalingam und T. Reps: On the
computational complexity of dynamic graph
problems. Theoretical Computer Science 158,
1996, 233-277
Petra Mutzel
Alg. & Dat.
WS 08/09
5
Literatur für Experimente
•  C. Demetrescu, S. Emiliozzi und G.F. Italiano:
Experimental Analysis of Dynamic All Pairs Shortest
Path Algorithms, Proc. 15th ACM-SIAM Symposium
on Discrete Algorithms (SODA 2004), New Orleans,
369-378.
•  Zeitschriftenversion: C. Demetrescu und G.F.
Italiano: Experimental Analysis of Dynamic All Pairs
Shortest Path Algorithms, ACM Trans-actions on
Algorithms, vol. 2 (4), 2006, S. 578-601.
Petra Mutzel
Alg. & Dat.
WS 08/09
6
Dynamische Graphalgorithmen
Ein dynamischer Algorithmus erhält eine gegebene
Eigenschaft P eines gewichteten Graphen während
dynamischer Änderungen des Graphen, z.B.
–  Einfügen neuer Kanten,
–  Entfernen von Kanten und
–  Kosten-Änderungen der Kanten
Anforderungen an einen dynamischen Algorithmus:
•  schnelle Beantwortung von Anfragen auf Eigenschaft P
•  schnelle Bearbeitung von Update-Operationen, d.h.
schneller als ein statischer Algorithmus, der jedesmal alles
von vorn berechnen muss
Petra Mutzel
Alg. & Dat.
WS 08/09
7
Dynamische Graphalgorithmen
•  Wir betrachten o.E. nur (Kosten-)Änderungen der Kanten.
•  Dies
läßt
sich
leicht
auf
Knoten(kosten)
änderungen
übertragen.
•  Ein dynamischer Algorithmus heißt voll-dynamisch (full
dynamic) wenn er für Erhöhungen von Kantenkosten bzw.
Entfernungen von Kanten als auch für Verminderungen von
Kantenkosten bzw. Hinzufügen neuer Kanten geeignet ist.
•  Sonst heißt er teil-dynamisch (partially dynamic).
Petra Mutzel
Alg. & Dat.
WS 08/09
8
Dynamische Komplexitätsmaße
•  Amortisiert: Worst-Case in Größe des Inputs, wobei der
Durchschnitt über eine Folge von Operationen genommen
wird.
•  Alternativ: Worst-Case in Größe der Änderungen bzgl.
des Inputs und des Outputs
Petra Mutzel
Alg. & Dat.
WS 08/09
9
Worst Case bzgl. der I/O-Änderungen
•  Ein Knoten heißt modifiziert (modified), wenn er oder
eine inzidente Kante einen neuen Input-Wert bekommen
hat oder eingefügt oder entfernt wurde.
•  Ein Knoten heißt betroffen (affected), wenn er entweder
neu eingefügt wurde oder er durch die Änderung einen
neuen Output-Wert bekommen hat.
•  CHANGED:={Menge aller modifizierten oder betroffenen
Knoten}
•  Sei |δ|=|CHANGED|
•  Sei ||δ||=|δ|+Anzahl der zu CHANGED inzidenten Kanten
•  So viele Änderungen sind mindestens notwendig
•  → notwendige Laufzeit
Worst Case bzgl. der I/O-Änderungen
•  Ein dynamischer Algorithmus heißt beschränkt (bounded),
wenn die benötigte Zeit für einen Update Schritt durch eine
Funktion in ||δ|| beschränkt ist.
•  Sonst heißt er unbeschränkt (unbounded).
•  Ein dynamisches Problem heißt unbeschränkt
(unbounded), wenn kein dynamischer beschränkter
Algorithmus existiert.
•  HIER: ein beschränkter dynamischer SSSP Algorithmus
Petra Mutzel
Alg. & Dat.
WS 08/09
11
Kürzeste Wege Probleme
Single-Source Shortest Path (SSSP)
•  Geg.: Graph G=(V,E) mit Kantenkosten c∈R, keine
negativen Kreise, s∈V
•  Gesucht: Kürzeste (s,v)-Wege in G für alle v∈V
All-Pairs Shortest Path (APSP)
•  Geg.: Graph G=(V,E) mit Kantenkosten c∈R, keine
negativen Kreise
•  Gesucht: Kürzeste Wege zwischen allen Knotenpaaren
(Distanzmatrix)
Petra Mutzel
Alg. & Dat.
WS 08/09
12
Dijkstra´s Algorithmus
• 
• 
• 
• 
Graph G gerichtet mit Kantenkosten c≥0
Sei M =„große Zahl“
Sei dist(v) die Distanzmatrix
Q sei Prioritätswarteschlange mit Operationen
–  InsertPrioQ(v,dist(v)): fügt v ein mit Priorität dist(v)
–  ExtractMinQ(): Gibt das Minimum zurück und entfernt
es aus Q
–  DecreasePrioQ(v, dist(v)): Aktualisiert die Priorität von
v in Q auf dist(v)
Petra Mutzel
Alg. & Dat.
WS 08/09
13
Dijkstra´s Algorithmus
•  Q←∅;
dist[s]=0; InsertPrioQ(s,0)
//
S←{s}
•  Für alle Knoten v≠s:
–  Setze
dist[v]=M;
InsertPrioQ(v,M)
•  Solange
Q≠∅:
–  u←ExtractMinQ()
//
Addiere
u
zu
S
–  Für
alle Kanten
(u,v), die u verlassen:
•  Falls
dist[v] > dist[u]+c[u,v]:
– Setze dist[v] ← dist[u]+c(u,v)
– DecreasePrioQ(v,dist[v])
•  Return
dist[]
: edge relaxation. edge scanning
Analyse: Korrektheit
•  Induktion: Nach jeder Iteration ist V in 2 Mengen aufgeteilt: S
und T:=V\S
•  Ind.-Ann. (Invariante)
–  (1) Für v∈S
ist
dist(v)=Länge des kürzesten (s,v)-Weges
–  (2) für v∈T
ist
dist(v)=Länge des kürzesten (s,v)-Weges bei
dem jeder Knoten außer v zu S gehört.
•  Ind.-Schritt: (Ind.Ann. gilt bis Knoten u aufgenommen wird)
–  Knoten u mit kleinstem dist-Wert wird in S aufgenommen.
(1) ist korrekt, denn: Falls ein kürzerer Weg existieren
würde, dann würde dieser einen ersten Knoten in T
benutzen; aber dieser müßte weiter weg von s sein, denn
sein dist-Wert ist größer als der von u. Die „edge
relaxation“ sorgt dafür, dass (2) erfüllt ist.
Petra Mutzel
Alg. & Dat.
WS 08/09
15
Analyse: Laufzeit
•  Sei n=|V| und m=|E|
•  T = n*T(InsertPrioQ()) + n*T(ExtractMinQ())
+ m*T(DecreasePrioQ())
•  Binärer Heap für Q: O( (n+m) log n )
–  T(InsertPrioQ())=O(log n)
–  T(ExtractMinQ())=O(log n)
–  T(DecreasePrioQ())=O(log n)
•  Fibonacci Heap für Q: O(m+n log n)
–  T(InsertPrioQ())=O(1)
–  T(ExtractMinQ())=O(log n) amortisiert
–  T(DecreasePrioQ())=O(1) amortisiert
Petra Mutzel
Alg. & Dat.
WS 08/09
16
5.2 Algorithmus von Ramalingam & Reps
Betrachte folgendes kürzestes Wegeproblem:
Single-Source Shortest Path (SSSP)
•  Geg.: Graph G=(V,E) mit Kantenkosten w∈R,
c >0
keine negativen Kreise, ts∈V
•  Gesucht: Kürzeste (s,v)-Wege
in G für alle v∈V
(v,t)
Petra Mutzel
Alg. & Dat.
WS 08/09
17
5.2 Algorithmus von Ramalingam & Reps
Geg.: Gerichteter Graph G=(V,E) mit positiven Kantenkosten
c(e)∊R, t∈V,
sowie Sequenz der folgenden Operationen:
–  delete_edge(v,w): entferne die Kante (v,w) aus GG´
–  insert_edge(v,w,c): füge die Kante (v,w) in G einG´
–  dist(v): gib die Distanz zwischen Knoten v und t zurück
–  path(v): gib den kürzesten Weg von v nach t aus, falls
einer existiert.
Damit sind auch die folgenden Operationen simulierbar:
–  increase_weight(e,c‘): erhöhe die Kosten von Kante e
auf c‘
–  decrease_weight(e,c‘): reduziere Kosten von e auf c‘
(jeweils durch delete_edge und insert_edge)
Petra Mutzel
Alg. & Dat.
WS 08/09
18
Definitionen
•  Ein Teilgraph T von G heißt kürzester-Wege-Baum für G
mit Senke t, falls
–  T ist ein gerichteter Baum mit Wurzel t
–  V(T) ist die Menge aller Knoten, die t erreichen können,
und
–  für jede Kante (u,v) in T gilt: dist(u) = dist(v)+c(u,v)
Petra Mutzel
Alg. & Dat.
WS 08/09
19
Definitionen
•  Eine Kante heißt SP-Kante, wenn sie auf einem kürzesten
Weg von v nach t liegt für ein v∈V.
•  Eine Kante ist also genau dann SP-Kante, wenn gilt:
dist(u) = dist(v)+c(u,v)
•  Sei SP(G) der durch die Menge aller SP-Kanten induzierte
Teilgraph von G (der kürzeste-Wege Teilgraph).
•  Jeder kürzeste Weg in G ist in SP(G) enthalten und
umgekehrt:
•  Jeder Weg in SP(G) ist ein kürzester Weg in G.
•  Da die Kantengewichte alle positiv sind, ist SP(G) ein
gerichteter, azyklischer Graph.
Petra Mutzel
Alg. & Dat.
WS 08/09
20
Delete_edge(v,w): G→G´
•  Ein Knoten in G´ heißt betroffen, wenn der Wert
distG(v) ≠ distG‘(v) ist.
•  Eine SP-Kante (x,y) heißt betroffen durch die
delete_edge(v,w) Operation, wenn kein Pfad in G´ von x
nach t existiert, der die Kante (x,y) benutzt und Länge
distalt(x) besitzt.
SP(G):
G:
1
w
4
5
8
2
4
2
4
v
3
7
t
4
1
Petra Mutzel
Alg. & Dat.
WS 08/09
21
Delete_edge(v,w): G→G´
•  Ein Knoten in G´ heißt betroffen, wenn der Wert
distG(v) ≠
distG‘(v) ist.
•  Eine SP-Kante (x,y) heißt betroffen durch die
delete_edge(v,w) Operation, wenn kein Pfad in G´ von x
nach t existiert, der die Kante (x,y) benutzt und Länge
distalt(x) besitzt.
Beobachtungen in SP(G)
•  (x,y) ist betroffen ⇔ y ist betroffen
•  Knoten x≠v ist betroffen ⇔ alle ausgehenden SP-Kanten
von x sind betroffen
•  Knoten v selbst ist betroffen ⇔ (v,w) die einzige
ausgehende SP-Kante ist
Algorithmus Delete_edge(v,w)
Phase 1:
•  Bestimme die Menge aller betroffenen Knoten und Kanten
•  Entferne die betroffenen Kanten von SP(G)
Phase 2:
•  Berechne neue dist-Werte aller betroffenen Knoten
•  Aktualisiere SP(G)
Petra Mutzel
Alg. & Dat.
WS 08/09
23
Phase 1 von Delete_edge(v,w)
•  Menge der betroffenen Knoten = Menge der Knoten, die im
Graphen SP(G)-(v,w) keine Verbindung zur Senke t
besitzen.
Algorithmus-Idee:
•  Aufruf von Top-Sort, wenn outdegree von v in SP(G´) = 0.
•  Speichere SP(G) durch Adjazenzlisten: in(v) und out(v),
•  oder nicht explizite Speicherung, sondern durch Test:
dist(x) == dist(y)+c(x,y)
Petra Mutzel
Alg. & Dat.
WS 08/09
24
Phase 2 von Delete_edge(v,w)
•  Sei A die Menge der nicht-betroffenen Knoten
•  Ziel: Berechne dist(x) für alle Knoten in B=V \ A
Algorithmus-Idee:
•  Kontrahiere A zu einem Knoten t´ und ersetze die Kanten
(x,y) durch (x,t´) mit Kosten c(x,y)+dist(y)
•  Aufruf von Dijkstra für den neuen Graphen
SP(G): 1
G:
4
v
3
5
8 2
4
2
4
w
c(5,7)+dist(7)
7
t
4
1
5 c(5,2)+dist(2) A
v 3
c(3,1)+dist(1)
Algorithmus Delete_edge(v,w)
1.  Falls (v,w)∈SP(G)
dann:
2. 
Entferne (v,w) aus SP(G) und E; dekrementiere
outdegSP(v)
3. 
Falls outdegSP(v)==0 dann: // Phase 1
4. 
WorkSet={v}; AffectVert=∅
5.  Solange WorkSet≠∅ do:
6. 
Wähle und entferne Knoten u aus WorkSet
7. 
AffectVert = AffectVert ⋃ {u}
8. 
Für jeden Knoten x mit (x,u)∈SP(G):
9. 
Entferne (x,u) aus SP(G); dekrement. outdegSP(x)
10. 
Falls outdegSP(x)==0 dann:
11. 
WorkSet = WorkSet ⋃ {x}
Petra Mutzel
Alg. & Dat.
WS 08/09
26
Algorithmus Delete_edge(v,w) ff
12. 
13. 
14. 
15. 
16. 
17. 
18. 
19. 
20. 
21. 
22. 
23. 
Q=∅ // Phase 2
Für jeden Knoten a∈AffectVert do {
dist(a) = min({c(a,b)+dist(b)|(a,b)∈E und b∉AffectVert)} ⋃ M
Falls dist(a)≠M
dann InsertPrioQ(a,dist(a))
}
Solange Q≠∅ do:
a←ExtractMinQ()
Für jeden Knoten b∈Succ(a) mit c(a,b)+dist(b)==dist(a)
Füge (a,b) in SP(G) ein; inkrementiere outdegSP(a)
Für jeden Knoten b∈Pred(a) mit c(b,a)+dist(a)<dist(b)
dist(b) = c(b,a)+dist(a)
DecreasePrioQ/InsertPrioQ(b,dist(b))
Petra Mutzel
Alg. & Dat.
WS 08/09
27
Korrektheit zu Phase 1
•  Falls v betroffen ist, wird Zeile 4-11 ausgeführt
•  Diese realisiert TopSort mit Startknoten v auf dem SPTeilgraphen
•  Wenn ein Knoten x betroffen ist, dann existiert kein (x,t)Weg im SP-Graphen und auch alle seine SP-Nachfolger
sind betroffen
•  TopSort findet alle betroffenen Knoten, denn: v hatte vor
der Deletion nur eine Verbindung zur Senke; die SPVorgänger von v, die aus der Queue entfernt werden sind
genau diejenigen, deren einzige Verbindung zu t über
(v,w) lief.
Petra Mutzel
Alg. & Dat.
WS 08/09
28
Korrektheit zu Phase 2
•  Wenn betroffene Knoten existieren, dann ist Q in
Zeile 17 nicht leer
•  Zeile 18-23 führt Dijkstra aus, das ist also wegen der
Korrektheit von Dijkstra korrekt
•  Alle betroffenen Knoten werden irgendwann in Q
aufgenommen, ihre Distanz wird also neu gesetzt
•  Laufzeitbetrachtungen: Nicht betroffene Knoten
werden nicht in Q aufgenommen (wegen Zeile 21)
•  Die SP-Kanten werden korrekt gesetzt
Petra Mutzel
Alg. & Dat.
WS 08/09
29
Laufzeitanalyse
•  Phase 1:
–  Anzahl der Iterationen: |δ|
–  Eine Iteration für Knoten u benötigt O(|Pred(u)|)
–  Gesamt: O(||δ|| )
•  Phase 2: mit Fibonacci Heaps
–  InsertPrioQ() + DecreasePrioQ(): O(1) amortisiert
–  ExtractMinQ() O(log p) mit p=Anzahl der Elemente im
Heap
–  Anzahl der Iterationen: höchstens |δ|
–  Gesamt: O(||δ||+|δ| log |δ|)
–  Laufzeit: O(||δ||+|δ| log |δ|)
Petra Mutzel
Alg. & Dat.
WS 08/09
30
Insert_edge(v,w): G→G´
Beobachtung:
•  Wenn u betroffen ist, dann sehen alle kürzesten Wege in G´
von u nach t folgendermaßen aus:
•  (kürzester (u,v)-Weg, Kante (v,w), kürzester (w,t)-Weg)
u ist betroffen ⇔
distG‘(u,v)+c(v,w)+distG(w) < distG(u)
4
SP(G):
G:
5
1
8
2
4
2
betroffene Knoten:
1
4
w
7
v 1
1
3 4
1
1
1
t
Algorithmus Insert_edge(v,w)
Betrachte neuen kürzesten-Wege Baum Tv für Knoten v:
•  Sei x beliebiger Knoten, u: Elter von x in Tv
•  Wenn x betroffen ist, dann muß auch u betroffen sein, denn
sonst: ex. kürzester Weg P von u nach t ohne Kante (v,w);
dann ist Weg ((x,u),P) auch kürzester Weg; x wäre nicht
betroffen.
•  ⇒
Menge der betroffenen Knoten bilden zusammenhängenden Teilbaum von Tv mit Wurzel v
4
SP(G):
G:
5
1
8
2
4
2
betroffene Knoten:
1
4
w
7
v 1
1
3 4
1
1
1
Tv
t
v
u
x
w
t
Algorithmus Insert_edge(v,w)
Idee: Benutze Dijkstra‘s Algorithmus für Menge der
betroffenen Knoten mit Priorität: dist(x)-dist(v) für alle x
Betrachte neuen kürzesten-Wege Baum Tv für Knoten v:
•  Sei x beliebiger Knoten, u: Elter von x in Tv
•  Wenn x betroffen ist, dann muß auch u betroffen sein, denn
sonst: ex. kürzester Weg P von u nach t ohne Kante (v,w);
dann ist Weg ((x,u),P) auch kürzester Weg; x wäre nicht
betroffen.
•  ⇒
Menge der betroffenen Knoten bilden zusammenhängenden Teilbaum von Tv mit Wurzel v
4
SP(G):
G:
5
1
8
2
4
2
betroffene Knoten:
1
4
w
7
v 1
1
3 4
1
1
1
Tv
t
v
u
x
w
t
Algorithmus Insert_edge((v,w),c)
1. 
2. 
3. 
4. 
5. 
6. 
7. 
8. 
9. 
10. 
Insert_edge (v,w) in G, setze Kosten c(v,w)
Q=∅
Falls c(v,w)+dist(w)<dist(v) dann {
dist(v)= c(v,w)+dist(w)
InsertPrioQ(v,0)
}
Sonst Falls c(v,w)+dist(w) == dist(v) dann {
Füge (v,w) in SP(G) ein
outdeg(v)++
}
Petra Mutzel
Alg. & Dat.
WS 08/09
34
Algorithmus Insert_edge((v,w),c) ff
9.  Solange Q≠∅:
10.  u←ExtractMinQ()
11.  Entferne alle ausgehenden Kanten von u in SP(G) und
update outdeg(u)
12.  Für jeden Knoten x∈Succ(u):
13. 
Falls c(u,x)+dist(x) == dist(u) dann:
14. 
Füge (u,x) in SP(G) ein und aktualisiere outdeg(u)
15.  Für jeden Knoten x∈Pred(u):
16. 
Falls c(x,u)+dist(u) < dist(x) dann {
17. 
dist(x)= c(x,u)+dist(u)
18. 
DecreasePrioQ/InsertPrioQ(x,dist(x)-dist(v)) }
19. 
Sonst Falls c(x,u)+dist(u) == dist(x)
20. 
Füge (x,u) in SP(G) ein und aktualisiere outdeg(x)
Bemerkungen
•  Falls also v betroffen ist, dann wird Dijkstra von v aus
gestartet, jedoch mit den dist[]-Werten zu t.
•  Alle Wege der betroffenen Knoten führen über Knoten v.
•  Da nur die betroffenen Knoten in die Priority Queues
eingefügt werden und dist(v) konstant ist, könnten wir
diese genauso gut mit Priorität dist(x) statt dist(x)-dist(v)
in Q einfügen.
•  Da die Menge der betroffenen Knoten zusammenhängend ist, werden alle betroffenen Knoten in Q
aufgenommen und auch gescanned.
•  Die Distanzen werden korrekt berechnet, wegen der
Korrektheit von Dijkstra
Petra Mutzel
Alg. & Dat.
WS 08/09
36
Laufzeitanalyse
•  mit Fibonacci Heaps
–  InsertPrioQ() + DecreasePrioQ(): O(1) amortisiert
–  ExtractMinQ(): O(log p) mit p=Anzahl der Elemente im
Heap
–  Anzahl der Iterationen: höchstens |δ|
–  Gesamt: O(||δ|| + |δ| log |δ|)
–  Laufzeit: O(||δ|| + |δ| log |δ|)
Petra Mutzel
Alg. & Dat.
WS 08/09
37
Zusammenfassung
•  Theorem: Es gibt einen beschränkten
dynamischen Algorithmus für das SSSP-Problem mit
Laufzeit O(||δ||+|δ| log |δ|) für jede Update-Operation
delete_edge(v,w) und insert_edge(v,w,c).
Petra Mutzel
Alg. & Dat.
WS 08/09
38
Experimenteller Vergleich
•  Test Sets
•  Algorithmen
•  Experimentelle Resultate
von Demetrescu und Italiano 2006
Petra Mutzel
Alg. & Dat.
WS 08/09
39
Experimentelles Setup: Test Sets
•  Zufällig erzeugte Graphen mit zufälliger Update Sequenz
•  Real-World Graphen
–  US Road Networks: ftp://edcftp.cr.usgs.gov
•  148 – 952 Knoten, 434 – 2896 Kanten, Kosten:
≤200.000 (physik. Distanzen)
–  Internet Graphen (AS): http://www.routeviews.org
•  500 – 3000 Knoten, 2406 – 13.734 Kanten, Kosten:
≤20.000
•  Synthetisch erzeugte Graphen (Bottleneck): Zwei bipartite
Komponenten, die über eine einzige Kante miteinander
verbunden sind. Experimentelles Setup:
Plattformen
•  AMD Athlon – 1.8 GHz, 256KB L2 cache, 512MB RAM
•  AMD Athlon – 2.1 GHz, 256KB L2 cache, 768MB RAM
•  Intel Xeon – 500 MHz, 512KB L2 cache, 512MB RAM
•  Intel Pentium 4 – 2.0 GHz, 512KB L2 cache, 2GB RAM
•  Sun UltraSPARC IIi – 440 MHz, 2MB L2 cache, 256MB
RAM
•  IBM Power 4 – 1.1 GHz, 1.4MB L2 cache, 32MB L3
cache, 64GB RAM
Petra Mutzel
Alg. & Dat.
WS 08/09
41
Experimentelles Setup:
Algorithmen
•  D-RRL: dynamischer SSSP von Ramalingam und Reps
•  D-KIN: dynamischer APSP von King
•  D-LHP: dynamischer APSP-LHP von Demetrescu und
Italiano
•  S-LSP: statischer APSP-LSP von Demetrescu und
Italiano
•  S-DIJ: statischer SSSP von Dijkstra (als Referenzcode)
•  Gleiche Datenstrukturen für alle C-Implementierungen
verwendet: (z.B. Heaps, dynamische Arrays, Hashtabellen, Graphen)
Petra Mutzel
Alg. & Dat.
WS 08/09
42
Experimentelles Setup:
Algorithmen
Algorithmus Update Zeit
S-DIJ
O(mn+n2 log n)
Query Speicherplatz
Zeit
O(1)
O(n2)
S-LSP
O(|LSP|+n2 log n)
O(1)
O(n2)
D-RRL
O(mn+n2 log n)
O(1)
O(n2)
D-KIN
O(n2.5√(Clog n)),
C=max Kosten
O(n2 log3n)
O(1)
O(n2.5√C(log n))
O(1)
O(mn log n)
D-LHP
Petra Mutzel
Alg. & Dat.
WS 08/09
44
Laufzeitvergleich für zufällige Graphen
Laufzeit per Update (in msec)
500 Knoten,1000 Updates, Gewichte ∈[1,1000]
Sieger: D-RRL und D-LHP
bei steigender Dichte: D-LHP
Anzahl der Kanten (x 1000)
Speicherplatz für zufällige Graphen
Speicherplatz (in MB)
500 Knoten,1000 Updates, Gewichte∈[1,1000]
Speicher von D-LHP:steigt mit Dichte
Speicher von D-RRL: unabhängig von Dichte
Anzahl der Kanten (x 1000)
Laufzeit für Real-World Graphen (IBM)
Laufzeit per Update (in msec)
US Road Networks,1000 Updates
Anzahl der Knoten
Laufzeit für Real-World Graphen (Sun)
Laufzeit per Update (in msec)
US Road Networks,1000 Updates
Anzahl der Knoten
Laufzeit für Real-World Graphen (IBM)
Laufzeit per Update (in msec)
US Road Networks,1000 Updates
IBM Power 4:
1.4 MB L2 cache,
32 MB L3 cache,
64 GB RAM
Anzahl der Knoten
Laufzeit für Real-World Graphen (Sun)
Laufzeit per Update (in msec)
US Road Networks,1000 Updates
Sun UltraSPARC IIi:
2 MB L2 cache,
512 MB RAM
Anzahl der Knoten
Speicherplatz für Real-World Graphen
Speicherplatz (in MB)
US Road Networks,1000 Updates
Anzahl der Knoten
Laufzeit für Real-World Graphen (IBM)
Laufzeit per Update (in msec)
Internet Networks,1000 Updates
IBM Power 4:
1.4 MB L2 cache,
32 MB L3 cache,
64 GB RAM
Relative Laufzeit D-RRL/D-LHP
Relative Laufzeit auf verschiedenen Plattformen
US Road Networks,1000 Updates
Anzahl der Kanten (x100)
Cache miss ratio D-RRL/D-LHP
Cache Effekte auf dem Colorado Road Network
Cache Größe
Relative Laufzeit auf Bottleneck Graphen
Synthetische Graphen, 500 Knoten, 1000 Up
Laufzeit per Update (in sec)
D-LHP so langsam wie S-LSP
D-RRL langsamer als S-DIJ
IBM Power 4
Anzahl der Kanten (x1000)
ENDE Kap. 7
Und wie geht es weiter?
Prüfungen?
Petra Mutzel
Alg. & Dat.
WS 08/09
56
Prüfungselemente
•  Modulprüfung bzw. Mündliche Fachprüfung:
–  Über VO 4 inkl Ü 2: 9LP
–  Anforderungen:
•  Zusammenhänge des Gebiets
•  Spezielle Fragestellungen einordnen und
bearbeiten
•  Regelmäßige aktive Mitarbeit in Übungen, u.a.
erfolgreiche Präsentationen und bearbeitete
Übungsblätter
•  Mündliche Prüfung: Stoff der VO und Ü (20 Min.)
Petra Mutzel
Alg. & Dat.
WS 08/09
57
Prüfungselemente
•  Leistungsnachweis:
–  Über VO 4 inkl. Ü 2: 9LP
–  Anforderungen:
•  Regelmäßige aktive Mitarbeit in Übungen, u.a.
erfolgreiche Präsentationen und bearbeitete
Übungsblätter
Petra Mutzel
Alg. & Dat.
WS 08/09
58
Themen der Vorlesung
1. 
2. 
3. 
4. 
5. 
6. 
7. 
8. 
Priority Queues: 1.1 Fibonacci Heaps (2-3)
1.2 Externe Array Heaps (4-6)
2. Amortisierte Analyse von Algorithmen (6)
2,5: Suffix Arrays (8-9)
3. String Matching: 3.2 Knuth-Morris-Pratt 3.3 Boyer-Moore (7/10)
3.4 Aho-Corasick 3.5 Bit-Parallelismus (12/13)
(Gastvorlesung J. Singler: Multi-Core using STL (11))
4. Lineare Programmierung (13,14-17) 4.1 Einführung 4.2
Simplex-Algorithmus 4.3 Dualitätstheorem (18) (*)
9.  (Gastvorlesung M. Jünger: Geometrische Dualität (19))
10.  5. Approximationsalgorithmen (18/20)
11.  5,5: Zusammenhang in Graphen (21)
12.  6. Geometrische Algorithmen 6.1 Mehrdimensionale Suchstrukturen
(23-26)
13.  7. Dynamische kürzeste Wege (27/28)
60
Fachprüfung: Ein Thema streichbar; * = nicht streichbar!
Ihre Lieblingsthemen sind:
1. 
2. 
3. 
4. 
5. 
6. 
7. 
8. 
Priority Queues: 1.1 Fibonacci Heaps (2-3)
1.2 Externe Array Heaps (4-6)
2. Amortisierte Analyse von Algorithmen (6)
Suffix Arrays (8-9)
String Matching: 3.2 Knuth-Morris-Pratt 3.3 Boyer-Moore (7/10)
3.4 Aho-Corasick 3.5 Bit-Parallelismus (12/13)
(Gastvorlesung J. Singler: Multi-Core using STL (11))
4. Lineare Programmierung (13,14-17) 4.1 Einführung 4.2 SimplexAlgorithmus 4.3 Dualitätstheorem (18) (*)
9.  (Gastvorlesung M. Jünger: Geometrische Dualität (19))
10.  5. Approximationsalgorithmen (18/20)
11.  10. Zusammenhang in Graphen (21)
12.  6. Geometrische Algorithmen 6.1 Mehrdimensionale
Suchstrukturen (23-26)
13.  7. Dynamische kürzeste Wege (27/28)
Diese Themen fanden Sie gar
nicht schön:
•  Lineare Programmierung
•  Geometrische Algorithmen
Petra Mutzel
Alg. & Dat.
WS 08/09
62