8. Kürzeste Wege in Graphen

Transkript

1 . Kürzeste Wege in Graphen Problemstellung Ungewichtete Graphen und erweiterte Breitensuche Distanzgraphen und Dijkstra-Algorithmus Gewichtete Digraphen und Moore-Ford-Algorithmus Netzpläne und erweiterte topologische Sortierung Alle kürzeste Wege in gewichteten Digraphen mit Floyd-Algorithmus Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

2 Problemstellung kürzeste Wege () Im allgemeinen gibt es zwischen zwei Knoten u und v mehrere Wege. Ein Weg von u nach v heißt kürzester Weg, falls der Weg minimale Länge hat. Weglänge bei gewichtetem Graph ist Summe der Kantengewichte. Weglänge bei ungewichtetem Graph ist Anzahl der Kanten. Die Distanz d(u,v) zwischen u und v wird als die Länge eines kürzesten Weges definiert. Falls es keinen Weg von u nach v gibt, ist d(u,v) =. 6 6 Weg von nach mit Länge. Kürzester Weg von nach mit Länge. 0 Damit ist Distanz d(,) =. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

3 Problemstellung kürzeste Wege () Länge eines Weges muss nicht die wörtliche Bedeutung haben. Die Gewichte (Kosten) der Kanten und damit die Weglängen können in Abhängigkeit von der Anwendung ganz unterschiedliche Bedeutungen haben. Beispiele: - Streckenlänge - Zeitspannen - Kosten - Profit: Gewinn/Verlust (Gewichte können positiv und negativ sein) - Wahrscheinlichkeiten Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

4 Verschiedene Problemvarianten () Single pair shortest path: Kürzeste Wege zwischen zwei Knoten: () Single-source shortest-path problem: Kürzeste Wege zwischen einem Knoten und allen anderen Knoten () All pairs shortest path: Kürzeste Wege zwischen allen Knotenpaaren. Für Problem () kennt man keine bessere Lösung, als einen Algorithmus für Lösung () zu nehmen, der abgebrochen wird, sobald der Zielknoten erreicht wird. Problem () kann auf Problem () zurückgeführt werden. Bei dicht besetzten Graphen (d.h. viele Kanten) gibt es jedoch eine effizientere Lösung, die zudem auch negative Kantengewichte zulässt. Problemstellungen lassen sich für verschiedene Graphtypen (gerichtet oder ungerichtet, gewichtet oder ungewichtet) algorithmisch unterschiedlich lösen. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

5 Verschiedene Algorithmen A B C D E Problemvariante Single-source shortest-path für ungewichtete Graphen Single-source shortest-path für Distanz-Graphen (nur positive Gewichte) Single-source shortest-path für gewichtete Digraphen (auch negative Gewichten) Single-source shortest-path für gewichtete, azyklische Digraphen mit einem Start- und einem Endknoten (Netzpläne) All pairs shortest path für gewichtete Digraphen (auch negative Gewichte) Algorithmus Erweiterte Breitensuche Algorithmus von Dijkstra; A*-Verfahren Algorithmus von Moore und Ford Erweiterte topologische Sortierung Algorithmus von Floyd A ist ein Spezialfall von B. Wendet man den Dijkstra-Algorithmus auf Graphen mit Kantengewichten an, ergibt sich eine Breitensuche. D ist ein Spezialfall von C. Der auf Variante D zugeschnittene Algorithmus ist jedoch wesentlich effizienter als der Algorithmus für Variante C. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

6 . Kürzeste Wege in Graphen Problemstellung Ungewichtete Graphen und erweiterte Breitensuche Distanzgraphen und Dijkstra-Algorithmus Gewichtete Digraphen und Moore-Ford-Algorithmus Netzpläne und erweiterte topologische Sortierung Alle kürzeste Wege in gewichteten Digraphen mit Floyd-Algorithmus Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09-6

7 Erweiterte Breitensuche Single-source shortest-path: Gesucht sind alle kürzesten Wege von einem Startknoten s zu allen anderen Knoten. Beginne bei s und durchlaufe Graph mit Breitensuche. Speichere für jeden besuchten Knoten v die Distanz d[v] zu Startknoten s. Speichere Vorgängerknoten p[v] im kürzesten Weg nach v. p stellt ein Baum mit Wurzel s dar. Der kürzeste Weg von s nach v ergibt sich in umgekehrter Reihenfolge: v, p[v], p[p[v]],, p[ p[p[v]] ] = s Beispiel: Startknoten s = v 0 6 d[v] p[v] () () () 0 v 0 6 d[v] 0 p[v] v 0 6 d[v] 0 p[v] - () () () Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

8 Algorithmus für erweiterte Breitensuche Eingabe: Startknoten s und ungewichteter Graph G void shortestpath (Vertex s, Graph G, int[ ] d, Vertex[ ] p) { for ( jeden Knoten v ) { d[v] = ; p[v] = undef; d[s] = 0; // Distanz für Startknoten Queue<Vertex> q; q.add(s); Ausgabe: Distanzfeld d und Vorgängerfeld p while (! q.empty() ) { v = q.remove(); for ( jeden adjazenten Knoten w von v ) { if (d[w] == ) { // w noch nicht registriert d[w] = d[v] + ; p[w] = v; q.add(w); v 0 6 d[v] 0 p[v] v 0 6 d[v] 0 p[v] v 0 6 d[v] 0 p[v] - Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

9 Analyse der Breitensuche Für jeden Knoten w kann d[w] höchstens einmal von auf einen endlichen Wert gesetzt werden. Damit kommen in die Queue q höchstens V Knoten. Die while-schleife läuft damit höchstens V -mal. Jede Kantenrichtung wird höchstens einmal in einer der for-schleifen betraachtet. Verwendet man die Adjazenzlistendarstellung, ist der Aufwand für den Durchlauf aller for-schleifen gleich O( E ). Damit ergibt sich mit Adjazenzlistendarstellung insgesamt: T = O( V + E ) Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09-9

11 Algorithmus von Dijkstra Idee () Single-source shortest-path: Gesucht sind alle kürzesten Wege von einem Startknoten s zu allen anderen Knoten im einem Distanz-Graphen (Gewichte müssen 0 sein). Ähnlich wie bei der Breitensuche werden alle Knoten, die als nächstes besucht werden können, in einer Liste K (Kandidatenliste) gehalten. Aus der Kandidatenliste wird immer der Knoten mit der kleinsten Distanz als nächster besucht v 0 6 d[v] 0 6 p[v] Kandidatenliste Bereits besucht Als nächstes wird Knoten mit Distanzwert besucht. d[v] Distanz zwischen v und Startknoten s = 0 p[v] Vorgängerknoten im kürzesten Weg nach v Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

12 Algorithmus von Dijkstra Idee () Wird ein neuer Knoten v besucht, dann kommen eventuell neue Nachbarknoten zur Kandidatenliste. Bei allen Nachbarknoten wird geprüft, ob ein Weg über v einen kürzeren Weg ergibt Knoten wird besucht 0 Knoten wird besucht v 0 6 d[v] 0 6 p[v] v 0 6 d[v] 0 6 p[v] Knoten ist zur Kandidatenliste neu dazu gekommen. Der Distanzwert von Knoten hat sich von 6 auf verbessert, da der Weg über Knoten kürzer ist als der bisherige. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

13 Algorithmus von Dijkstra void shortestpath (Vertex s, DistanzGraph G, double[ ] d, Vertex[ ] p ) { kl = Æ; // leere Kandidatenliste for (jeden Knoten v) { d[v] = ; p[v] = undef; d[s] = 0; // Startknoten () kl.insert(s); while (! kl.empty() ) { () lösche Knoten v aus kl mit d[v] minimal; for ( jeden adjazenten Knoten w von v ) { if (d[w] == ) // w noch nicht besucht und nicht in Kandidatenliste () kl.insert(w); if (d[v] + c(v,w) < d[w]) { p[w] = v; () d[w] = d[v] + c(v,w); Eingabe: Startknoten s und Distanzgraph G Ausgabe: Distanzfeld d und Vorgängerfeld p In der Kandidatenliste sind alle Knoten abgespeichert, die als nächstes besucht werden können. Die Zugriffsoperationen auf die Kandidatenliste sind rot gekennzeichnet. Mögliche Implementierungen werden auf der nächsten Folie diskutiert. Distanzwert für w verbessert sich. Kürzester Weg nach w geht nun über v. Falls in Zeile () w neu in kl eingefügt wurde, wird d[w] von zu einem endlichen Wert verbessert. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

14 Eigenschaften Die d-werte der besuchten Knoten in Zeile () sind monoton steigend. Begründung: die d-werte der anderen Kandidaten sind und bleiben d[v]. In Zeile () wird zwar für einen adjazenten Knoten w von v der d-wert verringert. Dennoch gilt d[w] d[v], da die Gewichte der Kanten c(v,w) 0 sind. while (! kl.empty() ) { () lösche Knoten v aus kl mit d[v] minimal; Knoten v wird besucht. for ( jeden adjazenten Knoten w von v ) { if (d[w] == ) // w noch nicht besucht und nicht in Kandidatenliste () kl.insert(w); if (d[v] + c(v,w) < d[w]) { p[w] = v; () d[w] = d[v] + c(v,w); Sobald ein Knoten v besucht wird (Zeile ()), ist sein kürzester Weg bekannt. Wird ein kürzester Weg von einem Startknoten s zu einem bestimmten Zielknoten z gesucht, dann kann das Verfahren abgebrochen werden, sobald v = z besucht wird. Ein Knoten wird höchstens einmal in die Prioritätsliste eingefügt. Daher kl.size() V. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

15 Kandidatenliste als Index-Heap Analyse () Speichere Kandidaten in einem Index-Heap (siehe Kap., Prioritätslisten), wobei als Priorität der Distanzwert aus Feld d genommen wird. Ein Index-Heap bietet eine effiziente Realisierung folgender Operationen an: - insert(v, d) in O(log V ): fügt Element v mit Priorität d ein. Aufruf in () und (). - v = delmin() in O(log V ): löscht Element mit kleinster Priorität. Aufruf in (). - change(v, dneu) in O(log V ): ändert den Vorrangwert des Elements v in dneu. Aufruf in (). Analyse des Dijkstra-Algorithmus mit Kandidatenliste als Index-Heap Jede Kantenrichtung wird genau einmal in einer der for-schleifen betrachtet. Da () und () in O(log V ) geht, ist für alle for-schleifen insgesamt O( E log V ) notwendig. Hinzu kommt höchstens V -mal die Ausführung von (), was O( V log V ) bedeutet. Insgesamt: T = O( E log V ) Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

16 Analyse () Kandidatenliste als unsortiertes Feld Speichere Kandidaten in einem unsortierten Feld. Damit benötigt die Operation in Zeile () (Minimum bestimmen) O( V ) und die Operationen in (), () und () benötigen O(). Analyse des Dijkstra-Algorithmus mit Kandidatenliste als unsortiertes Feld Die while-schleife wird höchstens V -mal durchgeführt. Für () ist O( V ) notwendig. Jede Kantenrichtung wird genau einmal in einer der for-schleifen betrachtet. Da () und () in O() geht, ist für alle for-schleifen insgesamt O( E ) notwendig. Insgesamt: T = O( V ) Fazit: Ist der Graph dicht besetzt, d.h. E = O( V ), dann ist die Variante mit Kandidatenliste als unsortiertes Feld besser. Ist der Graph dünn besetzt, d.h. E = O( V ), dann ist die Variante mit Kandidatenliste als Prioritätsliste besser. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09-6

17 Beispiel zu Dijkstra-Algorithmus () Knoten 0 wird besucht 0 v 0 6 d[v] 0 p[v] v 0 6 d[v] 0 6 p[v] Knoten wird besucht 6 0 Knoten wird besucht v 0 6 d[v] 0 6 p[v] Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

18 Beispiel zu Dijkstra-Algorithmus () Knoten wird besucht 6 0 v 0 6 d[v] 0 6 p[v] v 0 6 d[v] 0 6 p[v] Knoten 6 wird besucht 6 Knoten wird besucht 0 v 0 6 d[v] 0 6 p[v] Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

19 Beispiel zu Dijkstra-Algorithmus () Kürzeste Wege für Startknoten s = 0 sind nun bekannt für die Zielknoten:,,, 6,. Kürzester Weg von 0 nach ist 0,, 6, mit Distanz d =. v 0 6 d[v] 0 6 p[v] Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09-9

20 A*-Algorithmus: Verbesserung des Dijkstra-Algorithmus Ist der kürzeste Weg zu genau einem Zielknoten z gesucht und lässt sich die Distanz von einem Knoten v zum Zielknoten z durch eine Schätzfunktion h(v,z) abschätzen, dann lässt sich der Algorithmus von Dijkstra optimieren. Statt den Knoten v mit d[v] minimal als nächstes zu besuchen zu besuchen, wird der Knoten v besucht mit d[v] + h(v,z) minimal. Damit werden Knoten v bevorzugt, die näher zum Zielknoten liegen. Sind die Knoten des Graphen Punkte in der Euklidischen Ebene und die Gewichte gleich den Euklidischen Abständen (Luftlinienabstand), dann lässt sich als Schätzfunktion h(v,z) der Euklidische Abstand zwischen v und z wählen. z s h(,z) h(,z) Wird der kürzeste Weg von s nach z gesucht, wird zuerst Knoten besucht, weil dieser näher zu z liegt. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09-0

21 A*- Algorithmus boolean shortestpath (Vertex s, Vertex z, DistanzGraph G, double[ ] d, Vertex[ ] p ) { kl = Æ; // leere Kandidatenliste for (jeden Knoten v) { d[v] = ; p[v] = undef; d[s] = 0; // Startknoten kl.insert(s); Ausgabe: Distanzfeld d und Vorgängerfeld p Eingabe: Startknoten s, Zielknoten z und Distanzgraph G while (! kl.empty() ) { lösche Knoten v aus kl mit d[v] + h(v,z) minimal; Änderungen gegenüber if (v == z) // Zielknoten z erreicht dem Diskstra-Algorithmus return true; sind blau gekennzeichnet. for ( jeden adjazenten Knoten w von v ) { if (d[w] == ) // w noch nicht besucht und nicht in Kandidatenliste kl.insert(w); if (d[v] + c(v,w) < d[w]) { p[w] = v; d[w] = d[v] + c(v,w); return false; Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

22 Korrektheit des A*- Algorithmus Das A*-Verfahren liefert immer einen kürzesten Weg, falls der Zielknoten z erreichbar ist und die Schätzfunktion h folgende Eigenschaften erfüllt: () h ist zulässig: 0 h(u,v) d(u,v) für alle Knoten u, v (h ist positiv und unterschätzt die Distanz d) () h ist monoton: h(u,v) c(u,w) + h(w,v) für alle Knoten u, v, w v h(u,v) h(w,v) u c(u,w) w Die Euklidische Abstandsfunktion erfüllt die beiden oberen Bedingungen. Die Schätzfunktion h(u,v) = 0 erfüllt trivialerweise beide Bedingungen. Man erhält dann genau den Algorithmus von Dijkstra. In der Literatur wird die Schätzfunktion auch Heuristik genannt (Heuristik = Strategie zur Lösungssuche) Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

23 Vergleich A*- und Dijkstra-Algorithmus Dijkstra-Algorithmus A*-Algorithmus 6 s z s z 6 Schätzfunktion h und Kantengewicht c sind als Euklidischer Abstand definiert. Im Beispiel wird kürzester Weg von Startknoten s nach Zielknoten z berechnet. Reihenfoge der besuchten Knoten in rot. Berechnete kürzeste Wege sind blau markiert. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

24 Schlechtes Verhalten von A* bei Sackgassen A* geht direkt auf das Ziel z zu, läuft aber in eine Sackgasse. s z A* besucht nun einen Knoten, der sich anfangs vom Ziel entfernt und daher nicht früher betrachtet wurde. s z Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

26 Graphen mit negativen Gewichten () Hat ein Graph auch negative Gewichte, dann ist die Existenz eines kürzesten Weges nicht gesichert, da Zyklen mit negativer Länge existieren können. Durch mehrfaches Ablaufen solcher Zyklen kann die Weglänge beliebig klein (negativ) werden. u - v Zyklus mit Länge = + + = - Damit kann die Weglänge von u nach v beliebig klein werden. Die Eindeutigkeit kürzester, einfacher Wege ist jedoch garantiert (d.h. Knoten dürfen nicht mehrfach auftreten). Jedoch sind bis heute hierfür keine effizienten Algorithmen bekannt. Daher: Einschränkung auf beliebig gewichtete Digraphen ohne Zyklen negativer Länge. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09-6

27 Graphen mit negativen Gewichten () Der Algorithmus von Dijkstra arbeitet bei Graphen mit negativ gewichteten Kanten im allgemeinen nicht korrekt: Mit Algorithmus von Dijkstra berechneter Weg mit Länge =.. s= z=9-0 6 Kürzester Weg von s nach z mit Länge = -6. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

28 Algorithmus von Moore und Ford - Idee Single-source shortest-path: Gegeben ist ein gewichteter Digraph (Gewichte können negativ sein). Gesucht sind alle kürzesten Wege zwischen einem Startknoten s und allen anderen Knoten, sofern der Graph keine negativen Zyklen enthält. Ausgangspunkt ist der Algorithmus von Dijkstra. Beim Algorithmus von Dijkstra wird jeder Knoten v höchstens einmal besucht und zwar dann, wenn der kürzeste Weg zu v bekannt ist. Kommen aber negative gewichtete Kanten vor, dann muss jeder Knoten im allgemeinen mehrere Male besucht werden und zwar immer dann, wenn sich ein noch kürzerer Weg ergibt. Die Reihenfolge, in der die Knoten besucht werden, spielt nun keine Rolle mehr. Es wird daher eine Schlange statt einer Vorrangswarteschlange gewählt. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

29 Algorithmus von Moore und Ford void shortestpath (Vertex s, WeightedDiGraph G, double[ ] d, Vertex[ ] p) { Queue<Vertex> kl = Æ; for (jeden Knoten v) { d[v] = ; p[v] = undef; d[s] = 0; // Startknoten kl.add(s); while (! kl.empty()) { v = kl.remove(); for ( jeden adjazenten Knoten w von v ) { () if (d[v] + c(v,w) < d[w]) { () p[w] = v; () d[w] = d[v] + c(v,w); () if (! kl.contains(w) ) () kl.add(w); Ausgabe: Distanzfeld d und Vorgängerfeld p Eingabe: Startknoten s und gewichteter und gerichteter Graph g In der Kandidatenliste sind alle Knoten abgespeichert, die als nächstes besucht werden können. Die Zugriffsoperationen auf die Kandidatenliste sind rot gekennzeichnet. Distanzwert für w verbessert sich. Kürzester Weg nach w geht nun über v. w muss evtl. nochmals besucht werden. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09-9

30 Beispiel zu Moore-Ford-Algorithmus s= Nächster besuchter Knoten ist rot gekennzeichnet. v 6 9 d[v] v 6 9 p[v] Kandiatenliste kl,,,,,,,, 6, 6, 9 6, 9, 9,,,,, 9, 9, 9,, 9 Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09-0

31 Analyse des Moore-Ford-Algorithmus Enthält der Graph keine Zyklen mit negativer Länge, dann wird jeder Knoten maximal ( V -)-mal in die Schlange kl eingefügt (Zeile () im Algorithmus). (Begründung siehe [Turau]). Wird ein Knoten V -mal eingefügt, dann muss es ein Zyklus mit negativer Länge geben und es könnte im Algorithmus eine entsprechende Ausgabe erfolgen. Würde jeder Knoten genau einmal in die Schlange kl eingefügt werden, wäre der Aufwand für alle for-schleifen gerade O( E ). Denn jede Kante im Graph wird genau einmal in einer der for-schleifen betrachtetet. (Zeile () kl.contains(w) kann mit Hilfe eines Booleschen Felds in O() realisiert weden). Da nun aber jeder Knoten bis zu ( V -)-mal in die Schlange kl eingefügt werden kann, erhält man insgesamt: T = O( E * V ). Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

33 Netzpläne Netzpläne sind azyklische Digraphen mit genau einem Start und einem Endknoten. Die Knoten (außer Start- und Endknoten) stellen oft gewisse Aktivitäten dar und sind mit einem Gewicht (Aufwand wie z.b. Zeitangaben) versehen. Start Ende Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

34 Kritischer Pfad Kritischer Pfad ist ein Weg vom Start- zum Ziel-Knoten mit maximalen Aufwand. Beispiel Projektplan: - Die Knoten sind Tätigkeiten, die in einem Projekt durchgeführt werden müssen. - Die Gewichte geben die Zeitdauer der Aktivitäten an. - Die gerichteten Kanten legen Reihenfolgenbeziehungen fest. - Die Länge eines kritischen Pfades gibt die frühestmögliche Projektfertigstellung an. Start Ende Netzplan und kritischer Pfad mit Zeitaufwand Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

35 Bestimmung eines kritischen Pfades Werden die an den Knoten notierten Gewichte an die einmündenden Kanten mit umgekehrtem Vorzeichen verschoben, erhält man einen gewichteten, azyklischen Digraphen. Die Bestimmung des kritischen Pfades lässt sich dann zurückführen auf die Berechnung eines kürzesten Weges vom Start- zum Zielknoten. Start Ende Gewichteter, azyklischer Digraph mit kürzestem Weg der Länge -. Prinzipiell ließe sich der kritische Pfad mit dem Algorithmus von Moore und Ford bestimmen. Für den Spezialfall der Netzpläne ist jedoch ein auf toplogischer Sortierung basierender Algorithmus wesentlich effizienter. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

36 Erweiterte topologische Sortierung () Single-source shortest-path für Netzpläne: Gewichteter, azyklischer Digraph (Gewichte können negativ sein) mit genau einem Startknoten s. Gesucht sind alle kürzeste Wege zwischen s und allen anderen Knoten. Besuche die Knoten wie bei der topologischen Sortierung. Dazu werden in der Schlange alle noch nicht besuchten Knoten gehalten, deren Vorgänger bereits besucht worden sind. Bei jedem Knotenbesuch werden dann wie beim Algorithmus von Moore und Ford für alle Nachfolgerknoten die Distanzen und der gefundene kürzeste Weg gegebenenfalls aktualisiert. Analyse (wie bei der topologischen Sortierung): T = O( E + V ). Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09-6

37 Erweiterte topologische Sortierung () void allshortestpath (WeightedDiGraph g, double[ ] d, Vertex[ ] p) { int[ ] indegree; // Anz. noch nicht besuchten Vorgänger Queue<Vertex> q; for (jeden Knoten v) { d[v] = ; p[v] = undef; indegree[v] = Anzahl der Vorgänger; if (indegree[v] == 0) { q.add(v); d[v] = 0; if (q.size() > ) { println( Fehler; mehr als ein Startknoten ); return; Ausgabe: Distanzfeld d und Vorgängerfeld p Eingabe: Gewichteter Digraph G mit genau einem Startknoten. int k = 0; while (! q.empty() ) { v = q.remove(); k++; for ( jeden Nachfolger w von v ) { if (d[v] + c(v,w) < d[w]) { p[w] = v; d[w] = d[v] + c(v,w); if (--indegree[w] == 0) q.add(w); Programmteile, um die die topologische Sortierung erweitert wurde, sind blau gekennzeichnet. if (k!= n) println( Fehler; Graph ist zyklisch ); Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

38 Beispiel zu erweiterten topologischen Sortierung Start Ende Kürzester Weg Kand.Liste q 0 0,,, 6 6,,, 9, 0 0 v d[v] v p[v] Nächster besuchter Knoten ist rot gekennzeichnet. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

40 Idee des Floyd-Algorithmus All pairs shortest-path: Gegegeben ist ein gewichteter Digraph (Gewichte können negativ sein). Gesucht sind kürzeste Wege zwischen allen Knotenpaaren, sofern der Graph keine negativen Zyklen enthält. Der Algorithmus basiert im wesentlichen auf dem Optimalitätsprinzip von Bellman, das für Graphen ohne Zyklen negativer Länge gilt. Für jeden Knoten u auf einem kürzesten Weg von v nach w gilt: d(v,w) = d(v,u) + d(u,w). D.h. Teilwege von kürzesten Wegen müssen ebenfalls kürzeste Wege sein. v u w Der Floyd-Algorithmus arbeitet nach dem Prinzip des dynamischen Programmierens. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09-0

41 Einschub - dynamisches Programmieren () Problem: Bei rekursiven Funktionen kann es zu mehrfacher Berechnung des gleichen Funktionswerts kommen. Beispiel: Fibonacci-Funktion Aufrufstruktur für fib(): int fib(int n) { if (n == 0) return 0; else if (n == ) return ; else return fib(n-) + fib(n-); fib() fib() fib() fib() fib() fib() fib() fib(0) fib(0) Bei Aufruf von fib() wird -mal fib(), -mal fib() und -mal fib(0) berechnet. Bei Aufruf von fib() wird -mal fib(), -mal fib(), -mal fib(0), -mal fib(9), -mal fib() etc. berechnet. Es lässt sich zeigen, dass bei Aufruf von fib(n) insgesamt etwa (/Ö)*f n+ Aufrufe stattfinden, wobei f = (+Ö)/».6 (f wird auch Goldener Schnitt genannt.) Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

42 Einschub - dynamisches Programmieren () Dynamisches Programmieren: Ausgangspunkt: Rekursiv definierte Funktion. Berechne rekursive Funktion mit Iteration und Tabelle statt Rekursion: Beginne mit den Basisfällen und wende dann Rekursionsschritte aufwärts an, wobei Zwischenergebnisse in einer Tabelle zur späteren Verwendung abgespeichert werden. Dynamisches Programmieren geht auf ein Verfahren zur Optimierung technischer Prozesse von Bellman 9 zurück. Beispiel: Fibonacci-Funktion int[ ] fib = new int[n+]; Tabelle fib[0] = 0; fib[] = ; Basisfälle for (int n = ; n <= N; n++) fib[n] = fib[n-] + fib[n-]; Rekursionsschritt aufwärts angewendet Analyse der Fibonacci-Funktion: dynamisch programmiertes fib: O(n) rekursives fib: O(.6 n ) Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

43 Einschub - dynamisches Programmieren () Weiteres Beispiel aus der Kombinatorik: Eine Auswahl (Teilmenge) von k verschiedenen Elementen aus einer Menge von n Elementen heißt Kombination. Die Anzahl der Kombinationen schreibt man in der Mathematik auch als:! " Dieser Ausdruck ist nur für n k 0 definiert. 9 Beispiel: die Anzahl der möglichen Lottokombinationen ist gleich 6. Rekursive Formulierung! " =! " +! " = falls " = 0! " =, falls " =!! " Rekursionsfall: Um eine k-elementige Teilmenge aus einer Menge mit n Elementen auszuwählen, kann entweder das n-te Element weggelassen oder dazu genommen werden. Basisfälle: Bei k = 0 gibt es nur eine Teilmenge, nämlich die leere Teilmenge. Bei k = n ist die Menge selbst die einzige Teilmenge. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

44 Einschub - dynamisches Programmieren () Iterative Berechnung mit Tabelle int[ ][ ] komb= new int[n+][n+]; for (int n = 0; n <= N; n++) { komb[n][0] = ; // Basisfall () komb[n][n] = ; // Basisfall () Tabelle zum Speichern der Zwischenergebnisse:! komb[n][k] = " // Rekursionsschritt: for (int n = ; n <= N; n++) for (int k = ; k < n; k++) komb[n][k] = komb[n-][k] + komb[n-][k-]; Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

45 Einschub - dynamisches Programmieren () Beispiel: für N = ergibt sich die Tabelle komb wie folgt: n \ k 0 0 Basisfälle + 6 Rekursionsfall komb[n][k] = komb[n-][k] + komb[n-][k-]; Pascalsches Dreieck! Bemerkung: Für die Berechnung von komb[n][k] würde es genügen nur die jeweils letzte Zeile der Matrix zu speichern. Daher eindimensionales Feld statt Matrix. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

46 Kürzeste Wege mit dynamischer Programmierung () Nochmals die Problemstellung - Berechne kürzeste Wege zwischen allen Knotenpaaren in einem gewichteten, gerichteten Graphen. Graph darf keine Zyklen negativer Länge enthalten. - Knoten sind durchnummeriert: v 0, v,, v n-. Formulierung des Problems als Funktion - D k (i, j) = Distanz (Länge eines kürzesten Weges) von v i nach v j, wobei nur Wege von v i nach v j betrachtet werden, die über Knoten aus {v 0, v,, v k gehen. - D n- löst unser Problem! Rekursive Formulierung - Basisfall k = - (nur die direkte Verbindung von v i nach v j ist erlaubt): D - (i, j) = c(v i, v j ) (Gewicht der Kante (v i, v j )) - Rekursionfall (k ³ 0): D k (i, j) = min { D k- (i, j), D k- (i, k) + D k- (k, j) Länge eines kürzesten Wegs von v i nach v j, ohne über v k zu gehen. Länge eines kürzesten Wegs von v i nach v j über v k setzt sich zusammen aus kürzestem Weg von v i nach v k und kürzestem Weg von v k nach v j. (Optimalitätsprinzip von Bellman) Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09-6

47 Kürzeste Wege mit dynamischer Programmierung () Iterative Berechnung von D k mit Tabelle: - D k (i, j) lässt sich für jedes k durch eine -dimensionale Matrix D[i][j] darstellen. D - wird gemäß Basisfall initialisiert; D 0 ergibt sich aus D - nach dem Rekursionsfall, D aus D 0, usw. D n- ist die Lösung unseres Problems. - Es genügt, D k nur für den jeweils aktuellen Wert von k abzuspeichern. D k (i, j) = min { D k- (i, j), D k- (i, k) + D k- (k, j) = min { D k- (i, j), D k (i, k) + D k (k, j) (denn D k (i, k) = D k- (i, k) und D k (k, j) = D k- (k, j)) // Tabelle int[ ][ ] D = new int[n][n]; // Starte mit D - : for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) if (i == j) D[i][j] = 0; else D[i][j] = c(v i, v j ); for (int k = 0; k < n; k++) // Berechne D k : for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) if (D[i][j] > D[i][k] + D[k][j]) D[i][j] = min {D[i][j], D[i][k] + D[k][j] ; D[i][j] = D[i][k] + D[k][j]); Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

48 Speicherung der kürzesten Wege Zur Speicherung der gefundenen Wege wird eine Vorgängermatrix P eingesetzt: P[i][j] = Vorgängerknoten von v j im kürzesten Weg von v i nach v j. Damit kann der kürzeste Weg von Start s nach Ziel z mit z beginnend in eine Liste von hinten nach vorne eingetragen werden: List<Integer> getshortestpath (int s, int z, Vertex[ ][ ] P) LinkedList<Integer> shortestpath; Vertex v = z; // Ziel while ( v!= s ) { shortestpath.addfirst(v); v = P[s][v]; shortestpath.addfirst(s); kürzester Weg von s nach z. return shortestpath; Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -

49 Algorithmus von Floyd void computeallshortestpath (WightedDiGraph G, double[ ][ ] D, Vertex[ ][ ] P) { // Initialisiere D und P: for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { P[i][j] = undef; if (i == j) D[i][j] = 0 else { D[i][j] = c(v i, v j ); //, falls keine Kante (v i,v j ) existiert if (D[i][j]!= ) P[i][j] = i; Ausgabe: Distanzmatrix D und Vorgängermatrix P Eingabe: Gewichteter Digraph G mit n Knoten. for (int k = 0; k < n; k++) // Berechne D k : for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) if (D[i][j] > D[i][k] + D[k][j]) { D[i][j] = D[i][k] + D[k][j]; P[i][j] = P[k][j]; Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09-9

50 Analyse des Floyd-Algorithmus Enthält der Graph Zyklen mit negativer Länge, dann wird ein Diagonalelement von D negativ. Der Algorithmus kann leicht um eine passende Abprüfung mit entsprechender Ausgabe erweitert werden. Analyse: die dreifach geschachtelten for-schleifen ergeben: T = O( V ). Vergleich zu Dijkstra-Algorithmus: Ist der Graph dünn-besetzt (d.h. E = O( V ) und alle Gewichte positiv, dann kann der Dijkstra-Algorithmus mit einem Index-Heap auch für jeden Knoten aus V als Startknoten durchgeführt werden. Damit: T = O( V E log( V ) = O( V log( V ). Also: Dijkstra-Algorithmus besser als Floyd-Algorithmus. Ist der Graph dicht besetzt und alle Gewichte positiv, dann würde das V -malige Durchführen des Dijkstra-Algorithmus (mit unsortierter Prioritätsliste) ebenfalls zu T = O( V ) führen. Dann ist aber aufgrund der einfacheren Datenstruktur der Floyd-Algorithmus besser als der Dijkstra-Algorithmus. Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09-0

51 Beispiel zu Floyd-Algorithmus v 0 v - - v - v - v D - D 0 D D D D P - P 0 P P P P Prof. Dr. O. Bittel, HTWG Konstanz Algorithmen und Datenstrukuren Kürzeste Wege in Graphen SS 09 -