Kürzeste Wege in Graphen

Transkript

1 Kürzeste Wege in Graphen Algorithmische Paradigmen In diesem Abschnitt wollen wir nicht nur neue Algorithmen vorstellen, sondern auch den Blick auf Gemeinsamkeiten und prinzipielle Unterschiede zwischen verschiedenen Algorithmen richten. Bei genauerer Betrachtung findet man bestimmte Grundmuster, welche beim Entwurf von Algorithmen sehr häufig auftreten, man spricht dann von algorithmischen Paradigmen. Drei solche Grundmuster werden wir etwas näher kennenlernen: 1. Greedy Algorithmen (gierige oder gefräßige Algorithmen) 2. Divide and Conquer (das Prinzip vom Teilen und Herrschen) 3. Dynamische Programmierung Zu den weiteren Paradigmen (auf die wir hier nicht näher eingehen werden) gehören u.a. die Randomisierung, Approximationsalgorithmen, lineare Optimierung und genetische Algorithmen. Greedy Algorithmen sind per Definition eng mit dem mathematischen Begriff des Matroids verknüpft, aber man kann ihre Gemeinsamkeiten auch verbal beschreiben als Algorithmen für Optimierungsprobleme, bei denen eine vorhandene Lösung für ein Teilproblem immer schrittweise erweitert wird bis man eine Lösung des Gesamtproblems erreicht hat. Typische Vertreter sind Breiten- und Tiefensuche sowie der Algorithmus von Prim zur MST-Berechnung. Im Gegensatz dazu wird die Gesamtlösung bei einem Ansatz mit Divide and Conquer aus den Lösungen mehrerer Teilprobleme zusammengesetzt, in der Regel kombiniert mit rekursiven Aufrufen. Um zu einer effizienten Lösung zu kommen, sollte bei jeder Aufspaltung die Anzahl der neuen Teilprobleme konstant sein (im Standardfall zwei) und die Größe der neuen Teilprobleme um einen konstanten Faktor c < 1 abnehmen (z.b. Halbierung der Größe). Bekannte Vertreter sind Merge Sort und die Binärsuche. Bei der dynamischen Programmierung wird die Lösungsmenge von vielen Teilproblemen einer bestimmten Größe m im nächsten erweitert auf eine Lösungsmenge von Teilprobleme der Größe m + 1. Im Gegensatz zu Greedy Algorithmen reicht also die Lösung eines Teilproblems nicht aus zur Erweiterung, sondern man muss den Zugriff auf verschiedene Teillösungen haben. Oft kann man die Teillösungen in Form einer Tabelle erfassen und verwalten. Wir haben noch keinen typischen Vertreter kennengelernt, aber die Berechnung der Binomialkoeffizienten mit dem Pascalschen Dreieck gehört im weiteren Sinne auch zu dieser Klasse. Im Folgenden wollen wir uns mit der Bestimmung kürzester Wege in Graphen beschäftigen. Dazu sei G = (V, E) ein gerichteter Graph mit einer Gewichtsfunktion w : E R, die den Kanten nichtnegative Gewichte ( Länge der Kante) zuordnet. Wir definieren das Gewicht eines Weges als die Summe der Gewichte seiner Kanten. Unser erstes Ziel wird es sein, für einen Startknoten s leichteste, also im Sinne der Anwendung kürzeste, Wege zu allen anderen erreichbaren Knoten zu berechnen. Man beachte, dass sich die Weglänge dann nicht auf die ursprüngliche Definition (Anzahl der Kanten) bezieht, sonder auf die Summen der Kantengewichte. Haben alle Kanten das gleiche Gewicht, dann stimmen die beiden Begriffsbildungen überein. In einem zweiten Schritt wird es darum gehen, für alle Knotenpaae jeweils kürzeste Wege zu berechnen. 1

2 Der Algorithmus von Dijkstra Vorüberlegungen: Die Eigenschaft kürzester Weg vererbt sich auf Teilwege. Ist also p ein kürzester Weg von u nach v über die Zwischenknoten u und v, dann ist der induzierte Teilweg von u nach v auch ein kürzester. Damit kann man kürzeste Wege von s zu allen erreichbaren Knoten so auswählen, dass sie einen Baum bilden, den man kompakt mittels der π Zeiger verwaltet. Breitensuche ist ein Spezialfall eines Kürzesten-Wege-Problems, alle Kanten haben Gewicht 1. Idee des Algorithmus In Analogie zum MST Algorithmus von Prim vergrößern wir in jedem Schritt eine Menge S von Knoten, für die die Abstände von s und kürzeste Wege bereits bestimmt sind. Der Algorithmus ist greedy. Für jeden Knoten v in V \ S halten wir einen Schlüssel d[v] aufrecht, der sagt, wie lang der bisher bekannte kürzeste Weg von s nach v ist und wir merken uns auch, wer der Vorgänger π[v] auf einem solchen Weg ist. Die Schlüssel d[v] werden in einer Prioritäts Warteschlange Q verwaltet. Wir nehmen den Kopf u der Warteschlange in S auf und müssen überprüfen, ob man dessen Nachbarn v von s aus über u besser (d.h. auf kürzerem Weg als bisher bekannt) erreichen kann. Dies nennt man Relaxieren und formal ist es folgendes: Falls d[v] > d[u] + w(u,v) dann ersetze d[v] durch d[u] + w(u,v) und π[v] zeigt jetzt auf u. Adj[u] v s u S V\S Obige Abbildung zeigt, welche Knoten des Graphen nach Entfernung eines minimalen Elements u aus der Prioritätswarteschlange betrachtet werden müssen. Hier ist der formale Pseudocode. 2

3 Dijkstra(G,w,s) for all v V(G) d[v] = π[v] = Nil d[s] = 0 S = /0 for all v V(G) insert v in Q while Q not empty u = Extract-Min(Q) S = S {u} for all v Adj[u] if (d[v] > d[u] + w(u,v)) π[v] = u d[v] = d[u] + w(u,v) Welche Laufzeit erreicht dieser Algorithmus? Die Antwort hängt von der konkreten Realisierung der Prioritätsschlange ab: Verwendet man unsortierte Arrays, so kostet Extract-Min im worst case Länge des Arrays, während die Update-Operation in konstanter Zeit geht, also insgesamt O( V 2 ). Verwendet man binäre Heaps, so kostet Extract-Min O(log V ) Zeit. Die Updates gehören nicht zu den Basisoperationen einer Prioritätswarteschlange, aber man kann sie analog zum Verhalden eines neuen Elements in O(log V ) Zeit implementieren. Zu beachten ist dabei, dass in einem Feld die Positionen der Knoten in der Halde gespeichert werden müssen. Insgesamt erhalten wir eine Laufzeit von O( E log V ). Korrektheitsbeweis für den Algorithmus: Bezeichne d G (s,v) die Länge eines kürzesten Weges von s nach v. Wir müssen zeigen, dass in dem Moment, wenn v in S aufgenommen wird, d G (s,v) = d[v] gilt (danach wird d[v] nicht mehr verändert!) Zunächst ist klar, dass im Algorithmus zu jedem Zeitpunkt und für jeden Knoten v gilt d[v] d G (s,v). Die entgegengesetzte Ungleichung wird indirekt bewiesen. s S x u Ein kuerzester Weg von s nach u y ist der erste Knoten ausserhalb von S, x der Vorgaenger von y auf diesem Weg y 3

4 Beweis mit Widerspruch: 1. Sei u der zeitlich erste (!!) Knoten, für den bei Aufnahme in S gilt d[u] > d G (s,u), also der Algorithmus einen Fehler macht. 2. Sei y erster Knoten auf einem tatsächlich kürzestem Weg von s nach u, der in V \ S liegt. Für y gilt aber d[y] = d G (s,y). Begründung: d[x] ist korrekt für den Vorgänger x von y (es gilt x S). Nach Annahme war u ja erster Fehler. Bei Aufnahme von x in S wurde Kante (x,y) relaxiert, also ist auch d[y] korrekt. Wenn y = u, sind wir hier schon fertig. 3. Ansonsten haben wir: d[u] > d G (s,u) = d G (s,y) + d G (y,u) = d[y] + d G (y,u). Aber damit ist d[u] > d[y] bei der Aufnahme von u in S, weil d G (y,u) nichtnegativ ist. 4. Das ist aber der gesuchte Widerspruch, der Algorithmus hat u genommen, hätte aber tatsächlich y mit dem kleineren Schlüssel nehmen müssen. Anmerkung: Für die meisten Anwendungen ist die Voraussetzung von nichtnegativen Kantengewichten keine wirkliche Einschränkung. Der Algorithmus arbeitet aber sogar für Graphen mit negativen Kantengewichten korrekt, wenn man die Existenz von sogenannten negativen Zyklen ausschließen kann. Damit sind gerichtete Kreise gemeint, deren Kantengewichte sich zu einem negativen Wert aufsummieren. Der A -Algorithmus Wird vom Startknoten s nur der kürzeste Weg zu einem bestimmten Zielknoten w gesucht (Dijkstra berechnet die kürzesten Wege zu allen möglichen Zielknoten), dann kann der Algorithmus unter bestimmten Voraussetzungen beschleunigt werden. Das ist insbesondere der Fall, wenn der Graph neben den Kantengewichten auch eine Einbettung in die Ebene hat mit der Eigenschaft, dass für jede Kante (u,v) die Ungleichung w G (u,v) dist(u,v), wobei dist(u,v) den Euklidischen Abstand zwischen den Punkten u und v angeben soll. Diese Situation liegt z.b. bei Navigationssystemen vor: Die Länge w G (u,v) einer Straßenverbindung von u nach v kann nicht kürzer als die Luftlinie dist(u,v) sein. Das Problem bei der Anwendung des Dijkstra Algorithmus, um z.b. die kürzeste Route von Berlin nach München zu berechen, besteht darin, dass man erst zum richtigen Ergebnis kommen kann, wenn man vorher auch die kürzesten Routen nach Hamburg, Kiel und Rostock berechnet hat, also von Städten, die näher an Berlin liegen als München, aber für den kürzesten Weg nach München bestimmt nicht relevant sind. Der A Algorithmus verfolgt die Idee, die Schlüsselwerte in der Prioritätswarteschlange so zu verändern, dass Orte, die dichter am Ziel liegen (und somit als Zwischenknoten in Frage kommen) bevorzugt werden gegen Orte, die weit vom Ziel entfernt sind. Dafür führt man eine Heuristik h : V R + ein mit welcher der kürzeste Weg von einem Zwischenknoten u zum Zielknoten w von unten abschätzt. Es muss also immer h(u) d G (u,w) gelten. Bei Navigationssystemen kann man h(u) = dist(u, w) setzen. An Stelle des Dijkstra-Schlüssels d[u], der die Länge des kürzesten bekannten Wegs repräsentiert, setzt man als neuen Schlüssel den Wert f [u] = d[u] + h(u). Damit bekämen in unserem Beispiel mit s = Berlin und w = München alle Orte nörlich von Berlin schon allein durch den großen Euklidischen Abstand zu München einen hohen Schlüsselwert, Orte auf dem kürzesten Weg nach München würden dagegen bevorzugt aus der Warteschlange entfernt werden. 4

5 Der Algorithmus von Floyd-Warshall Ziel ist es, für einen gerichteten Graphen G = (V, E) und eine Kantengewichtsfunktion w alle Abstände zwischen Knoten und realisierende kürzeste Wege zu finden. Das heißt dann All-Pair-Shortest-Path- Problem. Wir setzen wieder voraus, dass es keine Kreise mit negativem Gesamtgewicht gibt. Natürlich läßt sich dieses Problem durch Anwendung des Dijkstra-Algorithmus für jeden möglichen Startknoten s lösen. Wir werden aber sehen, dass es konzeptionell viel einfacher geht und insbesondere nur elementare Datenstrukturen nötig sind. Das dahinter stehende algorithmische Prinzip ist das des Dynamischen Programmierens. Die Idee: Wir benennen die Knoten mit 1,...,n. Ziel ist, eine n n Matrix D zu berechnen, deren Einträge d i, j die Länge eines kürzesten gerichteten Weges von i nach j angibt. Ausgangspunkt ist die Kostenmatrix W welche für vorhandene Kanten das Kantengewicht, Nullen auf der Diagonalen und für Nicht Kanten enthält. Zusätzlich werden wir mit π-verweisen wie bei Dijkstra tatsächlich kürzeste Wege implizit verwalten. Sei also Π die n n Matrix, deren Eintrag π i, j der Vorgänger des Knotens j auf einem kürzesten Weg von i nach j ist. Wir werden zunächst starke Einschränkungen auf das Problem legen, die eingeschränkten Problem lösen und dann die Einschränkungen wieder Schritt für Schritt wegnehmen, bis wir wieder beim Ausgangsproblem sind. Wie sehen die Einschränkungen aus? Wir betrachten für die Knoten i, j nicht mehr alle Wege von i nach j und suchen darunter einen kürzesten, sondern wir schränken die Menge der möglichen Zwischenknoten (die diese Wege benutzen können, aber nicht müssen) ein. Wir definieren: Sei d (k) i, j die Länge eines kürzesten Weges von i nach j, der nur Zwischenknoten aus der Knotenmenge {1,..., k} benutzt. Nichtdefinierte Werte werden auf gesetzt. Für k = 0 erlauben wir gar keine Zwischenknoten! Die π (k) i, j sind analog definiert, NIL falls der Knoten nicht existiert. Zentrale Beobachtung: Die Matrizen D (k) der d (k) i, j Werte und die Matrizen Π(k) der Knoten π (k) i, j lassen sich bottom up sehr einfach berechnen. Initialisierung: Die Matrizen D (0) und Π (0) kann man direkt aus der Adjazenzmatrix A = (a i, j ) des Graphen (dies ist hier die geeignete Datenstruktur, a i, j die Länge der Kante) ablesen. d (0) π (0) 0 i = j a i, j i j sonst i i NIL i = j i j sonst D (k) gewinnt man aus D (k 1) mittels der folgenden rekursiven Beziehung: 5

6 d (k) min{d (k 1) i, j,d (k 1) + d (k 1) } Denn wenn der Knoten k als Zwischenknoten vorkommt dann nur ein Mal!! Und analog: π (k) { π (k 1) i, j falls d (k 1) π (k 1) sonst Es ist offensichtlich D (n) = D und Π (n) = Π. i, j < d (k 1) + d (k 1) Zwischenknoten aus der Menge {1,2,...,k} i k j Zwischenknoten aus der Menge {1,2,...,k 1} Zwischenknoten aus der Menge {1,2,...,k 1} i j Zwischenknoten aus der Menge {1,2,...,k 1}, also ohne k Dies ergibt sofort den folgenden Algorithmus für die Bestimmung von D (n) : Floyd Warshall(W,n) D (0) = W for k = 1 to n for i = 1 to n for j = 1 to n d (k) min( d (k 1) return D (n) i, j,d (k 1) + d (k 1) ) Die Laufzeit dieses Algorithmus ist offensichtlich Θ(n 3 ). Eine Variante: Die transitive Hülle eines gerichteten Graphen G = (V,E) ist der Graph G = (V,E ), wobei es in G eine Kante von i nach j gibt, falls in G ein gerichteter Weg von i nach j existiert. Man kann eine einfache Abwandlung des Floyd Warshall dazu benutzen, die transitive Hülle zu bestimmen. Dazu sei t (k) i, j eine Boolesche Variable, die 1 ist, falls ein gerichteter Weg mit Zwischenknoten aus 6

7 {1,...,k} von i nach j existiert und 0 sonst. Offensichtlich gilt: t (k) t (k 1) mit der Initialisierung t (0) i, j (t (k 1) 1 i = j 1 i j 0 sonst t (k 1) ) 7