6 Folien/Blatt - Chair 11: ALGORITHM ENGINEERING

Ankündigung für SS09
Kap. 7: Dynamische Algorithmen
für kürzeste Wege
•  LVAs von Petra Mutzel
–  (VO DAP2)
–  SE Algorithm Engineering
Professor Dr. Petra Mutzel
Lehrstuhl für Algorithm Engineering, LS11
Fakultät für Informatik, TU Dortmund
27./28. VO
A&D
–  VO Sublineare Algorithmen 4VO+2UE
–  SE Datenstromalgorithmen
WS 08/09 3./5. Februar 2009
Petra Mutzel
Alg. & Dat.
WS 08/09
1
Petra Mutzel
Alg. & Dat.
WS 08/09
2
Überblick
Ankündigung für SS09
7.1 Einführung
–  Dynamische Graphalgorithmen
–  Dynamische Komplexitätsmaße
–  Dijkstra´s SSSP-Algorithmus
–  Analyse: Korrektheit und Laufzeit
•  Beate Bollig (LS2)
–  Effiziente Algorithmen für den Primzahltest
(2 VO)
–  SE OBDD-basierte Graphalgorithmen
7.2 SSSP von Ramalingam & Reps
•  Jan Vahrenhold, LS11
–  Einführung SP-Teilgraph für SSSP
–  Algorithmus Dynamic SSSP
–  Laufzeit-Analyse
–  Erst im WS09/10: Algorithmische
Geometrie 4VO+2UE
Petra Mutzel
•  LVAs von Christian Sohler (NEU an LS2,
Nachfolge Fritz Eisenbrand)
Alg. & Dat.
WS 08/09
3
Literatur für diese VO
Petra Mutzel
Alg. & Dat.
WS 08/09
4
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.
•  G. Ramalingam und T. Reps: On the
computational complexity of dynamic graph
problems. Theoretical Computer Science 158,
1996, 233-277
•  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
5
Petra Mutzel
Alg. & Dat.
WS 08/09
6
1
Dynamische Graphalgorithmen
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
•  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.
Anforderungen an einen dynamischen Algorithmus:
•  schnelle Beantwortung von Anfragen auf Eigenschaft P
•  Sonst heißt er teil-dynamisch (partially dynamic).
•  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 Komplexitätsmaße
Petra Mutzel
Alg. & Dat.
WS 08/09
8
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.
•  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
•  CHANGED:={Menge aller modifizierten oder betroffenen
Knoten}
•  Sei |δ|=|CHANGED|
•  Sei ||δ||=|δ|+Anzahl der zu CHANGED inzidenten Kanten
Petra Mutzel
Alg. & Dat.
WS 08/09
9
Kürzeste Wege Probleme
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.
Alg. & Dat.
WS 08/09
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)
•  HIER: ein beschränkter dynamischer SSSP Algorithmus
Petra Mutzel
•  So viele Änderungen sind mindestens notwendig
•  → notwendige Laufzeit
11
Petra Mutzel
Alg. & Dat.
WS 08/09
12
2
Dijkstra´s Algorithmus
• 
• 
• 
• 
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
•  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.
Alg. & Dat.
WS 08/09
: edge relaxation. edge scanning
Analyse: Laufzeit
Analyse: Korrektheit
Petra Mutzel
•  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[]
15
5.2 Algorithmus von Ramalingam & Reps
•  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
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.
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)
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
17
Petra Mutzel
Alg. & Dat.
WS 08/09
18
3
Definitionen
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)
•  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)
•  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
19
•  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.
1
w
4
5
8
2
4
2
4
v
3
WS 08/09
20
•  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)
7
•  (x,y) ist betroffen ⇔ y ist betroffen
t
4
•  Knoten x≠v ist betroffen ⇔ alle ausgehenden SP-Kanten
von x sind betroffen
1
Petra Mutzel
Alg. & Dat.
Delete_edge(v,w): G→G´
Delete_edge(v,w): G→G´
SP(G):
G:
Petra Mutzel
•  Knoten v selbst ist betroffen ⇔ (v,w) die einzige
ausgehende SP-Kante ist
Alg. & Dat.
WS 08/09
21
Algorithmus Delete_edge(v,w)
Phase 1 von Delete_edge(v,w)
Phase 1:
•  Bestimme die Menge aller betroffenen Knoten und Kanten
•  Entferne die betroffenen Kanten von SP(G)
•  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.
Phase 2:
•  Berechne neue dist-Werte aller betroffenen Knoten
•  Aktualisiere SP(G)
Petra Mutzel
Alg. & Dat.
WS 08/09
•  Speichere SP(G) durch Adjazenzlisten: in(v) und out(v),
•  oder nicht explizite Speicherung, sondern durch Test:
dist(x) == dist(y)+c(x,y)
23
Petra Mutzel
Alg. & Dat.
WS 08/09
24
4
Algorithmus Delete_edge(v,w)
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
5 c(5,2)+dist(2) A
v 3
c(3,1)+dist(1)
1
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
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
Alg. & Dat.
WS 08/09
26
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
Laufzeitanalyse
Korrektheit zu Phase 2
•  Phase 1:
–  Anzahl der Iterationen: |δ|
–  Eine Iteration für Knoten u benötigt O(|Pred(u)|)
–  Gesamt: O(||δ|| )
•  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
•  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 |δ|)
•  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
–  Laufzeit: O(||δ||+|δ| log |δ|)
Petra Mutzel
Alg. & Dat.
WS 08/09
29
Petra Mutzel
Alg. & Dat.
WS 08/09
30
5
Algorithmus Insert_edge(v,w)
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
1
4
w
7
v 1
1
3 4
1
1
1
t
4
5
2
4
2
betroffene Knoten:
2
4
2
1
4
w
7
v 1
1
3 4
1
1
1
Tv
1
4
w
7
v 1
1
3 4
1
1
1
Tv
t
w
t
u
x
Algorithmus Insert_edge((v,w),c)
t
v
u
x
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)
w
v
t
betroffene Knoten:
Algorithmus Insert_edge(v,w)
8
5
1
8
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
1
4
SP(G):
G:
betroffene Knoten:
SP(G):
G:
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
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
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
6
Laufzeitanalyse
Zusammenfassung
•  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 |δ|)
•  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).
–  Laufzeit: O(||δ|| + |δ| log |δ|)
Petra Mutzel
Alg. & Dat.
WS 08/09
37
Experimenteller Vergleich
Petra Mutzel
Alg. & Dat.
WS 08/09
38
Experimentelles Setup: Test Sets
•  Zufällig erzeugte Graphen mit zufälliger Update Sequenz
•  Test Sets
•  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
•  Algorithmen
•  Experimentelle Resultate
•  Synthetisch erzeugte Graphen (Bottleneck): Zwei bipartite
Komponenten, die über eine einzige Kante miteinander
verbunden sind. von Demetrescu und Italiano 2006
Petra Mutzel
Alg. & Dat.
WS 08/09
39
Experimentelles Setup:
Plattformen
Experimentelles Setup:
Algorithmen
•  AMD Athlon – 1.8 GHz, 256KB L2 cache, 512MB RAM
•  AMD Athlon – 2.1 GHz, 256KB L2 cache, 768MB RAM
•  D-RRL: dynamischer SSSP von Ramalingam und Reps
•  D-KIN: dynamischer APSP von King
•  Intel Xeon – 500 MHz, 512KB L2 cache, 512MB RAM
•  Intel Pentium 4 – 2.0 GHz, 512KB L2 cache, 2GB RAM
•  D-LHP: dynamischer APSP-LHP von Demetrescu und
Italiano
•  S-LSP: statischer APSP-LSP von Demetrescu und
Italiano
•  Sun UltraSPARC IIi – 440 MHz, 2MB L2 cache, 256MB
RAM
•  S-DIJ: statischer SSSP von Dijkstra (als Referenzcode)
•  IBM Power 4 – 1.1 GHz, 1.4MB L2 cache, 32MB L3
cache, 64GB RAM
Petra Mutzel
Alg. & Dat.
WS 08/09
•  Gleiche Datenstrukturen für alle C-Implementierungen
verwendet: (z.B. Heaps, dynamische Arrays, Hashtabellen, Graphen)
41
Petra Mutzel
Alg. & Dat.
WS 08/09
42
7
Experimentelles Setup:
Algorithmen
500 Knoten,1000 Updates, Gewichte ∈[1,1000]
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
O(1)
O(n2)
D-KIN
O(n2.5√(Clog
O(1)
O(n2.5√C(log
O(1)
O(mn log n)
D-LHP
n)
n)),
C=max Kosten
O(n2 log3n)
Petra Mutzel
Alg. & Dat.
WS 08/09
n))
Laufzeit per Update (in msec)
Algorithmus Update Zeit
Laufzeitvergleich für zufällige Graphen
Laufzeit für Real-World Graphen (IBM)
US Road Networks,1000 Updates
Laufzeit per Update (in msec)
500 Knoten,1000 Updates, Gewichte∈[1,1000]
Speicherplatz (in MB)
bei steigender Dichte: D-LHP
Anzahl der Kanten (x 1000)
44
Speicherplatz für zufällige Graphen
Speicher von D-LHP:steigt mit Dichte
Sieger: D-RRL und D-LHP
Speicher von D-RRL: unabhängig von Dichte
Anzahl der Kanten (x 1000)
Anzahl der Knoten
Laufzeit für Real-World Graphen (Sun)
Laufzeit für Real-World Graphen (IBM)
US Road Networks,1000 Updates
Laufzeit per Update (in msec)
Laufzeit per Update (in msec)
US Road Networks,1000 Updates
Anzahl der Knoten
IBM Power 4:
1.4 MB L2 cache,
32 MB L3 cache,
64 GB RAM
Anzahl der Knoten
8
Laufzeit für Real-World Graphen (Sun)
Speicherplatz für Real-World Graphen
US Road Networks,1000 Updates
Sun UltraSPARC IIi:
2 MB L2 cache,
512 MB RAM
Speicherplatz (in MB)
Laufzeit per Update (in msec)
US Road Networks,1000 Updates
Anzahl der Knoten
Anzahl der Knoten
Laufzeit für Real-World Graphen (IBM)
Relative Laufzeit auf verschiedenen Plattformen
Relative Laufzeit D-RRL/D-LHP
Laufzeit per Update (in msec)
Internet Networks,1000 Updates
IBM Power 4:
1.4 MB L2 cache,
32 MB L3 cache,
64 GB RAM
US Road Networks,1000 Updates
Anzahl der Kanten (x100)
Cache Effekte auf dem Colorado Road Network
Relative Laufzeit auf Bottleneck Graphen
Synthetische Graphen, 500 Knoten, 1000 Up
Laufzeit per Update (in sec)
Cache miss ratio D-RRL/D-LHP
D-LHP so langsam wie S-LSP
Cache Größe
D-RRL langsamer als S-DIJ
IBM Power 4
Anzahl der Kanten (x1000)
ENDE Kap. 7
9
Prüfungselemente
Und wie geht es weiter?
•  Modulprüfung bzw. Mündliche Fachprüfung:
–  Über VO 4 inkl Ü 2: 9LP
–  Anforderungen:
Prüfungen?
•  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
56
–  Anforderungen:
•  Regelmäßige aktive Mitarbeit in Übungen, u.a.
erfolgreiche Präsentationen und bearbeitete
Übungsblätter
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)
57
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)
–  Über VO 4 inkl. Ü 2: 9LP
WS 08/09
WS 08/09
1. 
2. 
3. 
4. 
5. 
6. 
7. 
8. 
•  Leistungsnachweis:
Alg. & Dat.
Alg. & Dat.
Themen der Vorlesung
Prüfungselemente
Petra Mutzel
Petra Mutzel
58
60
Fachprüfung: Ein Thema streichbar; * = nicht streichbar!
Diese Themen fanden Sie gar
nicht schön:
•  Lineare Programmierung
•  Geometrische Algorithmen
Petra Mutzel
Alg. & Dat.
WS 08/09
62
10