Fully dynamic algorithms for the single source shortest path problem.

Transkript

1 Fully dynamic algorithms for the single source shortest path problem. Michael Baur Wintersemester 2001/2002 Zusammenfassung Im folgenden Paper werde ich Algorithmen für das dynamische Kürzeste-Wege-Problem mit ausgezeichentem Startknoten (single source shortest path, SSSP) vorstellen, die von Daniele Frigioni, Alberto Marchetti-Spaccamela und Umberto Nanni in [1] veröffentlicht wurden. Die Algorithmen ermöglichen das Ändern von Kantengewichte sowie das Einfügen und Löschen von Kanten und benötigen linearen Speicherplatz. Die Laufzeit wird in Abhängigkeit von der Anzahl der Ausgabeänderungen angegeben und liegt für Graphen mit einer k-beschränkten Besitzfunktion in O(k log n) pro Ausgabeänderung im worst-case, falls nur Änderungen der Kantengewichte zulässig sind Die gleiche amortisierte Laufzeit wird erreicht, falls auch des Löschen und Hinzufügen von Kanten erlaubt ist. Für viele Klassen von Graphen, z.b. mit beschränktem Grad oder beschränkter Pagenumber, bedeutet dies eine Laufzeit in O(log n). 1 Einleitung Das Finden kürzester Wege in einem gewichteten Graphen ist ein grundlegendes und häufig untersuchtes Problem der Informatik. Es taucht in vielen praktischen Anwendungen auf und ist eng verknüpft mit einer Reihe weiterer interessanter Probleme ([2] beschreibt viele theoretische und praktische Anwendungen des Kürzeste-Wege-Problems). Die Laufzeit des besten bekannten Algorithmus zur Lösung dieses Problems auf gerichtete Graphen mit n Knoten und m Kanten ist in O(m + n log n) (Dijkstras Algorithmus mit Fibonacci-Heaps als Knotenspeicher [3], [4]). Auf ungerichteten Graphen ist die von Thorup [5] vorgeschlagene Version mit einer Laufzeit in O(m) die schnellste. In diesem Paper betrachten wir die (vollständig) dynamische Version des Kürzesten-Wege-Problems mit einem ausgezeichneten Startknoten (single source shortest paths, SSSP). Das Problem besteht darin, die Informationen über die kürzesten Wege wieder herzustellen, nachdem sich der Graph geändert hat. Die Informationen sollen dabei nicht komplett neu erstellt werden, sondern möglichst von der älteren Version übernommen werden. Die häufigsten Änderungen an einem Graphen, die in diesem Zusammenhang vorgenommen werden, sind Erhöhen und Verringern der Kantengewichte, Hinzufügen und Entfernen von Kanten und Einfügen und Löschen von isolierten Knoten. Wenn eine beliebige Folge dieser Operationen auf einem Graphen erlaubt sein soll, bezeichnet man das Problem als (vollständig) dynamisch. Die dynamische Version des SSSP Problems spielt in vielen realen Anwendungen eine Rolle, etwa bei der Verwaltung sich ändernder Kommunikationsnetzwerke wie dem Internet. Das Entfernen einer Kante kann in diesem Beispiel den Ausfall einer Netzwerkverbindung repräsentieren, während das Verringern eines Kantengewichts die Erhöhung der Bandbreite einer existierenden Verbindung bedeuten könnte. 1.1 Frühere Ergebnisse In der Literatur sind bereits einige Arbeiten über das dynamische SSSP Problem vorhanden. Die bisher bekannten Algorithmen sind allerdings entweder nur theoretische Lösungen, da sie zu komplex für reale 1

2 Anwendungen sind, funktionieren nur für bestimmte Klassen von Graphen oder erlauben nur einen Teil der Änderungsoptionen, z.b. nur das Verändern von Kantengewichten. Bisher ist keine Löung für die vollständig dynamische Version des Problems auf beliebigen Graphen bekannt, die asymptotisch besser ist, als alle Information komplet neu zu berechnen. 1.2 Resultate Die in diesem Paper vorgestellten Algorithmen verwalten den zu einem Graphen G mit n Knoten und m Kanten gehörenden Kürzesten-Wege-Baum bezüglich eines Startknotens s, wobei eine beliebige Folge der oben beschriebenen Änderungsoperationen erlaubt ist. Anfragen werden in optimaler Zeit beantwortet, d.h. die Distanz eines Knotens von s wird in konstanter Zeit geliefert, der zugehörende kürzeste Weg in O(l), wobei l die Länge dieses Weges ist. Die Laufzeit der Änderungsoperationen wird in Abhängigkeit der Anzahl der Ausgabeänderungengemessen, unter Benutzung einer k-beschränkten Besitzfunktion für die Kanten von G (eine genaue Definition dieser Begriffe folgt im nächsten Kapitel). Sind nur Änderungen der Kantengewichte zugelassen, liegt die worst-case Laufzeit des Algorithmus in O(k log n). Bei beliebigen Folgen von Änderungen beträgt die amortiesierte Laufzeit O(k log n), wenn für jeden der durch die Änderungen entstehende Graphen eine k-beschränkte Besitzfunktion existiert. Für viele Klassen von Graphen bedeutet dies eine Laufzeit in O(log n), da für sie k konstant ist (siehe Kapitel 2.4). Die Algorithmen sind nicht nur Laufzeiteffizient, sondern auch einfach und effizient zu implementieren, da sie als Datenstrukturen nur Listen und Priority Queues benötigen. 1.3 Inhalt Im zweiten Kapitel werden die Grundlagen für die Algorithmen besprochen, d.h. Notation, Laufzeitmessung und Besitzfunktion. In Kapitel drei werden die Algorithmen für das Verändern der Kantengewichte ausführlich besprochen, da sie danach im vierten Kapitel für den vollstandig dynamischen Fall erweitert werden. 2 Grundlagen 2.1 Notation Im folgenden werden die in der Graphentheorie üblichen Bezeichnungen benutzt. Sei G = (V, E) ein gewichteter ungerichteter Graph mit n := V Knoten und m := E Kanten und der Kantengewichtsfunktion w : E R >0, d.h. G hat positive Kantengewichte. Da wir das SSSP betrachten, benötigen wir außerdem einen Startknoten s und einen Kürzesten-Wege- Baum (KWB) T (s) = (V s, E s ) von diesem Startknoten aus. Für v V sei d(v) die Distanz zu s in T und V or(v) der Vorgänger in T. Auserdem bezeichne T (v) = (V v, E v ) den Teilbaum von T mit Wurzel v. 2.2 Dynamische Graphen Wir betrachten die vollständig dynamische Version des SSSP Problems, d.h. wir wollen den Kürzesten- Wege-Baum von s und damit auch die Distanzen von s zu allen anderen Knoten berechen, auch wenn sich die Struktur von G ändert. Konkret bedeutet dies, dass die folgenden Operationen auf dem Graphen erlaubt sind: 2

3 distance(v): liefert die aktuelle Distanz von s nach v, min-path(v): liefert einen kürzesten Weg zwischen s und v, insert(v, w, ɛ): fügt eine neue Kante {v, w} mit Gewicht ɛ in G ein, delete(v, w): löscht die Kante {v, w}, increase(v, w, ɛ): erhöht das Gewicht der Kante {v, w} um ɛ, decrease(v, w, ɛ): verringert das Gewicht der Kante {v, w} um ɛ. Nach jeder Änderung an einer Kante muss ein neuer Kürzesten-Wege-Baum berechnet werden. Dabei soll nicht der komplette Baum von Grund auf neu erstellt werden, sondern nur die Teile, in denen sich etwas geändert hat. Das bedeutet für unser Problem, dass möglichst nur Knoten, die entweder ihre Entfernung von v oder ihren Vorgänger in T (s) geändert haben, bearbeitet werden. Aus diesem Grund werden wir zuerst eine von der üblichen asymptotischen Laufzeitangabe, die in Abhängigkeit von der Größe der Eingabe erfolgt, abweichende Methode einführen. 2.3 Laufzeit in Abhängigkeit von der Ausgabekomplexität Wir werden die Laufzeit der weiter unten vorgestellten Algorithmen in Abhängigkeit von der Anzahl der nach einer Operation nötigen Änderungen an der Ausgabe angeben. Im Fall des dynamischen SSSP Problems bedeutet dies, die Laufzeit pro Knoten, der entweder seinen Vorgänger im Kürzeste-Wege-Baum oder seine Distanz zu s ändert, anzugeben. Diese Laufzeit wird in der bekannten asymptotischen Notation angegeben. Es ist sinnvoll, die Laufzeit eines dynamischen Algorithmus auf diese Art zu messen, da eine Operation mit der gleichen Anzahl von Eingabeparametern zu völlig verschiedenen Laufzeiten führen kann. Das Verringern eines Kantengewichts zum Beispiel kann konstante Laufzeit benötigen, wenn die Kante eine Nichtbaumkante war und bleibt, aber genauso zu einer Änderung weiter Teile des Kürzeste-Wege-Baum führen, wenn sie eine Baumkante mit großem Unterbaum war. 2.4 Besitzfunktion (Accounting function) Für die Laufzeitbetrachtung werden wir für die Graphen eine durch k beschränkte Besitzfunktion benötigen. Definition 2.1 Sei G = (V, E) ein Graph. Eine Besitzfunktion B : E V für G ordnet jeder Kante (v, w) E einen ihrer Endknoten zu, den Besitzer von (v, w). Die Menge B 1 (v) = {(v, w) E B(v, w) = v} heisst Besitz(v), {(v, w) E B(v, w) v} heisst Nichtbesitz(v). G hat eine durch k beschränkte Besitzfunktion, wenn für alle v V die Kardinalität von Besitz(v) höchstens k ist. Beispiele für k-beschränkte Besitzfunktion für bestimmte Klassen von Graphen sind: k = O( m) für allgemeine Graphen k 3 für planare Graphen k g für Graphen mit maximalem Grad g k a für Graphen mit arboricity a Das minimale k, so dass G eine k-beschränkte Besitzfunktion hat, kann in polynomialer Zeit berechnet werden. 3

4 3 Algorithmen zur Änderung der Kantengewichte In diesem Kapitel werde ich Algorithmen für den Fall vorstellen, dass nur das Ändern der Kantengewichte als Operation zugelassen ist. Diese werden im nächsten Kapitel für das Hinzufügen und Entfernen von Kanten modifiziert. Sei also o.e. G in diesem Kapitel ein zusammenhängender Graph. Um die Arbeitsweise der Algorithmen genauer betrachten zu können, werde ich weiter unten die folgenden Bezeichnungen verwenden: zu einem Knoten v V ist d (v) die Distanz von s nach v nach Durchführung einer Operation und D(v) die Distanz, die der zugehörige Algorithmus berechnet hat. Die Algorithmen orientieren sich am Algorithmus von Dijkstra. Die Knoten werden in einer Priority Queue gespeichert, um sie in nicht-absteigender Reihenfolge ihrer Distanzen zu s zu bearbeiten. Wie bei Dijkstra wir ein Knoten höchsten einmal in diesen Knotenspeicher eingefügt, und erst dann aus ihm entfernt, wenn er seine endgültige Distanz zugewiesen bekommen hat. Da wir nur die Teile des Kürzeste-Wege-Baum betrachten wollen, in denen sich nach einer Operation etwas geändert hat, werden im Gegensatz zu Dijkstra beim Entfernen eines Knotens aus dem Knotenspeicher nicht alle seine Nachbarn betrachtet, sondern nur eine Teilmenge davon. Um einen Indikator für zu betrachtende Nachbarknoten zu erhalten, treffen wir folgende Definitionen: 3.1 Backward level und Forward level Definition 3.1 Sei G = (V, E) ein gewichteter Graph. Der Backward level bzw. der Forward level einer Kante (v, w) und des Knotens w relativ zum Knoten v ist B v (w) = d(w) ω(v, w) bzw. F v (w) = d(w) + ω(v, w). Die Idee hinter diesen Definitionen ist, dass die Level einer Kante (v, w) Informationen über den kürzest möglichen Pfad von s nach w, der über v führt, liefern. Betrachten wir das Verringern eines Kantengewichts genauer. Nehmen wir an, der Knoten v hat nach einer solchen Operation seine Distanz verringert und es existiert eine Kante (v, w) mit d (v) < B v (w). Also gilt d (v) < d(w) ω(v, w) und damit d (v) + ω(v, w) < d(w), was bedeutet, dass es einen kürzeren Pfad von s nach w über v gibt, als den ursprünglichen kürzesten Pfad. Wenn wir die Kanten (v, w i ) in nicht-aufsteigender Folge ihrer Backward level betrachten, stellen wir sicher, dass nur solche Kanten bearbeitet werden, bei denen auch w i die Distanz verringert. Eine ähnliche Funktion übernimmt der Forward level bei der Erhöhung eines Kantengewichts. Nehmen wir an, dass eine solche Operation auf eine Kante des kürzesten Pfades von s nach v angewandt wurde und sei l die Länge, die dieser Pfad nun besitzt. Wenn eine Kante (v, w) mit l > F v (w) existiert, so gilt l > d(w) + ω(v, w) und damit existiert ein kürzerer Pfad von s nach v, der über w führt. Betrachten wir die Kanten (v, w i ) in nicht-absteigender Folge ihrer Forward level, stellen wir sicher, dass nur Kanten bearbeitet werden, die auch zu einem kürzeren Pfad für die w i führen. 3.2 Datenstrukturen und k-beschränkte Besitzfunktion Wenn ein Knoten bearbeitet wird, kann es passieren, dass alle seine adjazenten Kanten betrachtet werden. Im worst-case ist ihre Anzahl n mal größer als die Anzahl der Ausgabeänderungen. Betrachten wir nun eine durch k beschränkte Besitzfunktion für G wie in 2.4 beschrieben. Für alle v V speichern wir nun die adjazenten Kanten, die sich in N ichtbesitz(v) befinden, folgendermaßen: B v ist eine absteigend sortierende Priority Queue, in der die Kanten (v, w i ) (die sich im Besitz von w i befinden) mit der Priorität des Backward level B v (w i ) gespeichert werden, und F v ist eine aufsteigend sortierende Priority Queue, in der die Kanten (v, w i ) (die sich im Besitz von w i befinden) mit der Priorität des Forward level F v (w i ) gespeichert werden. 4

5 Wenn wir im Laufe des Algorithmus einen Knoten v aus dem Knotenspeicher entfernen und seine Nachbarknoten w i in der Reihenfolge ihrer Position in B v bzw. F v betrachten, können wir diesen Vorgang abbrechen, sobald zum ersten Mal für einen Knoten w i keine Verbesserung eintritt. Um einzusehen, warum dann insgesamt nur die behauptete Laufzeit erreicht wird, sehen wir uns die Algorithmen für das Verringern und Erhöhen eines Kantengewichts getrennt an. 3.3 Verringern eines Kantengewichts (Decrease) Nehmen wir an, v und w seien zwei Knoten des Graphen (o.e. d(v) d(w)) und das Gewicht der Kante (v, w) wurde um ɛ 0 verringert. Wenn w seine Distanz nicht verringert, kann dies auch kein anderer Knoten tun, der Kürzeste-Wege-Baum ändert sich nicht und der Algorithmus endet. Falls w seine Distanz verkleinert (d (w) < d(w)), verringern auch alle Knoten im Unterbaum T (w) von w ihre Distanz zu s (und zwar um den gleichen Betrag wie w). Außerdem können zum Unterbaum T (w) Knoten hinzukommen, die nicht in T (w) enthalten waren, deren kürzester Pfad nach s nun aber die Kante (v, w) enthält. Die Anzahl der Ausgabeänderungen ist in diesem Fall die Anzahl der Knoten in T (w). Betrachten wir nun einen Knoten z, der seine Distanz zu s verringert hat. Ein Nachbarknoten x i von z soll genau dann betrachtet werden, wenn eine der folgenden zwei Bedingungen zutrifft: die Kante (z, x i ) gehört dem Knoten z; die Kante (z, x i ) gehört dem Knoten x i und es gilt B z (x i ) > d (z) ( d(x i ) > d (z) + ω(z, x i ) ). Durch die Sortierung der Priority Queue stellen wir sicher, dass nur solche Nachbarn von z betrachtet werden, die tatsächlich ihre Distanz verkleinern. Außerdem werden alle Knoten im Unterbaum T (w) bearbeitet, da eine der beiden Bedingungen für jede Kante des Unterbaums erfüllt ist. Betrachten wir nun den Pseudocode des Algorithmus Weight-Decrease (siehe Abb. 1). Im ersten Schritt wird zuerst überprüft, ob die Gewichtsänderung zulässig ist. Die Funktion U pdatelocal(v, w) überprüft, welchem der Endknoten die Kante (v, w) gehört und aktualisiert ihre Einträge in den Priority Queues B v und F v oder B w und F w. Falls der Knoten w seine Distanz verringert hat, wird er in den Heap C eingefügt und eine Schleife wie im Algorithmus von Dijkstra gestartet (Schritt 2). Ansonsten endet der Algorithmus. Schritt zwei berechnet einen neuen Kürzeste-Wege-Baum auf ähnliche Art wie der Algorithmus von Dijkstra. Solange der Knotenspeicher C nicht leer ist, wird der Knoten mit minimaler Priorität entnommen (und z genannt) und ein Teil seiner Nachbarknoten betrachtet. Ein Nachbarknoten x wird genau dann betrachtet, wenn eine der beiden oben beschriebenen Bedingungen erfüllt ist. Die Kanten, für die die zweite Bedingung erfüllt ist, werden gefunden, indem solange der Knoten mit maximaler Priorität aus B z entnommen wird, bis die Bedingung zum ersten mal nicht mehr erfüllt ist. Wenn die betrachtete Kante (z, x) dem Knoten x gehört, werden die entsprechenden Einträge in B x und F x aktualisiert. Falls die Entfernung von s nach x über z kleiner ist, als der bisher gefundene - dies ist der Fall, falls D(x) > D(z) + ω(z, x) gilt - werden die kürzeste Wege Informationen von x auf diesen Pfad gesetzt und x wird in den Knotenspeicher C eingefügt oder, falls er schon enthalten ist, seine Priorität auf die neue Distanz aktualisiert Korrektheitsanalyse Die Beweis läuft analog zum Beweis der Korrektheit des Algorithmus von Dijkstra und wird vielen Lesern bekannt erscheinen. Trotzdem werde ich ihn ausführen, da sich die Korrektheit der anderen Algorithmen auf ähnliche Art zeigen lässt. Wir stellen fest, dass vor der Ausführung des Algorithmus die folgenden drei Eigenschaften gelten: 5

6 Abbildung 1: Algorithmus Decrease Datenstrukturen: D: Array mit den Entfernungen der Knoten zu s P : Array mit dem Vorgänger eines Knotens C: Leerer aufsteigend sortierender Heap Funktion Decrease( Knoten v, w, real ɛ ) 1. Schritt: Initialisierung (O.E. D(v) < D(w)) Falls (ɛ ω(v, w)) führe aus EXIT Gewicht wird nicht-positiv Setze w(v, w) = w(v, w) ɛ UpdateLocal(v, w) Falls (D(w) D(v) + ω(v, w)) führe aus EXIT Keine Verbesserung der Distanz Setze D(w) = D(v) + ω(v, w) Setze P (w) = v Füge (w, D(w)) in C ein 2. Schritt: Knotenupdate Solange (C nicht leer) führe aus Setze (z, D(z)) = Minimum(C) Für alle (z, x) mit (z, x) Besitz(z) oder (z, x) Nichtbesitz(z) und D(z) < b z (x) Falls (z, x) Besitz(z) führe aus U pdatelocal(z, x) Falls (D(x) > D(z) + ω(z, x)) führe aus Setze D(x) = D(z) + ω(z, x) Setze P (x) = z HeapImprove(C, (x, D(x))) 6

7 (E1) Für jeden Knoten v V wird die Länge eines kürzesten Weges korrekt berechnet, d.h D(v) = d(v). (E2) T(s) ist ein Kürzester-Wege-Baum in G mit Wurzel s. (E3) Für jeden Knoten v V und jede Kante (v, w) Nichtbesitz(v) gilt: backward-level v (w) = B v (w) und forward-level v (w) = F v (w). Lemma 3.2 Wenn (E1) - (E3) vor der Ausführung des Algorithmus richtig waren, sind sie auch danach erfüllt und der Algorithmus damit offensichtlich korrekt. Betrachten wir zunächst die erste Eigenschaft und nehmen wir an, das Gewicht der Kante (v, w) wird verringert, wobei d(v) < d(w) und d (w) < d(w) gilt. Durch scharfes Ansehen des Algorithmus stellen wir fest, dass für jeden Knoten z V gilt: D(z) kann nur kleiner werden, also D(z) d(z), und D(z) wird nicht kleiner als d (z), also d (z) D(z). Um zu zeigen, dass für alle Knoten die richtige Distanz berechnet wurde, nehmen wir an, es gäbe Knoten mit falschen Werten. Wir betrachten davon den Knoten x mit der kleinesten (richtigen) Distanz zu s und zeigen denn Widerspruch, dass er den richtigen Wert hat, da für seinen Vorgänger im Kürzeste- Wege-Baum die richtige Distanz berechnet wurde. Für jeden Knoten y mit d (y) < d (x) gelte also D(y) = d (y), und somit auch für den Knoten z der Kante (z, x) im kürzesten Weg von x nach s. Daraus folgt: d (z) + ω(z, x) = d (x) < D(x) d(x) (*). 1.Fall: d(z) = d (z), die Distanz von z hat sich durch das Verkleinern des Kantengwechts nicht geändert. Damit folgt aus (*): d (x) = d (z) + ω(z, x) = d(z) + ω(z, x) d(x). Andererseits haben wir festgestellt, dass immer d (x) d(x) gilt, womit wir d (x) = D(x) = d(x) erhalten und die Distanz von x richtig berechnet wurde. 2.Fall: d(z) > d (z). Wenn z aus C entfernt wird, gilt richtigerweise D(z) = d (z). Beim Betrachten der zu z inzidenten Kanten wird auf jeden Fall auch (z, x) bearbeitet, da sie entweder in Besitz(z) ist oder die zweite Bedingung erfüllt ist (z hat seine Distanz verkleinert und der Wert B z (x) ist korrekt). Falls nun D(z) + ω(z, x) < D(x) gilt, wird die Distanz von x richtig auf D(z) + ω(z, x) gesetzt. Sonst gilt D(z) + ω(z, x) = D(x) und die Distanz ist bereits richtig berechnet worden. Die Korrektheit der anderen beiden Eigenschaften wird durch die folgenden einfachen Beobachtungen deutlich. Wenn die Distanz eines Knotens richtig auf einen neuen Wert gesetz wird, wird in der darauf folgenden Zeile auch der Vorgänger dieses Knotens im Kürzeste-Wege-Baum richtig gesetzt. Die Einträge B x (z) und F x (z) eines Knotens z werden richtig aktualisiert, da für z zu diesem Zeitpunkt bereits die korrekte Distanz errechnet wurde Laufzeit und Speicherplatzbedarf Die benutzten Datenstrukturen benötigen O( V + E ) Speichplatz, um Anfragen in optimaler Zeit zu beantworten. Die Distanz eines Knotens wird in konstanter Zeit geliefert, der kürzeste Weg in O(l), wobei l die Weglänge ist. Lemma 3.3 Das Verringern eines Kantengewichts in einem Graphen mit k-beschränkter Besitzfunktion benötigt im worst-case eine Laufzeit in O(k log n) pro Knoten mit geänderten Werten. Sei z ein Knoten, der aus dem Knotenspeicher C entfernt wurde. Da der Knoten davor in C eingefügt wurde, hat sich seine Distanz im Laufe des Algorithmus verringert. Eine zu z adjazente Kante (z, x) wird betrachtet, wenn sie entweder zu z gehört oder zu x gehört und d (z) < B z (x) gilt. 7

8 Im ersten Fall beträgt die Laufzeit für diese Kante O(log n). Da es höchstens k solche Kanten gibt, ergibt sich eine Laufzeit in O(k log n). Die Kanten, die die zweite Bedingung erfüllen, werden durch sukzessives Entfernen von Knoten aus B z ermittelt. Bei der ersten Kante, die die Bedingung nicht mehr erfüllt, brechen wir ab. Die Laufzeit für diese Kante liegt in O(log n). Die anderen Kanten führen zu Knoten x i, die ihre Distanz verringern und gehören zu deren Besitz. Die Laufzeit pro Kante beträgt O(log n) und geht in die Laufzeit von O(k log n) ein, die x i benötigt, wenn er aus C entfernt wird. Die Gesamtlaufzeit ist also in O(k log n). 3.4 Erhöhen eines Kantengewichts (Increase) Betrachten wir nun den Algorithmus zum Erhöhen eines Kantengewichts. Seien v und w zwei Knoten des Graphen (o.e. d(v) d(w)) und das Gewicht der Kante (v, w) wurde um ɛ 0 vergrößert. Es ist schnell zu sehen, dass sich nur die Informationen von Knoten im Unterbaum T (w) ändern können und der neue Unterbaum von w möglicherweise weniger Knoten enthält. Wir unterscheiden drei Fälle, nach denen wir die Knoten einfärben: Ein Knoten, der seine seine Distanz zu s vergrößert, erhält die Farbe rot. Ein Knoten wird blau gefärbt, wenn er seine alte Distanz beibehält und nur einen neuen Vorgänger im Kürzeste-Wege-Baum erhält. Wenn sich weder Vorgänger noch Distanz eines Knotens ändern, erhält er die Farbe weiß. Die Farbe eines Knotens bestimmt also die Farbe seiner Nachfolger im KWG. Ist er rot, sind die direkten Nachfolger rot oder blau. Ist er blau oder weiß, sind die direkten Nachfolger, und sogar alle Knoten im Unterbaum des Knotens, weiß. Die Färbung läßt sich also durch eine Breitensuche im Unterbaum T (w) herstellen, bei der zuerst alle Knoten (außer möglicherweise w) weiß sind, und solange die Nachfolger der roten Knoten eingefärbt werden, bis keine unbearbeiteten roten Knoten mehr existieren. Die Färbung der Knoten ergibt außerdem die Anzahl der Ausgabeänderungen, sie entspricht der Anzahl der roten und blauen Knoten. Für jeden solchen Knoten müssen die Nachbarn überprüft werden, ob sie einen kürzeren Pfad zu s liefern, als den aktuell gefundenen. Dabei sollen aber nicht alle Nachbarknoten betrachtet werden, um die Laufzeit nicht zu groß werden zu lassen. Wir definieren deshalb den besten nicht-roten Nachbarn eines Knotens z als den Knoten q aller nicht-roten Nachbarn q j, für den der Term F z (q j ) d(z) den minimalen Wert annimmt. Betrachten wir nun den Pseudocode des Algorithmus Increase (siehe Abb. 2). In Schritt eins werden zuerst durch die Funktion U pdatelocal(v, w) die Werte der Level der Kante (v, w) in den entsprechenden Datenstrukturen aktualisiert (siehe Algorithmus Decrease). Falls (v, w) keine Baumkante ist, endet der Algorithmus. Sonst wird w in den Heap M eingefügt und eine Schleife wie im Algorithmus von Dijkstra gestartet. Der zweite Schritt färbt die Knoten ein. Solange noch Knoten in M enthalten sind, wird der Knoten z mit minimaler Distanz aus M entfernt. Falls er einen noch nicht rot gefärbten Nachbarn x mit D(x) + ω(z, x) = D(z) hat, erhält er diesen Knoten als Vorgänger, ändert seine Distanz nicht und wird blau gefärbt. Da x eine geringere Distanz als z hat und daher bereits die richtige Farbe hat, ist diese Zuweisung korrekt. Damit ist die Bearbeitung von z abgeschlossen. Falls er keinen solchen Nachbarn hat, wird er rot gefärbt und alle seine direkten Nachfolger müssen rot oder blau gefärbt werden. Deshalb werden sie in M eingefügt. Nun sind nur noch die rot gefärbten Knoten zu bearbeiten. In Anlehnung an den Algorithmus von Dijkstra werden in Schritt 3.b ihre Distanzen in nicht-absteigender Reihenfolge berechnet. Davor wird in Schritt 3.a für jeden roten Knoten eine vorläufige Entfernung berechnet, die der Länge eines kürzesten 8

9 Abbildung 2: Algorithmus Increase Datenstrukturen: D: Array mit den Entfernungen der Knoten zu s P : Array mit dem Vorgänger eines Knotens M, N: Leere aufsteigend sortierende Heaps Funktion Increase( Knoten v, w, real ɛ ) 1. Schritt: Initialisierung (OE D(v) < D(w)) UpdateLocal(v, w) Falls ((v, w) ist keine Baumkante) dann EXIT Keine Änderungen nötig Sonst Füge (w, D(w)) in M ein 2. Schritt: Einfärben Solange (M nicht leer) führe aus Setze (z, D(z)) = Minimum(M) Falls (es existiert nicht-roter Nachbar x von z mit D(x) + ω(x, z) = D(z)) dann Setze P (z) = x und färbe z blau Sonst Färbe z rot Für alle Nachfolger x von z Füge (x, D(x)) in M ein 3.a: Vorbereiten der roten Knoten Für jeden roten Knoten z führe aus Falls (z hat nur rote Nachbarn) dann Setze D(z) = unendlich Setze P (z) = Null Sonst sei x der beste nicht-rote Nachbar von z Setze D(z) = D(x) + ω(x, z) Setze P (z) = x Füge (z, D(z)) in N ein 3.b: Bearbeiten der roten Knoten Solange (N nicht leer) führe aus Setze (z, D(z)) = Minimum(N) Für alle Kanten (z, x) Besitz(z) führe aus Update b x (z) f x (z) Für alle Kanten (z, x) mit x ist rot führe aus Falls (D(z) + ω(z, x) < D(x)) dann Setze D(x) = D(z) + ω(z, x) Setze P (x) = z HeapImprove(Q, (x, D(x))) Färbe alle roten und blauen Knoten wieder weiß 9

10 Weges zu s, der keine roten Knoten enthält, entspricht. Wenn kein solcher Weg existiert, erhält der Knoten die Entfernung unendlich. Mit diesem Wert als Priorität wird der Knoten in den Heap N eingefügt. Nun wird wie üblich jeweils der Knoten z mit minimaler Distanz aus N entfernt. Für alle Kanten (z, x), die sich in seinem Besitz befinden, werden die Einträge B x (z) und F v (z) aktualisiert. Danach wird für alle roten Nachbarn x überprüft, ob sich ihr Entfernungswert verringert, wenn sie z als Vorgänger wählen und gegebenenfalls die Informationen geändert und die Position in N aktualisiert. Schließlich werden alle roten und blauen Knoten wieder weiß gefärbt Korrektheitsanalyse Der Beweis der Korrektheit von Increase kann analog zum Beweis der Korrektheit von Decrease geführt werden. Man betrachtet wieder den Knoten mit kleinster Distanz, für den die Informationen nicht korrekt berechnet wurde und erhält aus der Annahme, dass sein Vorgänger korrekt ist, den Widerspruch, dass er doch den richtigen Distanzwert hat Laufzeit und Speicherplatzbedarf Wieder benötigen die benutzten Datenstrukturen O( V + E ) Speichplatz, um Anfragen in optimaler Zeit zu beantworten. Die Distanz eines Knotens kann in konstanter Zeit geliefert werden, der kürzeste Weg in O(l), wobei l die Weglänge ist. Lemma 3.4 Das Vergrößern eines Kantengewichts in einem Graphen mit k-beschränkter Besitzfunktion benötigt im worst-case eine Laufzeit in O(k log n) pro Knoten mit geänderten Werten. Die Laufzeit in den Schritten zwei und 3.a wird von der Suche nach dem besten nicht-roten Nachbarn dominiert. Wenn der beste nicht-rote Nachbar eines Knotens z gesucht wird, ist z entweder rot oder blau. Höchstens k der untersuchten Kanten gehören z. Da die Kanten in der Reihenfolge ihres Vorkommens in F z betrachtet werden, führen alle bis auf eine der anderen Kanten zu Knoten, die auch rot sind. Für jede Kante beträgt der Aufwand O(log n), was zu einer Laufzeit von O(k log n) pro geändertem Knoten führt. Mit dem gleichen Argument gilt auch für Schritt 3.b eine Laufzeit von O(k log n) pro geändertem Knoten. 4 Algorithmen für Einfüge- und Löschoperationen In diesem Kapitel werden kurz die Änderungen besprochen, die nötig sind, um die Algorithmen zur Änderung der Kantengewichte für das Löschen und Einfügen von Kanten zu erweiteren. Im Fall eines sich vollständig dynamisch ändernden Graphen treten zwei Probleme auf, die im vorherigen Kapitel noch keine Rolle spielten. Zum einen kann der Graph in mehrere Komponenten aufgeteilt werden (und auch wieder zusammen gefügt werden), zum anderen ist nicht garantiert, dass die ursprüngliche k-beschränkte Besitzfunktion auch nach mehreren Änderungsoperationen noch gilt. Im Folgenden werden die gleichen Bezeichnungen benutzt, wie im dritten Kapitel. 4.1 Einfügen einer Kante (Insert) Man kann sich das Einfügen einer Kante (v, w) mit Kantengewicht ɛ vorstellen als das Verringern des Kantengewichts einer schon existierenden Kante (v, w) von einem sehr hohen Wert auf ɛ. Deshalb ist es einsichtig, dass der Algorithmus Decrease größtenteils für das Einfügen übernommen werden kann. Die größten Unterschiede sind: 10

11 Die neu eingefügte Kante wird dem Besitz einer ihrer Endknoten zugeordnet und die Datenstrukturen der Level werden entsprechend aktualisiert. Der Algorithmus endet danach, falls sich keiner der Endknoten verbessert. Eine Knotenfärbung wird eingeführt. Zuerst sind alle Knoten weiß. Ein Knoten wird rot, wenn er seine Distanz zu s ändert, d.h. wenn er in C eingefügt wird. Die Aktualisierung der Datenstrukturen für die Level wird nicht in Schritt zwei erledigt sondern im neu eingefügten Schritt drei (siehe nächster Punkt). Dies beeinträchtigt die Korrektheit nicht, da diese Informationen in diesem Durchlauf des Algorithmus nicht mehr benötigt werden. Ein neuer Schritt drei wird angefügt, der den Besitzer bestimmter Kanten ändert. Dieser ist für die Korrektheit nicht erforderlich, garantiert aber die Einhaltung der gewünschten Laufzeit. Der Pseudocode des neuen Schrittes sieht folgendermaßen aus: Für alle roten Knoten z führe aus Für alle Kanten (z, x) Besitz(z) mit x ist nicht rot führe aus ChangeOwnership(z,x) Für alle Kanten (z, x) Besitz(z) mit x ist rot führe aus UpdateLocal(z,x) Färbe alle Knoten wieder weiß Dabei tauscht die Funktion ChangeOwnership(z, x) den Besitzer der Kante (z, x) und aktualisiert die zugehörigen Werte in den Datenstrukturen der Level. Die Korrektheit des Algorithmus folgt direkt aus der Korrektheit von Decrease und wird nicht ausgeführt. 4.2 Löschen einer Kante (Delete) Das Löschen einer Kante kann durch das Erhöhen des Gewichts dieser Kante auf einen sehr großen Wert simuliert werden. Deshalb kann der Algorithmus Increase mit wenigen Änderungen für diese Aufgabe verwendet werden. Die Werte der gelöschte Kante werden aus den Datenstrukturen der Level entfernt. Danach endet der Algorithmus, falls eine Nichtbaumkante gelöscht wurde. Wenn zu Beginn von Schritt 3.b alle Knoten in N die Priorität unendlich besitzen bedeutet dies, dass diese Knoten von der Komponente des Graphen, die s enthält, getrennt wurde. Alle Knoten in N erhalten die Distanz unendlich, ohne dass noch irgendwelche Kanten untersucht werden. Die Aktualisierung der Datenstrukturen für die Level wird nicht in Schritt 3.b erledigt sondern im neu eingefügten Schritt vier (siehe nächster Punkt). Dies beeinträchtigt die Korrektheit nicht, da diese Informationen in diesem Durchlauf des Algorithmus nicht mehr benötigt werden. Ein neuer Schritt drei wird angefügt, der genau dem neuen Schritt im Algorithmus Insert entspricht. Wieder folgt die Korrektheit direkt aus der Korrektheit von Increase und wird nicht ausgeführt. 11

12 5 Zusammenfassung In diesem Paper wurden Algorithmen für den dynamischen Fall des Kürzesten-Wege-Problems mit festem Startknoten vorgestellt. Diese sind sowohl effizient in Bezug auf die Ausgabekomplexität als auch praktisch implementierbar. Eine interessante noch offene Aufgabe ist die Erweiterung dieser Algorithmen für den Fall, dass eine ganze Folge von Kantenänderungen ohne Ausgabe der Zwischenergebnisse berechnet werden soll. Literatur [1] D. Frigioni, A. Marchetti-Spaccamela u. U. Nanni. Fully Dynamic Algorithms for Maintaining Shortest Paths Trees, Journal of Algorithms 34, pp (2000). [2] R. K. Ahuia, T. L. Magnanti and J. B. Orlin. Network Flows: Theory, Algorithms and Applications, Prentice-Hall, Englewood Cliffs, NJ, [3] E. W. Dijkstra. A note on two problems in connection with graphs, Numer. Math. 1, pp (1959). [4] M. L. Fredman and R. E. Tarjan. Fibonacci heaps and their use in improved network optimization algorithms, J. Assoc. Comput. Mach. 34, pp (1987). [5] M. Thorup. Undirected single source shortest path in linear time, Proceedings IEEE Symposium on Foundations of Computer Science, Miami Beach, Florida, October , pp