Grundlagen der Algorithmen und Datenstrukturen Kapitel 10

Transkript

1 Grundlagen der Algorithmen und Datenstrukturen Kapitel 0 Christian Scheideler + Helmut Seidl SS Kapitel 0

2 Kürzeste Wege Zentrale Frage: Wie komme ich am schnellsten von A nach B? B A Kapitel 0

3 Kürzeste Wege Zentrale Frage: Wie komme ich am schnellsten von A nach B? Fälle: Kantenkosten DAG, beliebige Kantenkosten Beliebiger Graph, positive Kantenkosten Beliebiger Graph, beliebige Kosten Kapitel 0 3

4 Einführung Kürzeste-Wege-Problem: gerichteter Graph G=(V,E) Kantenkosten c:e!ir SSSP (single source shortest path): Kürzeste Wege von einer Quelle zu allen anderen Knoten APSP (all pairs shortest path): Kürzeste Wege zwischen allen Paaren Kapitel 0 4

5 Einführung s µ (s,v): Distanz zwischen s und v kein Weg von s nach v µ (s,v) = - Weg bel. kleiner Kosten von s nach v min{ c(p) p ist Weg von s nach v} Kapitel 0 5

6 Einführung s Wann sind die Kosten -? Wenn es einen negativen Kreis gibt: s C v c(c)< Kapitel 0 6

7 Einführung Negativer Kreis hinreichend und notwendig für Wegekosten -. Negativer Kreis hinreichend: Weg q Weg p s C v c(c)<0 Kosten für i-fachen Durchlauf von C: c(p) + i c(c) + c(q) Für i! geht Ausdruck gegen Kapitel 0 7

8 Einführung Negativer Kreis hinreichend und notwendig für Wegekosten -. Negativer Kreis notwendig: l: minimale Kosten eines einfachen Weges von s nach v es gibt nichteinfachen Weg r von s nach v mit Kosten c(r) < l r nicht einfach: Zerlegung in p 0 C p...p n- C n p n, wobei C i Kreise sind und p 0...p n ein einfacher Pfad da c(r) < l c(p 0...p n ) ist, gilt c(c i )<0 für ein i Kapitel 0 8

9 Kürzeste Wege Graph mit Kantenkosten : Führe Breitensuche durch s Kapitel 0 9

10 Kürzeste Wege in DAGs Reine Breitensuche funktioniert nicht. s Kapitel 0 0

11 Kürzeste Wege in DAGs Korrekte Distanzen: s Kapitel 0

12 Kürzeste Wege in DAGs Strategie: nutze aus, dass Knoten in DAGs topologisch sortiert werden können, d.h.: alle Kanten a b erfüllen a<b 3 3 s Kapitel 0

13 Kürzeste Wege in DAGs Strategie: betrachte dann Knoten in der Reihenfolge ihrer topologischen Sortierung und aktualisiere Distanzen zu s s Kapitel 0 3 8

14 Kürzeste Wege in DAGs Strategie:. Topologische Sortierung der Knoten. Aktualisierung der Distanzen gemäß der topologischen Sortierung Warum funktioniert das?? Kapitel 0 4

15 Kürzeste Wege in DAGs Betrachte kürzesten Weg von s nach v. Dieser hat topologische Sortierung (t i ) i mit t i <t i+ for alle i. t t t 3 t 4 t 5 s 0 d d d 3 d 4 c c c 3 c 4 v Besuch in topologischer Reihenfolge führt zu richtigen Distanzen (d i = j<=i c i ) Kapitel 0 5

16 Kürzeste Wege in DAGs Betrachte kürzesten Weg von s nach v. Dieser hat topologische Sortierung (t i ) i mit t i <t i+ für alle i. t t t 3 t 4 t 5 s 0 d d d 3 d 4 c c c 3 c 4 v Bemerkung: kein Knoten auf dem Weg zu v kann Distanz < d i zu s haben, da sonst kürzerer Weg zu v möglich wäre Kapitel 0 6

17 Kürzeste Wege in Graphen Allgemeine Strategie: Am Anfang, setze d(s) = 0; und d(v) = ; für alle anderen Knoten besuche Knoten in einer Reihenfolge, die sicherstellt, dass mindestens ein kürzester Weg von s zu jedem v in der Reihenfolge seiner Knoten besucht wird für jeden besuchten Knoten v, aktualisiere die Distanzen der Knoten w mit (v,w) E, d.h. setze d(w) = min{d(w), d(v)+c(v,w)}; Kapitel 0 7

18 Kürzeste Wege in DAGs Zurück zur Strategie:. Topologische Sortierung der Knoten. Aktualisierung der Distanzen gemäß der topologischen Sortierung Wie führe ich eine topologische Sortierung durch? Kapitel 0 8

19 Kürzeste Wege in DAGs Topologische Sortierung: Verwende eine FIFO Queue q Anfangs enthält q alle Knoten, die keine eingehende Kante haben (Quellen). Verwalte für jeden Knoten Zähler der noch nicht markierten eingehenden Kanten. Entnehme v aus q und markiere alle (v,w) E, d.h. dekrementiere den Zähler für w. Falls der Zähler von w null wird, füge w in q ein. Wiederhole das, bis q leer ist Kapitel 0 9

20 Kürzeste Wege in DAGs Beispiel: : Knoten momentan in Queue q Nummerierung nach Einfügereihenfolge Kapitel 0 0

21 Kürzeste Wege in DAGs Korrektheit der topologischen Nummerierung: Knoten wird erst dann nummeriert, wenn alle Vorgänger nummeriert sind Kapitel 0

22 Kürzeste Wege in DAGs Laufzeit: Zur Bestimmung der Anzahlen der eingehenden Kanten aller Knoten muss Graph einmal durchlaufen werden. Danach wird jeder Knoten und jede Kante genau einmal betrachtet, also Zeit O(n+m) Kapitel 0

23 Kürzeste Wege in DAGs Bemerkung: topologische Sortierung kann nicht alle Knoten nummerieren genau dann, wenn Graph gerichteten Kreis enthält (kein DAG ist) Test auf DAG-Eigenschaft Kapitel

24 Kürzeste Wege in DAGs DAG-Strategie:. Topologische Sortierung der Knoten Laufzeit O(n+m). Aktualisierung der Distanzen gemäß der topologischen Sortierung Laufzeit O(n+m) Insgesamt Laufzeit O(n+m) Kapitel 0 4

25 Dijkstras Algorithmus Nächster Schritt: Kürzeste Wege für beliebige Graphen mit positiven Kanten. Problem: besuche Knoten eines kürzesten Weges in richtiger Reihenfolge s 0 d d d 3 d 4 w v Lösung: besuche Knoten in der Reihenfolge der kürzesten Distanz zur Quelle s Kapitel 0 5

26 Dijkstras Algorithmus Am Anfang, setze d[s] = 0; und d[v] = ; für alle andern Knoten. Füge s in Priority Queue q ein, wobei die Prioritäten in q gemäß der aktuellen Distanzen d[v] definiert sind. Wiederhole, bis q leer ist: Entferne aus q (deletemin) den Knoten v mit niedrigstem d[v]. Für alle (v,w) E, setze d[w] = min{d[w], d[v]+c(v,w)}. Falls w noch nicht in q war, füge w in q ein Kapitel 0 6

27 Dijkstras Algorithmus Beispiel: ( : aktuell, : fertig) s Kapitel 0 7

28 Dijkstras Algorithmus void Dijkstra(Node s) { d = new double[n]; Arrays.fill(d,); parent = new Node[n]; d[s] = 0; parent[s] = s; PriorityQueue<Node> q = <s>; while (q!= <>) { u = q.deletemin(); // u: min. Distanz zu s in q foreach (e=(u,v) E) if (d[v] > d[u]+c(e)) { // aktualisiere d[v] if (d[v]==) q.insert(v); // v schon in q? d[v] = d[u]+c(e); parent[v] = u; q.decreasekey(v); // nur PQ q reparieren } } } Kapitel 0 8

29 Dijkstras Algorithmus Korrektheit: Angenommen, Algo sei inkorrekt. Sei v der Knoten mit kleinstem µ (s,v) der aus q entfernt wird mit d[v]>µ (s,v) realisiert durch einen kanten-minimalen Pfad. Sei p=(s=v,v,,v k =v) ein solcher von s nach v. Weil alle c(e) 0 sind, steigt minimales d[w] in q monoton an. Da d[v k- ] d[v k ], muss v k- vor v k aus q entfernt worden sein oder gleiche Distanz haben. Entweder gilt auch d[v k- ] >µ (s,v k- ), dann haben wir einen Widerspruch für einen kürzeren Pfad, oder d[v k- ] =µ (s,v k- ) Bei Entfernung von v k- hat Algo überprüft, ob d[v k- ] + c(v k-,v k )<d[v k ]. Das muss bei Annahme oben der Fall gewesen sein, aber dann hätte Algo d[v] auf d[v k- ] + c(v k-,v) =µ (s,v) gesetzt, ein Widerspruch Kapitel 0 9

30 Dijkstras Algorithmus Laufzeit: T Dijkstra = O(n (T DeleteMin (n)+t Insert (n)) + m T decreasekey (n)) Binärer Heap: alle Operationen O(log n), also T Dijkstra = O((m+n) log n) Fibonacci Heap (nicht in Vorlesung behandelt): T DeleteMin (n)=t Insert (n)=o(log n) T decreasekey (n)=o() Damit T Dijkstra = O(n log n + m) Kapitel 0 30

31 Monotone Priority Queues Einsicht: Dijkstras Algorithmus braucht keine allgemeine Priority Queue, sondern nur eine monotone Priority Queue. Monotone Priority Queue: Folge der gelöschten Elemente hat monoton steigende Werte. Effiziente Implementierungen von monotonen Priority Queues möglich, falls Kantenkosten ganzzahlig Kapitel 0 3

32 Bucket Queue Annahme: alle Kantenkosten im Bereich [0,C]. Konsequenz: zu jedem Zeitpunkt enthält q Distanzen im Bereich [d,d+c] für ein d. d+3 d+ C=8 d+ d d+8 d+ d Kapitel 0 3

33 Bucket Queue Annahme: alle Kantenkosten im Bereich [0,C]. Konsequenz: zu jedem Zeitpunkt enthält q Distanzen im Bereich [d,d+c] für ein d. Bucket Queue: Array B aus C+ Listen und Variable d min für aktuell minimale Distanz (mod C+) 0 3. C Kapitel 0 33

34 Bucket Queue 0 3. C Jeder Knoten v mit momentaner Distanz d[v] wird in Liste B[d[v] mod (C+)] gespeichert Da momentane d[v] s im Bereich [d,d+c] für ein d sind, haben alle v in einem B[d] dasselbe d[v] Kapitel 0 34

35 Bucket Queue 0 3. C Insert(v): fügt v in B[d[v] mod (C+)] ein. Laufzeit O(). decreasekey(v): entfernt v aus momentaner Liste und fügt v in B[d[v] mod (C+)] ein. Falls in v Position in der Liste speichert, Laufzeit O(). deletemin(): solange B[d min ]=, setze d min :=(d min +) mod (C+). Nimm dann einen Knoten u aus B[d min ] heraus. Laufzeit O(C) Kapitel 0 35

36 Bucket Queue 0 3. C Insert(v), decreasekey(v): Laufzeit O(). deletemin(): Laufzeit O(C). Laufzeit von Dijkstras Algo mit Bucket Queue: O(m+n C) Kapitel 0 36

37 Radix Heap Radix Heaps sind eine verbesserte Form der Bucket Queues. Laufzeit von Dijkstras Algo mit Radix Heap: O(m + n log C) Kapitel 0 37

38 Radix Heap Array B mit Listen B[-] bis B[K], K=+blog Cc K Regel: Knoten v in B[min(msd(d min,d[v]),k)] msd(d min,d[v]): höchstes Bit, in dem sich Binärdarstellungen von d min und d[v] unterscheiden (-: kein Unterschied) Kapitel 0 38

39 Radix Heap Beispiel für msd(d min,d): sei d min =7 oder binär 000 d=7: msd(d min,d)=- d=8: binär 000, also msd(d min,d)= d=: binär 00, also msd(d min,d)= d=5: binär 000, also msd(d min,d)= Kapitel 0 39

40 Radix Heap Berechnung von msd für a=b: msd(a,b)=blog(a b)c Zeit O() (mit entspr. Maschinenbefehlen) - 0. K insert, decreasekey: wie vorher (mit neuer Regel), Laufzeit O() Kapitel 0 40

41 Radix Heap deletemin Operation: Falls B[-] besetzt, entnehme ein v aus B[-] (sonst kein Element mehr in Heap und fertig) finde minimales i, so dass B[i] ; (falls kein solches i, dann fertig) bestimme d min in B[i] (in O() Zeit möglich, falls z.b. d min -Werte in extra Feld min[-..k] gehalten) verteile Knoten in B[i] über B[-],,B[i-] gemäß neuem d min Entscheidend: für alle v in B[j], j>i, gilt nach wie vor msd(d min,d[v])==j, d.h. sie müssen nicht verschoben werden Kapitel 0 4

42 Radix Heap Wir betrachten Sequenz von deletemin Operationen Kapitel 0 4

43 Radix Heap Wir betrachten Sequenz von deletemin Operationen Kapitel 0 43

44 Radix Heap Lemma 0.6: Sei B[i] die minimale nichtleere Liste, i>0. Sei d min das kleinste Element in B[i]. Dann ist msd(d min,x)<i für alle x B[i]. Beweis: x d min : klar Alle Elemente in B[i] nach links x=d min : wir unterscheiden zwei Fälle: ) i<k, ) i=k Kapitel 0 44

45 Radix Heap Fall i<k: Bitposition: i 0 altes d min a 0 neues d min a x a Also muss msd(d min,x)<i sein Kapitel 0 45

46 Radix Heap Fall i=k: Bitposition: j K h 0 altes d min a 0 neues d min a b 0 x a b Für alle x: d min (alt) < d min (neu) < x < d min (alt)+c j = msd(d min (alt),d min (neu)), h = msd(d min (neu),x) Kapitel 0 46

47 Radix Heap Fall i=k: Bitposition: j K h 0 altes d min a 0 neues d min a b 0 x a Wegen j k hat Binärdarstellung von jedem übrigbleibenden x dasselbe Präfix ab bis runter zu Bitstelle j <K, d.h. h K b Kapitel 0 47

48 Radix Heap Fall i=k: Bitposition: j K h 0 altes d min a 0 neues d min a b 0 Konsequenz: jeder Knoten nur maximal K-mal verschoben in Radix Heap x a b Kapitel 0 48

49 Radix Heap - 0. K Insert(v), decreasekey(v): Laufzeit O(). deletemin(): amortisierte Laufzeit O(log C). Laufzeit von Dijkstras Algo mit Radix Heap: O(m + n log C) Kapitel 0 49

50 Bellman-Ford Algorithmus Nächster Schritt: Kürzeste Wege für beliebige Graphen mit beliebigen Kantenkosten. Problem: besuche Knoten eines kürzesten Weges in richtiger Reihenfolge s 0 d d d 3 d 4 w v Dijkstra Algo kann nicht mehr verwendet werden, da er im Allgemeinen nicht mehr Knoten in der Reihenfolge ihrer Distanz zu s besucht Kapitel 0 50

51 Bellman-Ford Algorithmus Beispiel für Problem mit Dijkstra Algo: 0 v - s Knoten v hat falschen Distanzwert! Kapitel 0 5

52 Bellman-Ford Algorithmus Lemma: Für jeden Knoten v mit µ (s,v)>- zu s gibt es einfachen Weg (ohne Kreis!) von s nach v der Länge µ (s,v). Beweis: Weg mit Kreis mit Kantenkosten 0: Kreisentfernung erhöht nicht die Kosten Weg mit Kreis mit Kantenkosten < 0: Distanz zu s ist -! Kapitel 0 5

53 Bellman-Ford Algorithmus Folgerung: (Graph mit n Knoten) Für jeden erreichbaren Knoten v mit µ (s,v)> - gibt es kürzesten Weg der Länge <n zu v. Strategie: Durchlaufe (n-)-mal sämtliche Kanten in Graph und aktualisiere Distanz. Dann alle kürzesten Wege berücksichtigt. s 0 d d d 3 d 4 v Durchlauf Kapitel 0 53

54 Bellman-Ford Algorithmus Problem: Erkennung negativer Kreise - 0 s Einsicht: in negativem Kreis erniedrigt sich Distanz in jeder Runde bei mindestens einem Knoten Kapitel 0 54

55 Bellman-Ford Algorithmus Problem: Erkennung negativer Kreise - 0 s Zeitpunkt: kontinuierliche Distanzerniedrigung startet spätestens in n-ter Runde (dann Kreis mindestens einmal durchlaufen) Kapitel 0 55

56 Bellman-Ford Algorithmus Keine Distanzerniedrigung möglich: Angenommen wir erreichen Zeitpunkt mit d[v]+c(v,w) d[w] für alle Knoten w. Dann gilt (über Induktion) für jeden Weg p, dass d[s]+c(p) d[w] für alle Knoten w. Falls sichergestellt ist, dass für den kürzesten Weg p nach w, d[w] c(p) zu jedem Zeitpunkt ist, dann gilt am Ende d[w]=µ (s,w) Kapitel 0 56

57 Bellman-Ford Algorithmus Zusammenfassung: Keine Distanzerniedrigung mehr möglich (d[v] +c(v,w) d[w] für alle w): Fertig, d[w] == µ (s,w) für alle w Distanzerniedrigung möglich selbst noch in n-ter Runde (d[v]+c(v,w) < d[w] für ein w): Dann gibt es negative Kreise, also Knoten w mit Distanz µ (s,w) == -. Ist das wahr für ein w, dann für alle von w erreichbaren Knoten Kapitel 0 57

58 Bellman-Ford Algorithmus void BellmanFord(Node s) { d = new double[n]; Arrays.fill(d,); parent = new Node [n]; d[s] = 0; parent[s] = s; for(int i=0;i< n-;i++) { // aktualisiere Kosten für n- Runden foreach (e=(v,w) E) if (d[w] > d[v]+c(e)) { // bessere Distanz möglich? d[w] =d[v]+c(e); parent[w] = v; }} foreach (e=(v,w) E) // in n-ter Runde noch besser? if (d[w] > d[v]+c(e)) infect(w); } void infect(node v) { // setze --Kosten von v aus if (d[v] > -) { d[v] = -; foreach ((v,w) E) infect(w); } } Kapitel 0 58

59 Bellman-Ford Algorithmus Laufzeit: O(n m) Verbesserungsmöglichkeiten: Überprüfe in jeder Aktualisierungsrunde, ob noch irgendwo d[v]+c[v,w]<d[w] ist. Nein: fertig! Besuche in jeder Runde nur die Knoten w, für die Test d[v]+c[v,w]<d[w] sinnvoll (d.h. d[v] hat sich in letzter Runde geändert) Kapitel 0 59

60 All Pairs Shortest Paths Annahme: Graph mit beliebigen Kantenkosten, aber keine negativen Kreise Naive Strategie für Graph mit n Knoten: lass n-mal Bellman-Ford Algorithmus (einmal für jeden Knoten) laufen Laufzeit: O(n m) Kapitel 0 60

61 All Pairs Shortest Paths Bessere Strategie: Reduziere n Bellman- Ford Anwendungen auf n Dijkstra Anwendungen Problem: wir brauchen dazu nichtnegative Kantenkosten Lösung: Umwandlungsstrategie in nichtnegative Kantenkosten, ohne kürzeste Wege zu verfälschen (nicht so einfach!) Kapitel 0 6

62 All Pairs Shortest Paths Gegenbeispiel zur Erhöhung um Wert c: Vorher Kosten + überall v 3 v s s - 0 : kürzester Weg Kapitel 0 6

63 All Pairs Shortest Paths Sei Φ:V! IR eine Funktion, die jedem Knoten ein Potenzial zuweist. Die reduzierten Kosten von e=(v,w) sind: r(e) := Φ(v) + c(e) - Φ(w) Lemma 0.8: Seien p und q Wege in G. Dann gilt für jedes Potenzial Φ: r(p)<r(q) genau dann wenn c(p)<c(q) Kapitel 0 63

64 All Pairs Shortest Paths Lemma 0.8: Seien p und q Wege in G. Dann gilt für jedes Potenzial Φ: r(p)<r(q) genau dann wenn c(p)<c(q). Beweis: Sei p=(v,,v k ) ein beliebiger Weg und e i =(v i,v i+ ) für alle i. Es gilt: r(p) = i r(e i ) = i (Φ(v i ) + c(e) - Φ(v i+ )) = Φ(v ) + c(p) - Φ(v k ) Kapitel 0 64

65 All Pairs Shortest Paths Lemma 0.9: Angenommen, G habe keine negativen Kreise und dass alle Knoten von s erreicht werden können. Sei Φ(v) = µ (s,v) für alle v V. Mit diesem Φ ist r(e) 0 für alle e. Beweis: nach Annahme ist µ (s,v) IR für alle v wir wissen: für jede Kante e=(v,w) ist µ (s,v)+c(e) µ (s,w) (Abbruchbedingung!) also ist r(e) = µ (s,v) + c(e) - µ (s,w) Kapitel 0 65

66 All Pairs Shortest Paths. Füge neuen Knoten s und Kanten (s,v) für alle v hinzu mit c(s,v) = 0 (alle erreichbar!) Berechne µ (s,v) nach Bellman-Ford und setze Φ(v) = µ (s,v); für alle v Berechne die reduzierten Kosten r(e). Berechne für alle Knoten v die Distanzen µ (v,w) mittels Dijkstra Algo mit reduzierten Kosten auf Graph ohne Knoten s Berechne korrekte Distanzen µ (v,w) durch µ (v,w) = µ (v,w)+φ(w)-φ(v) Kapitel 0 66

67 All Pairs Shortest Paths Beispiel: a b b a d - c c - d Kapitel 0 67

68 All Pairs Shortest Paths Schritt : künstliche Quelle a 0 0 b s 0 0 c - d Kapitel 0 68

69 All Pairs Shortest Paths Schritt : Bellman-Ford auf s a Φ(a)=0 0 0 b Φ(b)=0 s 0 0 c Φ(c)=- - d Φ(d)= Kapitel 0 69

70 All Pairs Shortest Paths Schritt 3: r(e)-werte berechnen a Φ(a)=0 Die reduzierten Kosten von e=(v,w) sind: r(e) := Φ(v) + c(e) - Φ(w) b 0 Φ(b)=0 c Φ(c)=- 0 d Φ(d)= Kapitel 0 70

71 All Pairs Shortest Paths Schritt 4: berechne alle Distanzen µ (v,w) via Dijkstra µ a b c d a b 0 c d a b c d Φ(a)=0 0 Φ(b)=0 Φ(c)=- 0 Φ(d)= Kapitel 0 7

72 All Pairs Shortest Paths Schritt 5: berechne korrekte Distanzen durch die Formel µ (v,w)=µ (v,w)+φ(w)-φ(v) a b Φ(a)=0 Φ(b)=0 µ a b c d a 0 3 b 0 0 c d 0-0 c d Φ(c)=- - Φ(d)= Kapitel 0 7

73 All Pairs Shortest Paths Laufzeit des APSP-Algorithmus: O(T Bellman-Ford (n,m) + n T Dijk stra (n,m)) = O(n m + n(n log n + m)) = O(n m + n log n) unter Verwendung von Fibonacci Heaps Kapitel 0 73