Undirected Single-Source Shortest Paths with Positive Integer Weights in Linear Time

Transkript

1 Universität Konstanz Mathematisch-naturwissenschaftliche Sektion Fachbereich Mathematik und Statistik Wintersemester 2001/02 Mikkel Thorup: Undirected Single-Source Shortest Paths with Positive Integer Weights in Linear Time Seminar: Leiterin: Betreuung: Effiziente Algorithmen Prof. Dr. Dorothea Wagner Frank Schulz Referentin: Annemarie Kastelsky Anschrift: Markgrafenstraße Konstanz Fächer: Französisch, Mathematik Fachsemester: 8

2 1 Einleitung Das Single-Source Shortest Paths Problem (SSSP-Problem) ist eine klassische Problemstellung. Gegeben ist ein Graph mit ganzzahligen positiven Kantengewichten und einem ausgezeichneten Knoten s. Gesucht werden kürzeste Wege von s zu allen anderen Knoten im Graphen. Im Folgenden ist dieser Graph zusätzlich ungerichtet. Diese Problemstellung wurde durch den Algorithmus von Dijkstra (1959) gelöst. Dieser war Grundlage für die weitere Entwicklung von Algorithmen zu diesem Problem. Da einige Elemente dieses Algorithmus auch in den Linearzeitalgorithmus von Thorup eingehen, wird zunächst der Algorithmus von Dijkstra kurz vorgestellt. Anschließend werden zwei Etappen auf dem Weg zu Thorups Linearzeitalgorithmus nachgezeichnet, die die andere Vorgehensweise seines Algorithmus zeigen. Der erste Schritt ist die Entwicklung des Algorithmus A, der das SSSP- Problem löst, wenn sich der Graph so in Teilmengen aufteilen lässt, dass alle Kanten zwischen den Teilmengen mindestens Gewicht 2 α haben. Im zweiten Schritt wird diese Einschränkung durch die Einführung einer Komponentenhierarchie wieder verallgemeinert. Diese führt zu den Algorithmen B und C, in denen minimale Komponenten besucht werden. Schließlich wird kurz aufgezeigt, wie dieser Algorithmus effizienter gestaltet werden kann, so dass man eine lineare Laufzeit erhält. Abschließend werden die Ergebnisse von Thorup vorgestellt. 1

3 2 Grundlagen und der Algorithmus von Dijkstra 2.1 Grundlagen Definitionen Sei G = (V, E), V = n, E = m ein zusammenhängender ungerichteter Graph mit einer Kantengewichtsfunktion l : E N und einem ausgezeichneten Knoten s V. Falls (v, w) E setzt man l(v, w) :=. d(v) ist die Distanz (= kürzester Weg) von s nach v. D(v) ist eine Weglänge von s nach v, also gilt immer D(v) d(v). S Teilmenge, S V, so dass v S : D(v) = d(v) v S : D(v) = min u S {d(u) + l(u, v)} Knoten besuchen Man kann einen Knoten v S nur besuchen, wenn D(v) = d(v) gilt. v wird zur Menge S dazugenommen und für die Nachbarknoten w von v wird D(w) neu bestimmt: Für alle (v, w) E, w S : D(w) = min{d(w), D(v) + l(v, w)} Folgerung Um Knoten besuchen zu können, ist es also nötig zu wissen, für welche v D(v) = d(v) gilt. Lemma 1 Wenn für ein v V \ S D(v) minimal ist, dann gilt D(v) = d(v). Beweis: Sei u der erste Knoten außerhalb von S auf einem kürzesten Weg von s nach v. Dann gilt D(u) = d(u) nach Definition von S. D(v) d(v) d(u) = D(u) D(v), da D(v) nach Voraussetzung minimal ist. Also gilt D(v) = d(v). Lemma 2 min D(V \ S) = min d(v \ S) ist nicht fallend. 2

4 Beweis: Zeigen zunächst die Gleichheit: Falls S = V gilt min D(V \ S) = min d(v \ S) = min =. (min = nach Definition.) Andernfalls existiert ein v V \ S mit d(v) minimal. Sei u der erste Knoten außerhalb von S auf einem kürzesten Weg von s nach v. Dann ist D(u) = d(u) d(v) (Lemma 1). Da für v d(v) minimal ist, gilt d(u) = d(v). Also folgt: min D(V \ S) D(u) = d(u) = d(v) = min d(v \ S). Andererseits ist für alle w V D(w) d(w) und somit min D(V \ S) min d(v \ S). Daraus folgt: min D(V \ S) = min d(v \ S). Zeigen nun: min d(v \ S) ist nicht fallend: d(w) ändert sich nicht für alle w V. S wird größer, also sucht man das minimale d(w) in einer immer kleineren Menge S \ V mit konstanten d- Werten. min d(v \ S) kann also höchstens größer werden. 2.2 Algorithmus von Dijkstra Der Algorithmus von Dijkstra beruht auf Lemma 1 und Lemma 2. Algorithmus von Dijkstra { 0 : v = s D 1 Setze D(v) := { : sonst s : v = s D 2 Setze V or(v) := nil : sonst D 3 S := D 4 Solange V \ S D 4.1 Finde u V \ S mit D(u) minimal D 4.2 Setze S := S {u} D 4.3 Für alle v {w V w V \ S und (u, w) E} führe aus: D Falls D(u) + l(u, v) < D(v) D Setze D(v) := D(u) + l(u, v) D Setze V or(v) := u 3

5 a s 3 12 b c 2 d 1 1 e 15 f Beginn: S = D(s) = 0, für alle v s : D(v) = 1. Durchlauf (Schleife) S = {s} D(b) = 3, D(e) = 1 2. Durchlauf S = {s, e} D(b) = 3, D(f) = Durchlauf S = {s, e, b} D(a) = 8, D(c) = 15, D(f) = Durchlauf S = {s, e, b, a} D(c) = 15, D(d) = 16, D(f) = Durchlauf S = {s, e, b, a, c} D(d) = 16, D(f) = Duchlauf S = {s, e, b, a, c, d} D(f) = Durchlauf S = {s, e, b, a, c, d, f} Wie leicht ersichtlich ist, müssen für diesen Algorithmus die Knoten nach D(v) sortiert werden. Das bedeutet, um den Algorithmus von Dijkstra in Linearzeit implementieren zu können, ist es nötig, in Linearzeit sortieren zu können (Fredman und Tarjan 1987). Andererseits setzt Sortieren in Linearzeit voraus, dass der Algorithmus von Dijkstra in Linearzeit implementiert werden kann (Thorup 1996). Folgerung Da es nicht möglich ist, die Knoten in Linearzeit nach D(v) zu sortieren, ist es also zur Entwicklung eines Linearzeitalgorithmus für das SSSP-Problem nötig, sich von Dijkstras Algorithmus zu lösen und andere Techniken zu verwenden. Wir suchen daher eine andere Bedingung, so dass zwar gilt D(v) = d(v), aber eventuell D(v) min D(V \ S). 4

6 3 Entwicklung des Algorithmus A 3.1 Die andere Bedingung Lemma 3 Sei die Knotenmenge von V in disjunkte Teilmengen V 1,..., V k aufteilbar, so dass alle Kanten zwischen den Teilmengen mindestens Gewicht δ haben. Für ein i und v V i \ S gelte D(v) = min D(V i \ S) min D(V \ S) + δ. Dann gilt D(v) = d(v). a s 3 b 12 c 2 d 1 1 e 15 f V lässt sich in zwei Teilmengen V 1 = {s, a, b, e} und V 2 = {c, d, f} aufteilen. Alle Kanten zwischen den Teilmengen V 1 und V 2 haben ein Gewicht δ = 8. Sei nun S = {s, b, e} wie nach dem zweiten Durchlaufen der Schleife des Algorithmus von Dijkstra. Dann gilt die zweite Bedingung des Lemma 3 für i = 2 und v = c: Für c V 2 \S = {c, d, f} gilt: D(c) = 15 = min D(V 2 \S), da D(f) = D(c) = und 15 min D(V \ S) + 8, denn V \ S = {a, c} mit D(a) = 8 und D(c) = 15. Beweis: Sei u der erste Knoten außerhalb von S auf einem kürzesten Weg von s nach v. Dann ist D(u) = d(u). Falls u V i, folgt wie bei Lemma 1: D(v) d(v) d(u) = D(u) D(v), also D(v) = d(v). Sei u V i. Dann haben alle Kanten zwischen V \ V i ( u) und V i ( w) Gewicht δ. Also folgt: D(v) d(v) d(u) + δ = D(u) + δ. Andererseits gilt: D(u) + δ min D(V \ S) + δ Vor = min D(V i \ S) Vor = D(v). Daraus folgt D(v) = d(v). 5

7 3.2 Technische Voraussetzungen Um dieses Ergebnis in einen Algorithmus umsetzen zu können, müssen zwei technische Voraussetzungen erfüllt werden. Eine Voraussetzung für den Algorithmus A und den späteren Linearzeitalgorithmus ist das RAM-Modell, die andere Vorausetzung die Verwendung von Buckets. RAM-Modell Bei diesem Modell ist der Speicher in adressierbare Wörter der Länge ω eingeteilt. So werden alle Gewichte und Weglängen als Binärzahlen der Länge ω gespeichert. Innerhalb des RAM-Modells wird es manchmal vorgezogen, sich auf so genannte AC 0 -Operationen zu beschränken. Diese beinhalten die Addition, die shift -Operation aber keine Multiplikation. Die shift -Operation Die shift -Operation wird als x i notiert, was für x 2 steht. i x = 6 in Binärzahlen: = 6 2 = = 6 2 = Betrachtet man statt der Dezimalzahlen die Binärzahlen, so sieht man, dass bei einer Zahl x durch die shift -Operation gerade die i letzten Stellen gestrichen werden. Buckets Ein Bucket B ist eine Menge, in die beliebige Elemente in konstanter Zeit eingefügt werden können und aus der ein beliebiges Element in konstanter Zeit wieder entfernt werden kann. Solche Buckets können zum Beispiel als doppeltverkettete Liste implementiert werden. Das RAM-Modell ermöglicht durch die Adressierbarkeit der Wörter die Erstellung eines Arrays mit l Buckets B(1) bis B(l), so dass in konstanter Zeit Elemente in B(i) eingefügt oder aus B(i) entfernt werden können. Mit diesen Voraussetzungen lässt sich nun ein Algorithmus formulieren, der auf Graphen angewandt werden kann, die die Bedingung aus Lemma 3 erfüllen. Dazu wählt man δ := 2 α. Die Indizes der Teilmengen i {1,..., k} werden so in Buckets einsortiert, dass i B(V i \ S) α. 6

8 Anzahl der benötigten Buckets D(v) heißt, es gibt einen Weg von s nach v mit Länge D(v). Es gilt: D(v) e E l(e). Der maximale Index eines nichtleeren Buckets ist begrenzt durch = e E l(e) α. Die benötigten Bucketindizes sind folglich 0, 1,...,,. Insgesamt benötigt man also + 2 Buckets. 3.3 Algorithmus A Algorithmus A löst das SSSP-Problem, wenn V in Teilmengen V 1,..., V k aufgeteilt ist, wobei alle Kanten zwischen den Teilmengen mindestens Gewicht 2 α haben. A 1 S := {s} D(s) := 0 für alle v s : D(v) := l(s, v) A 2 für ix := 0, 1,...,, : B(ix) := A 3 für i := 1,..., k: füge i in B(min D(V i \ S) α) ein A 4 für ix := 0 bis A 4.1 solange B(ix) A nimm i B(ix) A nimm v V i \ S mit D(v) minimal A für alle (v, w) E, w / S A A A sei j so, dass w V j D(w) := min{d(w), D(v) + l(v, w)} falls min D(V j \ S) α verringert wird, verschiebe j nach B(min D(V j \ S) α) S := S {v} falls min D(V i \ S) α vergrößert wird, verschiebe i nach B(min D(V \ S) α) 7

9 a s 3 b 12 c 2 d 1 1 e 15 f α = 3, V 1 = {s, a, b, e}, V 2 = {c, d, f} A 1 S = {s}, D(s) = 0, D(b) = 3, D(e) = 1, für alle anderen v: D(v) = A 2 = 58 3 = 7 A 3 (Der Übersicht halber steht nun V 1 statt i = 1 bzw. V 2 statt i = 2:) V 1 B(0), V 2 B( ) 1. Durchlauf B(0) nimm V 1, nimm e, da D(e) = 1 minimal in V 1 D(f) = 16, also V 2 B(2) S = {s, e} 2. Durchlauf B(0) nimm V 1, nimm b, da D(b) = 3 minimal in V 1 D(c) = 15, also V 2 B(1) D(a) = 8 S = {s, e, b} und V 1 B(1) 3. Durchlauf B(1) nimm V 2, nimm c, da D(c) = 15 minimal in V 2 D(d) = 17 S = {s, e, b, c} und V 2 B(2) 4. Durchlauf B(1) nimm V 1, nimm a, da D(a) = 8 minimal in V 1 D(d) = 16 S = {s, e, b, c, a} und V 1 B( ) 5. Durchlauf B(2) nimm V 2, nimm f, da D(f) = 16 minimal in V 2 S = {s, e, b, c, a, f} 6. Durchlauf B(2) nimm V 2, nimm d, da D(d) = 16 minimal in V 2 S = {s, e, b, c, a, f, d} und V 2 B( ) 8

10 Korrektheit Die Korrektheit des Algorithmus A beruht auf dem Einsortieren der i in entsprechende Buckets und folgt aus Lemma 3. min D(Vi \ S) min D(V \ S) min D(V i \S) min D(V \S)+2 α 2 α 2 α min D(V i \ S) α min D(V \ S) α min D(V i \ S) D(V \ S) + δ Es gilt: min D(V \ S) α = min i (min D(V i \ S) α). Wenn i also im nichtleeren Bucket mit dem kleinsten Index ist, gilt: min D(V i \ S) α = min D(V \ S) α. Sei nun ix der kleinste Index eines nichtleeren Buckets. Falls i B(ix) und für v V i \ S D(v) minimal ist, gilt: D(v) = min D(V i \ S) min D(V \ S) + δ Lemma = 3 D(v) = d(v) Laufzeit Die Laufzeit des Algorithmus A ist in O(m + )+ Kosten für das Behalten von min D(V i \ S) für jedes i. Diese Laufzeit kann verringert werden, indem man min D(V i \ S) rekursiv behält und indem man die Anzahl der Buckets verringert. Für letzteres genügt es, α groß zu wählen. Folgerung Wir suchen nun eine rekursive Bedingung, um D(v) = d(v) schließen zu können. 9

11 4 Entwicklung eines rekursiven Algorithmus 4.1 Komponentenhierarchie Definition G i ist ein Subgraph von G, dessen Kantenmenge die Kanten von G sind mit l(e) 2 i. G 0 besteht aus einzelnen Knoten. ω ist die Wortlänge, das heißt, alle Kantengewichte und Weglängen sind 2 ω, also G ω = G. Auf dem i-ten Level sind die Komponenten von G i. Die Komponente auf dem i-ten Level, die v enthält, wird mit [v] i bezeichnet. Diese Komponentenhierarchie lässt sich auch als Baum darstellen. In dieser Darstellung sind die Blätter die Komponenten, die nur aus einem Knoten bestehen. Die Wurzel ist der Knoten [v] r = G mit minimalem r. a s 3 b 12 c 2 d 1 1 e 15 f [s] 0 [e] 0 Lemma 4 Falls [v] i [w] i dann ist dist(v, w) 2 i. [s] 4 [c] 3 [c] 2 [s] 3 [s] 2 [a] 2 [s] 1 [b] 1 [a] 1 [c] 1 [d] 1 [b] 0 [a] 0 [c] 0 [f] 0 [d] 0 Beweis: Da [v] i [w] i enthält jeder Weg von v nach w eine Kante mit Gewicht 2 i. Definition [w] i 1 mit [w] i = [v] i heißt Kind von [v] i, das heißt w [v] i In der Darstellung als Baum sind Kinder gerade die direkten Nachfolger eines Knotens. Notation [v] i := [v] i \ S, [v] i muss dabei nicht zusammenhängend sein. 10

12 Definition [v] i heißt min-child von [v] i+1, falls min(d([v] i )) i = min(d([v] i+1 )) i Sei S = {s, e, b}: [s] 3 ist min-child von [s] 4 : [c] 3 ist min-child von [s] 4 : D(a) = 8 D(c) = 15 min(d([s] 3 )) 3 = 1 min(d([c] 3 )) 3 = 1 min(d([s] 4 )) 3 = 1 min(d([s] 4 )) 3 = 1 [c] 1 ist min-child von [c] 2 : [d] 1 ist nicht min-child von [c] 2 : D(c) = 15 D(d) = 16 min(d([c] 1 )) 1 = 7 min(d([d 1 )) 1 = 8 min(d([c] 2 )) 1 = 7 min(d([c 2 )) 1 = 7 Definition [v] i heißt minimal, falls [v] i und für m = i,..., r 1 gilt: [v] i ist min-child von [v] i+1. Die Bedingung [v] i ist wichtig für den Fall V = S. Falls V = S, ergibt sich min(d([v] i )) = min = für alle [v] i. Dann sind alle [v] i minimal. Durch die Bedingung [v] i ist im Fall V = S kein [v] i minimal. Sei S = {s, e, b}: a ist minimal und c ist minimal. Lemma 5 Falls v S und [v] i minimal ist, gilt min(d([v] i )) = min(d([v] i )). Insbesondere falls [v] 0 = {v} minimal ist, gilt D(v) = d(v). 4.2 Algorithmus B und Algorithmus C Damit ergibt sich ein rekursives Vorgehen, um eine minimale Komponente zu besuchen: Für Kinder [v] i 1 von [v] i wird überprüft, ob min(d([w] i 1 )) i 1 = min(d([v] i )) i 1 = ix([v] i), wobei ix([v] i ) ein Index ist. Dies geschieht so lange bis ein [v] 0 = {v} gefunden ist, das minimal ist. Dann kann man dieses v besuchen. 11

13 Algorithmus B Eingabe: Graph G = (V, E) mit einer Kantengewichtsfunktion l und einem ausgezeichneten Knoten s. Ausgabe: D mit D(v) = d(v) = dist(s, v) für alle v V. B 1 S := {s} B 2 D(s) := 0 für alle v s: D(v) := l(s, v) B 3 Visit ([s] ω ) B 4 Gib D aus Algorithmus C Der Algorithmus Visit ([v] i ) setzt voraus, dass [v] i minimal ist. Visit ([v] i ) C 1 falls i = 0, besuche v und gehe zurück C 2 falls v noch nie besucht wurde: ix([v] i ) := min D([v] i ) i 1 C 3 wiederhole bis [v] i = oder bis ix([v] i ) i erhöht wird: C 3.1 solange es ein Kind [w] i 1 von [v] i gibt, so dass min D([w] i 1 ) i 1 = ix([v] i) C sei [w] i 1 ein Kind von [v] i mit min D([w] i 1 ) i 1 = ix([v] i) C Visit ([w] i 1 ) C 3.2 erhöhe ix([v] i ) um 1 a s 3 b 12 c 2 d 1 1 e 15 f [s] 0 [e] 0 [s] 4 [c] 3 [c] 2 [s] 3 [s] 2 [a] 2 [s] 1 [b] 1 [a] 1 [c] 1 [d] 1 [b] 0 [a] 0 [c] 0 [f] 0 [d] 0 12

14 S = {s} Visit ([s] 4 ) D(e) = 1 ix([s] 4 ) = 0 D(b) = 3 Kind [s] 3 : min D([s] 3 ) 3 = 0 = ix([s] 4 ) Visit ([s] 3 ) ix([s] 3 ) = 0 Kind[s] 2 : min D([s] 2 ) 2 = 0 = ix([s] 3 ) Visit ([s] 2 ) ix([s] 2 ) = 0 Kind [b] 1 : min D([b] 1 ) 1 = 1 ix([s] 2 ) Kind [s] 1 : min D([s] 1 ) 1 = 0 = ix([s] 2 ) Visit ([s] 1 ) ix([s] 1 ) = 1 Kind [s] 0 : min D([s] 0 ) 0 = ix([s] 1 ) Kind [e] 0 : min D([e] 0 ) 0 = 1 = ix([s] 1 ) Visit ([e] 0 ) S = {s, e} ix([s] 1 ) = 2 D(b) = 3 ix([s] 2 ) = 1 D(f) = 16 Kind [s] 2 : min D([s] 2 ) 2 = 0 = ix([s] 3 ) Visit([s] 2 ) Kind [b] 1 : min D([b] 1 ) 1 = 2 = ix([s] 2 ) Visit([b] 1 ) ix([b] 1 ) = 2 Kind [b] 0 : min D([b] 0 ) 0 = 2 = ix([b] 1 ) Visit ([b] 0 ) S = {s, e, b} ix([b] 1 ) = 3 D(a) = 8 ix([s] 2 ) = 2 D(c) = 15 Kind [a] 2 : min D([a] 2 ) 2 = 1 ix([s] 3 ) ix([s] 3 ) = 1 Kind [c] 3 : min D([c] 3 ) 3 = 1 = ix([s] 3 ) Visit ([c] 3 ). 13

15 5 Ausblick auf die Entwicklung des Linearzeitalgorithmus Um eine lineare Laufzeit zu erhalten ist es nun nötig, die Komponentenhierarchie zu verfeinern. Dies geschieht, indem man einen so genannten Komponentenbaum konstruiert. Dieser entspricht im Wesentlichen der schon vorgestellten Baumdarstellung der Komponentenhierarchie, allerdings fehlen die Knoten [v] i mit [v] i = [v] i+1. Es gibt im Komponentenbaum also keine Knoten mit nur einem Nachfolger, daher ist die Anzahl der Knoten 2n 1. Wenn man von einem solchen Komponentenbaum ausgeht, lässt sich der Algorithmus C so verbessern, dass seine Laufzeit in O(m) ist. Dazu ist es wiederum nötig, den Komponentenbaum in Linearzeit konstruieren zu können. Dies erfolgt über die Konstruktion eines Minimum Spanning Tree (MST), was aber auch in Linearzeit möglich ist (Fredman und Willard 1994). 14

16 6 Ergebnis Satz 1 Für das SSSP-Problem in ungerichteten Graphen mit ganzzahligen positiven Kantengewichten gibt es einen deterministischen Algorithmus mit Laufzeit O(m). Einwände Gegen dieses Ergebnis können zwei Einwände vorgebracht werden. Der Linearzeitalgorithmus verwendet atomic heaps bei der Konstruktion des MST. Zum einen sind atomic heaps nur für definiert und zum anderen benötigt man für atomic heaps Multiplikation, was aber keine AC 0 -Operation ist. Folgerung Dies bedeutet, für die Praxis muss man Lösungen finden, die ohne die Verwendung von atomic heaps auskommen. Dies ist möglich, indem man auf andere Verfahren zur Konstruktion eines MST zurückgreift. Satz 2 Auf einer RAM mit Standard AC 0 -Operationen gibt es einen deterministischen Algorithmus für das SSSP-Problem für ungerichtete Graphen mit ganzzahligen positiven Kantengewichten mit Laufzeit O(α(m, n)m). Endergebnis: Es gibt einen Linearzeitalgorithmus für das SSSP-Problem in ungerichteten Graphen mit ganzzahligen positiven Kantengewichten, aber diese optimale Lösung ist nicht für Implementationen geeigenet. Es gibt jedoch implementierbare Varianten für die praktische Anwendung. Literatur: Mikkel Thorup(1999): Undirected Single-Source Shortest Paths with Positive Integer Weights in Linear Time. Journal of the ACM 46,3. Seite