Online-Algorithmen für Netzwerke

Seminar Systemorientierte Informatik Sommersemester 2000
Generalthema: Netzwerke und Optimierung
Online-Algorithmen für Netzwerke
Seminarleiter:
Dr. M. Sampels und Prof. B. Müller-Clostermann
Referent:
Thorsten Fischer
[email protected]
ONLINE-ALGORITHMEN FÜR NETZWERKE.............................................................................................1
1
ONLINE-ALGORITHMEN.........................................................................................................................2
1.1
DEFINITION (ONLINE-ALGORITHMUS) ......................................................................................................2
1.2
ANWENDUNGSBEISPIELE ..........................................................................................................................2
2
BEWERTUNG VON ONLINE-ALGORITHMEN....................................................................................2
2.1
PROBLEMSTELLUNGEN FÜR DIE COMPETITIVE ANALYSIS ........................................................................2
2.1.1
Maximierungs- oder Ertragsprobleme ............................................................................................3
2.1.2
Minimierungs- oder Kostenprobleme ..............................................................................................3
2.2
COMPETITIVE ANALYSIS ..........................................................................................................................3
2.3
COMPETITIVE ANALYSIS ZUR NETZWERKOPTIMIERUNG ..........................................................................4
2.3.1
Monotones Wachstum von G und H.................................................................................................5
2.3.2
Nicht monotones Wachstum von G und H .......................................................................................5
3
ANWENDUNGSBEISPIEL: DER ALGORITHMUS SHORTCUT ........................................................5
3.1
PROBLEMSTELLUNG/MOTIVATION ...........................................................................................................5
3.1.1
Das Problem ....................................................................................................................................5
3.1.2
Güteabschätzung .............................................................................................................................6
3.1.3
Lokalität eines Algorithmusses ........................................................................................................6
3.2
BEGRIFFE/DEFINITIONEN ..........................................................................................................................6
3.2.1
Bezeichnungen .................................................................................................................................6
3.2.2
Definition 1 (Status von Knoten) .....................................................................................................7
3.2.3
Definition 2 (Status von Kanten) .....................................................................................................7
3.2.4
Definition 3 (d(v,w); Sprungkante) ..................................................................................................7
3.2.5
Definition 4 (blockieren; Abkürzung) ..............................................................................................7
3.3
DER ALGORITHMUS SHORTCUT ...............................................................................................................8
3.4
ANALYSE DES ALGORITHMUSSES SHORTCUT ..........................................................................................8
3.4.1
Theorem 1 (Besuchen aller Knoten) ................................................................................................8
3.4.2
Beobachtung 1 (Blockieren bis Besuch) ..........................................................................................9
3.4.3
Lemma 1 (d(y,w) ≤ (2+δ)|vw|).........................................................................................................9
3.4.4
Theorem 2 (ShortCut ist 16-competitive).........................................................................................9
4
SHORTCUT AN EINEM BEISPIEL ........................................................................................................11
5
LITERATURVERZEICHNIS....................................................................................................................13
1
1 Online-Algorithmen
1.1
Definition (online-Algorithmus)
Eine kurze Definition des Begriffs „Online Algorithmen“ findet sich in „Randomized Algorithms“ von Rajeev
Motwani und Prabhakar Raghavan [MoRa95, 368]. Demnach sind Online-Algorithmen Verfahren, die ihre Eingaben Schrittweise empfangen und ebenso verarbeiten.
In typischen Anwendungen erhält ein Online-Algorithmus Anfragen nach bestimmten Diensten. Dabei muß jede
Anfrage bearbeitet werden, bevor die nächste empfangen werden kann. Bei der Bearbeitung jeder Anfrage wählt
der Algorithmus aus mehreren Möglichkeiten aus, die mit unterschiedlichen Kosten behaftet sind. Die Auswahl
auf einer Stufe kann jedoch die Kosten der nachfolgenden Entscheidungen beeinflussen.
Im Gegensatz dazu kann ein Offline-Algorithmus alle Anfragen empfangen, bevor er seine Antworten berechnet.
M. Halldórson und Mario Szgedy [HaSz94, 164] konkretisieren die Definition dahingehend, daß OnlineAlgorithmen die Antworten unter folgenden Bedingungen ermittlen:
1) Eine Anfrage muß beantwortet werden, bevor die nächste ankommt.
2) Es gibt keine Informationen über die zukünftigen Anfragen, noch nicht einmal über ihre Anzahl oder die
Reihenfolge.
3) Jede einmal ermittelte Antwort ist unwiderruflich.
1.2
Anwendungsbeispiele
Konkrete Anwendungsfälle für Online-Algorithmen sind zum Beispiel folgende
•
Über einen Landstrich sind Schulen mit begrenzen noch freien Schülerkapazitäten verteilt. Das Problem ist,
für jeden neuen Schüler, der in diese Gegend zuzieht, so eine Schule zu finden, daß die Wege für alle Schüler möglichst kurz werden. Dieses Problem stellt eine spezielle Variante des k-Server Problems dar.
[KaPr98]
•
Ein Computer verwaltet zwei Sorten von Speicher: Schnellen aber kleinen Cache und langsameren aber
dafür viel größeren Hauptspeicher. Zugriffe auf Daten, die im Cache liegen verursachen weniger Geschwindigkeitsverlust, als Zugriffe auf den Hauptspeicher. Ein Online-Paging Algorithmus soll nun bestimmen,
welche Daten im Cache gehalten werden, ohne, daß er alle Zugriffe auf die Daten im Vorhinein kennt, aber
so, daß er die Zugriffszeit insgesamt minimiert. [MoRa95, 368]
•
Ein Scheduling-Verfahren soll Last auf einem Mehrprozessor-System so verteilen, daß eine möglichst
gleichmäßige Auslastung entsteht.
•
Theseus sucht Ariadne in einem Labyrinth, oder als moderne Version dieses Problems: Agenten sollen in
einem unbekannten Netzwerk Informationen abrufen.
•
Ein Bankangestellter soll für einen Kunden ein möglichst günstiges Portefeuille erstellen, ohne daß er die
Kursverläufe der in Betracht kommenden Wertpapiere kennt.
•
Umrüstzeiten für Maschinen sollen möglichst gering gehalten werden, ohne daß die zukünftigen Aufträge
vorher bekannt sind.
2 Bewertung von Online-Algorithmen
2.1
Problemstellungen für die Competitive Analysis
1985 veröffentlichten Sleator und Tarjan den Artikel „Armortized Efficiency of List Update and Paging Rules“
[SlTa85], der den Boom der Online-Algorithmen in der theoretischen Informatik auslöste. Zum einen werden
darin Regeln zur Behandlung von unsortierten linearen Listen und zum anderen das Paging-Verfahren „least
recently used“ betrachtet. Die Autoren schlagen dabei ein besonderes Verfahren zur Analyse dieser Algorithmen
vor, die „competitive analysis“.
2
[FiWo98, Kapitel 1] Algorithmen, die mit Hilfe der „competitive analysis“ beurteilt werden, behandeln Probleme, die Varianten von NP-harten1 Entscheidungsproblemen darstellen. Unterschieden wird in solchen Problemen
zwischen den Problemparametern und der Probleminstanz.
Problemparameter:
Das, was dem Algorithmus im Vorhinein bekannt ist
Probleminstanz:
Das, was dem Algorithmus zur Lösung unbekannt ist
In einem allgemeinen Modell für die hier betrachteten Probleme und Algorithmen ist einem Algorithmus A eine
bestimmte Problemkonfiguration vorgegeben. Er empfängt Eingaben und geht nach Verarbeitung zur nächsten
Problemkonfiguration über.
Es werden zwei Arten von Problemen betrachtet:
2.1.1 Maximierungs- oder Ertragsprobleme
Maximierungsprobleme sind durch Ertragsfunktionen gekennzeichnet, die abhängig sind von den Eingaben und
der Folge von Konfigurationen, die von dem Algorithmus bearbeitet werden. Diese Funktionen bezeichnen den
Ertrag, den der Algorithmus aus der Probleminstanz berechnet.
Beispiele für Maximierungsprobleme sind
•
Routen von möglichst vielen Paketen durch Netzwerke
•
Ertragsmaximierung im Währungshandel
•
Durchsatzmaximierung in Computersystemen
2.1.2 Minimierungs- oder Kostenprobleme
Für Minimierungsprobleme gilt entsprechendes von Maximierungsproblemen
Beispiele für Minimierungsprobleme sind
•
Minimierung von Seitenfehlern im Speichermanagement
•
Minimieren der Anzahl der Farben bei Färbungsproblemen von Graphen
•
Minimieren der Anzahl der Pakete in Rucksackproblemen
2.2
Competitive Analysis
[FiWo98, Kapitel 1] Ein Hauptaspekt all dieser Probleme ist, daß die unvollständige Information über die Probleminstanz dazu führen kann, daß die Algorithmen sehr schlechte Ergebnisse liefern. Für viele Algorithmen ist
es sogar möglich, daß die Eingaben so aussehen, daß der Algorithmus immer die schlechtest mögliche Entscheidung trifft. Zum Beispiel könnte für jeden Paging-Algorithmus unabhängig davon, welcher konkret betrachtet
wird, diejenige Seite, die er gerade aus dem Cache entfernt hat, die nächste angeforderte sein. Deshalb scheint
eine klassische worst-case Analyse (in der man ja immer von diesen schlechtest möglichen Fällen ausgeht) zu
unterstellen, daß alle Paging-Algorithmen gleich schlecht sind. Dies widerspricht aber sowohl der Intuition als
auch der Empirie.
Eine mögliche Alternative zur worst-case Analyse, die average-case Analyse könnte darin bestehen, Annahmen
über die Wahrscheinlichkeitsverteilung der ankommenden Aufträge zu treffen. „Im allgemeinen kennt man für
ein bestimmtes Problem kaum Verteilungen, welche die Realität zufriedenstellend widerspiegeln und auch in der
Theorie zufriedenstellend analysierbar sind.“ [KrRa99, 8]
Es wird also eine Analysemethode benötigt, die für jede mögliche Auftragsverteilung gültige Aussagen trifft.
Um das Problem, das bei der worst-case Analyse auftritt zu vermeiden, muß diese gesuchte Methode den Begriff
„worst-case“ anders definieren. Das Problem des herkömmlichen worst-case Verhalten des PagingAlgorithmusses ist, daß es extrem schlecht sein kann. Was aber passiert, wenn gezeigt werden kann, daß wenn
das Verhalten eines Paging-Algorithmusses für eine bestimmte Eingabe(-verteilung) schlecht ist, dieses Verhalten für alle möglichen Paging-Algorithmen ebenso schlecht ist? Dies würde bedeuten, daß sich ein Algorithmus
1
Zur Definition von „NP-hart“ siehe Anhang B von [KrRa99]
3
ruhig so schlecht verhalten darf, wenn er als Entschuldigung dafür angeben kann, daß alle anderen Algorithmen
sich in seiner Situation auch nicht besser benehmen würden. Die competitive analysis betrachtet nun gerade, wie
viel besser ein solch besseres Verhalten sein könnte. Man betrachtet also nicht die absolute Güte eines bestimmten Algorithmusses, sondern das Verhältnis der Güte seiner Lösung zur Güte der optimalen Lösung für die gleiche Probleminstanz.
S. O. Krumke und J. Rambau erläutern in dem Zusammenhang den Begriff „online-Spieler“ wie folgt:
„Die kompetitive Analyse von Online-Algorithmen kann man als Spiel zwischen einem Online-Spieler und
einem böswilligen Gegner (Adversary) sehen. Der Online-Spieler arbeitet mit einem Algorithmus auf einer Eingabe, die vom Adversary vorgegeben wird. Der Adversary konstruiert, basierend auf seinem Wissen über den
Online-Algorithmus, eine Eingabe, die den Quotienten aus den Online- und den Offline-Kosten maximiert.
Manchmal bezeichnet man den Adversary zusammen mit den optimalen Offline-Algorithmus auch als OfflineSpieler.“ [KrRa99]
Der Ausdruck costA(I) bezeichnet die Kosten, die ein Algorithmus A für eine gegebene Probleminstanz I errechnet. Die competitive ratio oder der competitive factor2 eines Algorithmusses A für ein Kostenproblem P sei dann
inf { c | costA(I) ≤ c · costB(I), ∀I ∈ P, ∀B }3
Dementsprechend bezeichnet der Ausdruck benefitA(I) den Ertrag, den ein Algorithmus A für eine gegebene
Probleminstanz I erzeugt. Die competitive ratio eines Algorithmusses A für ein Ertragsproblem P sei dann
sup { c | c · benefitA(I) >= benefitB(I), ∀I ∈ P, ∀B }
Im Allgemeinen wird die competitive analysis für Probleme angewandt, in denen Entscheidungen unter unvollständiger Information getroffen werden müssen. Dies könnte daran liegen, daß
•
Ereignisse noch nicht eingetroffen sind,
•
Algorithmen fehlende Informationen erst noch berechnen müssen, oder daß
•
in verteilten Umgebungen gerechnet wird.
Online-Probleme stellen also lediglich eine Klasse von Problemen dar, deren Analyse mit Hilfe dieser Methodik
durchgeführt wird. A. Fiat und G. J. Woeginger weisen darauf hin [FiWo98, Kapitel 1], daß die competitive
analysis meistens für online-Algorithmen gebraucht wird, und daß daher manchmal fälschlicherweise diese
Analysetechnik mit der Klasse der online-Probleme verwechselt wird.
2.3
Competitive Analysis zur Netzwerkoptimierung
Im folgenden soll eine Anwendung der competitive analysis für online Netzwerkoptimierungsprobleme gegeben
werden. Sie ist gleichnamigem Artikel von B. Kalyanasundaram und K. Pruhs entnommen [KaPr98].
Probleme, die sich in Netzwerken ergeben, zielen häufig darauf ab, einen irgendwie kostenminimal gearteten
Teilgraphen H in einem sich dynamisch ändernden Netzwerk G zu bestimmen. Diese Probleme sind von Natur
aus „online“, denn sie lösende Algorithmen haben keine Kenntnis über die zukünftigen Änderungen von G. Im
Allgemeinen werden Probleme solcher Art wie folgt formalisiert:
N bezeichne ein festes Netzwerk, das nicht notwendigerweise im vorhinein bekannt ist. G0 ist ein initialer Teilgraph von N. Gi+1 wird durch Hinzufügen oder Weglassen von Knoten in Gi gebildet. Das Ziel des onlineAlgorithmusses ist es dann, den Teilgraphen Hi von Gi auf minimale Art zu ändern, um Hi+1 und Gi+1 zu erhalten.
2
Auch wenn in einigen deutschsprachigen Artikeln dieser Begriff mit „Kompetitivitätsfaktor“ übersetzt ist, wird
hier im weiteren der englischsprachige Begriff als Terminus benutzt, um dieses Wortungetüm zu vermeiden.
3
Infimum/Supremum
i)
Es sei A ⊆ ℜ
A ist nach oben (unten) beschränkt ⇔ ∀ x ∈ A: ∃ s ∈ ℜ mit x ≤ s (s ≤ x)
ii)
A ist nach oben beschränkt, dann ist das Supremum von A (sup A) die kleinste obere Schranke s, d. h. das
kleinste s ∈ ℜ, welches die Bedingung aus i) erfüllt. (Definition von Infimum entsprechend)
4
2.3.1 Monotones Wachstum von G und H
G und H sind monoton wachsend, wenn jeder Knoten in Gi ein Knoten in Gi+1 ist und Hi ⊆ Hi+1. Die competitive
ratio c eines Algorithmusses A ist dann das Maximum der Verhältnisse berechnet aus den Kosten des Teilgraphen, der von A konstruiert wird, dividiert durch die Kosten des optimalen Teilgraphen über alle Folgen von
Änderungen I an G.
ìï cost A ( I ) üï
c = max í
ý
ïî costopt . (I )
2.3.2 Nicht monotones Wachstum von G und H
Falls Knoten aus Gi herausfallen, oder Kanten aus Hi gelöscht werden können, gibt es zwei Parameter, die von
einem Algorithmus optimiert werden können. Das ist zum einen die Güte von Hi, zum anderen die Kosten zur
Restrukturierung von Hi. Beide dieser Kostenarten sind im monotonen Fall zugleich abgedeckt. Soll competitive
analysis angewandt werden, ist es notwendig, einen dieser Parameter zur Betrachtung konstant zu halten.
2.3.2.1 Fixed Quality Model
In diesem Modell wird ein Qualitätsparameter β als konstant vorgegeben. Die Funktion α(Hi, Hi+1) bezeichnet
die Kosten, die beim Ändern von Hi zu Hi+1 anfallen. Für ungewichtete N bezeichnet α die Anzahl der Kanten,
die hinzukommen oder wegfallen, für gewichtete N, die Summe der Kantengewichte dieser Kanten. Ziel ist, die
Kosten bei der Bearbeitung der Sequenz von I Änderungen zu minimieren, während der Teilgraph Hi höchstens
β-fache Kosten der optimalen Lösung von Gi verursacht.
In diesem Fall ergibt sich die competitive ratio als die Kosten, die der online-Algorithmus verursacht, um die
Anforderungen I zu bearbeiten, dividiert durch die Kosten um den Teilgraphen innerhalb der vorgegebenen
Güteforderung (höchstens β-fache Kosten zum Optimum) zu halten. Ein Beispiel, in dem es darauf ankommt die
Güte von H in dieser Weise zu berücksichtigen, ist die Anbindung neuer Haushalte in ein Stromnetz, das jährliche Betriebskosten verursacht.
2.3.2.2 Fixed Cost Model
In diesem Modell werden konstante Kosten α vorgegeben, die man bereit ist, für jede Änderung von G auszugeben. Wenn N ungewichtet ist, könnten diese Kosten zum Beispiel die Anzahl der Kanten sein, die von Hi nach
Hi+1 hinzukommen bzw. wegfallen. Das Problem besteht nun darin, die Kosten des endgültigen Teilgraphen H
unter der Bedingung zu minimieren, daß höchstens α⋅k Kosten für die Änderung ausgegeben werden dürfen. (k
bezeichnet die Anzahl der Änderungen, die an G vorgenommen werden.)
3 Anwendungsbeispiel: Der Algorithmus ShortCut
Im folgenden soll ein Anwendungsbeispiel für einen speziellen online-Algorithmus „ShortCut“ gegeben werden.
Dieser Algorithmus von K. Pruhs und B. Kalyanasundaram wird in dem Artikel „Constructing Competitive
Tours From Local Information“ dieser Autoren vorgestellt. [KaPr94]
3.1
Problemstellung/Motivation
3.1.1 Das Problem
Der Handlungsreisende Tobias Schlunz (TS) soll in einer Gegend, die ihm völlig unbekannt ist, alle Orte besuchen. Bei den heutigen Benzinpreisen will er natürlich seine Reise mit der kürztest möglichen Strecke erledigen.
Leider kann er von dieser Gegend keine Straßenkarte besorgen, so daß er die einzigen Informationen über die
Umgebung von den Straßenschildern ablesen muß. In jedem Ort, den er besucht, kann er also die Namen aller
angrenzenden Orte und deren Entfernungen in Erfahrung bringen. Indem Herr Schlunz also seinen Weg geht,
gewinnt er Informationen, die ihn vielleicht kürzere Routen festlegen lassen könnten, und die ihn die Reihenfolge seiner geplanten Besuche ändern lassen.
Dieses Problem des Handlungsreisenden wird das „online traveling salesman problem“ (online TSP) genannt.
Man kann es auch graphentheoretisch formulieren:
5
Angenommen die Straßen bilden einen kantengewichteten, zusammenhängenden, planaren4 Graphen G=(V, E).
Folgendes „fixed graph scenario“ beschreibt, wie der Handlungsreisende den Graphen entdeckt: Wenn der TS
einen Knoten v besucht, weiß er welche Knoten alle zu v adjazent sind. Für jeden dieser Knoten w findet er
außerdem die Länge |vw| der Kante vw heraus. Dabei muß |vw| nicht unbedingt der euklidische Abstand zwischen v und w in der Ebene sein. Die Entfernungen müssen also nicht notwendigerweise die Dreiecksungleichung5 erfüllen. Es wird lediglich gefordert, daß die Kantenlängen nicht negativ sind. Weiterhin weiß der TS die
Anzahl n der Knoten in G. Das Ziel des TS ist, alle Knoten des Graphen mit dem Pfad kürztest möglicher Gesamtlänge zu besuchen.
3.1.2 Güteabschätzung
Weil dem TS Informationen über den kompletten Graphen fehlen, ist es ihm nicht möglich, die optimale Tour zu
planen. Er wird also versuchen, die Route zu wählen, die am dichtesten an der optimalen Lösung liegt. Als Maß
dafür dient die Länge der Route des TS dividiert durch die Länge einer optimalen (offline konstruierten) Route.
Dieses Verhältnis wird als die „competitiveness“ der Tour bezeichnet. Der Online-Algorithmus, den der TS
benutzen wird, ist α-competitive, wenn das supremum aller möglichen Ausprägungen dieser Verhältniszahl α
ist. α wird dann auch als „competitive factor“ bezeichnet. Ein Algorithmus ist „competitive“, wenn sein competitive factor durch eine Konstante nach oben beschränkt ist.
Pruhs und Kalyanasundaram stellen einen Algorithmus „ShortCut“ vor, der das beschriebene online TSP löst.
Anschaulich betrachtet vollführt er einen Tiefendurchlauf in bestimmten Teilbereichen des Graphen, die er mit
gelegentlichen Sprüngen wechselt. Sein competitive factor ist 16.
Das offline TSP, in dem G im vorhinein bekannt ist, ist NP-hart. Es soll nun kurz erläutert werden, warum die
standard-Heuristiken zur Annäherung dieses Problems nicht auf das online-Problem übertragbar sind.
3.1.3 Lokalität eines Algorithmusses
Ein solcher offline-Algorithmus betrachtet die Knoten des Graphen in einer bestimmten Reihenfolge v1, ..., vn.
Als einen Schritt konstruiert er eine Tour Ti, für die ersten i dieser Knoten. Ein Algorithmus ist genau dann lokal,
wenn für alle solche Touren Ti, Ti+1, ..., Tn gilt, daß vi der Nachfolger von vi-1 ist. Ein entsprechender onlineAlgorithmus für das online-TSP muß demnach lokal sein, da ihm nicht im Vorhinein alle Knoten bekannt sind.
Die competitive offline Algorithmen, wie „nearest insertion“, „cheapest insertion“, der „minimum spanning
tree“-Algorithmus und der „Christofides Algorithmus“ sind nicht lokal. Sie beziehen deshalb nicht alle Kosten
ein, die für den online-TS entstehen. Weiterhin wird zum Beweis, daß diese Algorithmen competitive sind, einbezogen, daß es eine 1:1-Beziehung zwischen der von ihnen erzeugten Tour und einem minimalen Spannbaum
des Graphen gibt.
Es gibt zwar auch lokale offline-Algorithmen, wie zum Beispiel der „nearest neighbour“-Algorithmus und der
„space filling curve“-Algorithmus, aber diese Algorithmen sind nicht competitive.
Weil ShortCut sowohl lokal als auch competitive ist, wird eine andere Technik zum Beweis der competitiveness
nötig, die nicht diese oben erwähnte 1:1-Beziehung benutzt.
3.2
Begriffe/Definitionen
3.2.1 Bezeichnungen
xy
Wenn x und y Knoten eines Graphen darstellen, so wird eine Kante zwischen diesen
Knoten mit xy bezeichnet.
|xy|
Die Länge einer Kante xy (ihr Kantengewicht) wird mit |xy| bezeichnet.
Graph
Graphen werden als Multimengen von Kanten angesehen.
|S|
Wenn S eine Multimenge von Kanten ist, bezeichnet |S| die summierte Länge aller
Kanten in S.
4
Ein Graph heißt planar, wenn sich seine Kanten in einer zweidimensionalen Darstellungsweise nicht schneiden,
ohne an dieser Stelle einen Knoten zu haben.
5
Dreiecksungleichung: |a+b| ≤ |a| + |b|
6
Knoten in S
Ein Knoten v gehört zu einem Graphen S, wenn in S eine Kante mit v enthalten ist.
OPT
OPT bezeichnet den optimalen Pfad zwischen zwei Knoten, der sich offline ergibt.
MST
MST bezeichnet den minimalen Spannbaum eines Graphen G.
3.2.2 Definition 1 (Status von Knoten)
Knoten können drei sich gegenseitig ausschließende Status bekommen:
besucht
Ein Knoten ist besucht, wenn der TS dort war.
angrenzend
Ein Knoten ist angrenzend, wenn er zwar nicht besucht ist, aber benachbart zu einem
besuchten Knoten ist. (Zwei Knoten sind benachbart, wenn es zwischen ihnen eine
Kante gibt).
unbekannt
Ein Knoten ist unbekannt, wenn er weder besucht noch angrenzend ist.
3.2.3 Definition 2 (Status von Kanten)
Kanten können drei sich gegenseitig ausschließende Status bekommen:
besucht
Eine Kante ist besucht, wenn beide Endpunkte (Knoten) besucht sind.
angrenzend
Eine Kante ist angrenzend, wenn ein Endpunkt besucht ist, der andere nicht. Für die
Bezeichnung einer angrenzenden Kante vw gilt, daß v der besuchte Knoten ist und w
der nicht besuchte Knoten.
unbekannt
Eine Kante ist unbekannt, wenn sie weder besucht noch angrenzend ist.
3.2.4 Definition 3 (d(v,w); Sprungkante)
(a) d(v,w)
Zu einem besimmten Zeitpunkt gibt es zwischen zwei besuchten Knoten v und w einen kürzesten Pfad, der nur
über besuchte oder angrenzende Knoten führt. Der Ausdruck
d(v,w)
bezeichnet die Länge dieses Pfades.
(b) Sprungkante
Im Ablauf des Algorithmusses muß der TS manchmal seine Suche an anderer Stelle fortsetzten. Er geht dann auf
ihm bekannten Kanten von einem besuchten Knoten v zum anderen Knoten w. Dieser Weg wird wie eine eigene,
einzige neue Kante vw angesehen und als
Sprungkante
bezeichnet.
3.2.5 Definition 4 (blockieren; Abkürzung)
(a) (blockieren)
Eine angrenzende Kante xy blockiert eine andere angrenzende Kante vw
⇔
|xy| <
|vw| und
d(v,x) + |xy| < (1+δ) |vw|
Ist δ=0 bedeutet dies anschaulich, daß ein TS, der in v steht, einen kürzeren Weg weiß, wie er von dort nach y
kommt, als der Weg, der zwischen ihm und w liegt. In diesem Fall (δ=0) ist auch die erste Bedingung (|xy| <
|vw|) in der zweiten (d(v,x) + |xy| < (1+δ)|vw|) enthalten.
7
Ist jedoch δ>0, so bedeutet die Blockade von vw durch xy lediglich, daß der Weg von v nach y nach oben hin
abgeschätzt werden kann durch (also kleiner ist als) (1+δ)|vw|. Die Konstante δ > 0 wird später in dieser Weise
benutzt, um den competitive factor abzuschätzen.
(b) (Abkürzung)
Eine angrenzende Kante vw ist eine Abkürzung
⇔
Keine andere angrenzende Kante blockiert vw
3.3
Der Algorithmus ShortCut
Der Algorithmus ShortCut verläuft in etwa wie ein gewöhnlicher Tiefendurchlauf durch einen Graphen.
Angenommen, der TS befindet sich an einem Knoten v und überlegt, ob er die angrenzende Kante vw entlang
gehen soll. Wenn vw eine Abkürzung ist, wird er dies sofort tun. (Später wird eine solche Kante vw als „geladen“ bezeichnet.) Wenn vw aber keine Abkürzung ist, wird dieser Gang aufgeschoben, vielleicht sogar aufgehoben.
Angenommen, der TS hat gerade eine angrenzende Kante xy überschritten, dann sind jetzt y und xy besucht. Es
kann sein, daß nun eine andere anProcedure ShortCut(Knoten x,
grenzende Kante vw, deren DurchKnoten y,
gang vorher einmal aufgeschoben
Graph G) {
// Von x kommend besucht der TS y zum ersten Mal
worden war, zu einer Abkürzung
for (alle angrenzenden Kanten vw) {
wird. In diesem Fall wird eine
if (Besuchen von y leert Block(vw)) {
Sprungkante von y nach w hinzugefüge eine Sprungkante yw
fügt. Rein begrifflich betrachtet
zu Inzidenz(y) und Inzidenz(w) hinzu;
}
kann der TS diese Sprungkante ja
}
wie jede andere Kante auch durchfor (alle Kanten yz ∈ Inzidenz(y)) {
laufen. Wenn der Algorithmus irif (z ist ein angrenzender Knoten and
gendwann einmal den TS anweist,
yz ist eine Abkürzung
) {
Gehe über die Kante yz;
diese Sprungkante zu durchlaufen,
ShortCut(y, z, G);
wird er den dann kürzesten bekann} else if (
ten Weg von y nach w benutzen.
z ist ein angrenzender Knoten and
Später
wird
gezeigt,
daß
yz ist eine Sprungkante ) {
Gehe auf dem kürzesten bekannten Weg von y nach z;
d(y,w) ≤ (2+δ)|vw|. In diesem Fall
ShortCut(y, z, G);
wird die Kante vw als „geladen“
}
bezeichnet, und die Kosten um von
}
y nach w zu kommen fallen an.
Gehe auf dem kürzesten bekannten Weg nach x zurück;
}
Der Algorithmus führt für jeden
Knoten v eine Liste „Inzidenz(v)“
Abbildung 1 - ShortCut in Pseudocode
mit den Kanten, die an v angrenzen.
Eine weitere Liste „Block(e)“ wird für jede angrenzende Kante e geführt, die alle angrenzenden Kanten enthält,
welche die Kante e blockieren.
3.4
Analyse des Algorithmusses ShortCut
3.4.1 Theorem 1 (Besuchen aller Knoten)
Der TS besucht alle Knoten.
3.4.1.1 Beweis (Theorem 1)
Um einen Widerspruch zu erzeugen wird angenommen, daß bei Ende des Algorithmus noch Knoten unbesucht
sind. Es sei dann xy die angrenzende Kante, die Länge der Strecke von x nach y minimiert. Deshalb wäre beim
Besuch eines Knoten z (welcher nicht notwendigerweise der Knoten x sein muß), die Kante xy eine Abkürzung.
Daher wäre y entweder direkt von x besucht worden, oder von der Sprungkante von z aus.
8
3.4.2 Beobachtung 1 (Blockieren bis Besuch)
Wenn zu einem Zeitpunkt eine angrenzende Kante xy eine andere angrenzende Kante vw blockiert, so tut sie das
so lange, bis entweder y oder w besucht sind.
3.4.2.1 Begründung (Beobachtung 1)
Diese Beobachtung folgt daraus, daß sowohl xy und vw angrenzende Kanten bleiben, bis entweder y oder w
besucht sind.
3.4.3 Lemma 1 (d(y,w) ≤ (2+δ
δ)|vw|)
Angenommen nach dem Durchlaufen einer angrenzenden Kante xy wurde eine andere angrenzende Kante vw
zur Abkürzung und eine Sprungkante wurde von y nach w konstruiert. Dann gilt:
d(y,w) ≤ (2+δ)|vw|
3.4.3.1 Beweis (Lemma 1)
Nach dem Besuch von y blockiert keine andere Kante vw mehr. Nach Beobachtung 1 mußte es vor dem Besuch
von y eine andere an y angrenzende Kante gegeben haben, die vw blockierte. Durch Definition 4 gilt:
d(y,v) < (1+δ)|vw|
Also gilt dann:
d(y,w) < (2+δ)|vw|
3.4.4 Theorem 2 (ShortCut ist 16-competitive)
Der Algorithmus ShortCut ist 16-competitive.
3.4.4.1 Beweis (Theorem 2)
Eine Kante xy wird als geladene Kante bezeichnet, wenn sie die Abkürzung ist, die es ermöglicht y zum ersten
Mal zu besuchen. (Trotzdem muß nicht notwendigerweise xy bei diesem Besuch auch durchlaufen werden.) Es
sei nun P die Menge der geladenen Kanten. Die gesamte Länge der Tour ist höchstens 2(2+δ)|P|, wobei der
Faktor (2+δ) aus Lemma 1 folgt und sich der Faktor 2 aus der Tatsache ergibt, daß ein Tiefendurchlauf durch
einen Graphen jede Kante genau ein Mal in jeder Richtung durchläuft. MST bezeichne den minimalen Spannbaum, der die Anzahl der Kanten der Menge P-MST minimiert. (Diese Annahme ist bei gleichen Kantenlängen
entbehrlich) Es gilt |MST| ≤ |OPT|. Zuerst soll gezeigt werden, daß gilt:
|P| ≤ (1+ δ2 )|MST|
Das Theorem folgt dann durch die Wahl von δ=2. Das minimiert den Ausdruck 2(2+δ)(1+ δ2 )
Es werde eine feste, planare Umgrenzung von MST∪P betrachtet. (Darin kommt jede Kante aus P∩MST genau
einmal vor.) Jede Kante in PMST wird als chord bezeichnet. Es sei nun R der geschlossene Kantenzug den
man erhält, wenn man außen um die Kanten von MST herumläuft. In R wird dann jede Kante aus MST genau
zwei Mal enthalten sein. Jedem Knoten in R wird danach ein neuer Bezeichner gegeben. Es hilft, wenn man sich
vorstellt, R würde wie ein Luftballon aufgeblasen, so daß R zum Umriß eines Polygons wird, und die chords an
der Außenseite von R angeordnet werden. Nun wird das Polygon durch einen beliebigen Knoten z durchgeschnitten. Dadurch wird aus R eine offene Kurve.
9
f
f
b
b
c
a
c
a
e
d
c
d
d
c‘
e
b
c‘‘
a
b‘‘
b‘
f
e
Der Graph in der linken oberen
Ecke von Abblidung 2 zeigt einen
planaren Graphen, in dem MST
mit durchgezogenen Linien eingezeichnet ist und die Kanten aus
PMST mit gestrichelten Linien
eingezeichnet sind. Rechts oben ist
der geschlossene Kantenzug in
durchgezogenen Linien gezeichnet. Unten sind die aufgeblasene
Version von R und die chords zu
sehen. Durchschneiden von R bei
d erzeugt die offene Kurve
R = dc’ec‘‘b’fb‘‘abcd‘.
Um
zu
zeigen,
daß
2
|P| ≤ (1+ δ )|MST|, reicht es aus, zu
beweisen, daß die Summe der
Kantengewichte in PMST höchstens
|R|
δ
beträgt, weil |R|=2|MST|
gilt. Ein chord xy wird als innerhalb eines anderen chords vw
bezeichnet, wenn im Durchlaufen
von R folgende Knoten in einer dieser Reihenfolgen auftauchen: vxyw, vyxw, wyxv oder wxyv. Es werden nun
alle chords von innen nach außen rekursiv durchlaufen, während R sich dadurch ändert, daß es an jeweils passenden Knoten durchschnitten wird.
Abbildung 2 - Konstruktion von R
Es sei nun xy die betrachtete Kante. Der Ausdruck R(x,y) bezeichnet dann den Abschnitt zwischen x und y aus
R. xy wird als guter chord bezeichnet, wenn |R(x,y)| ≥ (1+δ)|xy|. Zuerst wird bewiesen, daß alle chords gut sind.
Um dazu einen Widerspruch zu erzeugen, wird angenommen, daß |R(x,y)| < (1+δ)|xy|. Eine Kante vw wird als
groß bezeichnet, wenn vw ∈ R(x,y) und |vw| ≥ |xy|. Dann wird gezeigt, daß es mindestens eine große Kante gibt.
Betrachtet man nämlich den Zeitpunkt, zu dem xy geladen wurde (das ist der Zeitpunkt, in dem y zum ersten
Mal besucht wurde), so muß zu diesem Zeitpunkt eine andere geladene Kante in R(x,y) gewesen sein, denn
R(x,y) stellt einen Pfad von einem besuchten Knoten zu einem angrenzenden Knoten dar. Die Kante vw sei die
erste solche angrenzende Kante, die durchlaufen wird, wenn der TS auf R(x,y) von x nach y geht. Weil zu diesem Zeitpunkt d(x,v)+|vw|<(1+δ)|xy| ist, muß |xy| ≤ |vw| sein, oder xy würde nicht geladen gewesen sein, als y
besucht wurde. Jetzt muß gezeigt werden, daß es mindestens eine große Kante gibt, die nicht geladen wurde. Um
einen Widerspruch zu erhalten, wird angenommen, daß jede große Kante geladen wurde. Unter den großen
Kanten in R(x,y) wird nun jene Kante betrachtet, die als letzte geladen wurde.
Ohne Verlust der Allgemeingültigkeit wird angenommen, daß v vor w besucht wird. Dann wird der Zeitpunkt
betrachet, an dem die angrenzende Kante vw geladen wird. Es sei ab die Kante, die als erstes erreicht wird, wenn
der Pfad R(x,y)+{xy}-{vw} von v nach w durchlaufen wird. Es gilt: d(v,a)+|ab| ≤ |R(x,y)|+|xy|-|vw|. Weil
|vw| ≥ |xy| und |R(x,y)| < (1+δ)|xy| gilt auch, daß d(v,a)+|ab| < (1+δ)|vw|. Weil vw eine geladene Kante ist, muß
|ab| ≥ |vw| sein. Deshalb ist ab eine große Kante, die nicht durch ShortCut zur geladenen wurde.
Wenn aber eine große Kante ab nicht geladen ist, gilt ab ∈ MST. Das führt aber nun zum Widerspruch, denn
entweder MST-{vw}+{xy} hat geringere Kosten als MST oder hat von P weniger chords verursacht, als MST.
10
Damit ist bewiesen, daß |R(x,y)| ≥ (1+δ)|xy|, daß also xy ein guter chord ist. Nun wird diejenige Kurve als R
bezeichnet, die entsteht, wenn man R(x,y) durch xy ersetzt und das Argument rekursiv wiederholend anwendet.
Es sei T(|R|,k) das Supremum über alle offenen einfachen Kurven R der Länge |R| und über alle Möglichkeiten k
chords so zu R hinzuzufügen, daß der resultierende Graph planar ist und jeder chord die Gleichung
|R(x,y)| ≥ (1+δ)|xy| erfüllt, wenn eben obige Argumentation rekursiv auf die gesamte Länge dieser k chords
angewendet wird. Dann erfüllt T(|R|,k) folgendes rekursives Gleichungssystem
T(|R|,0)
= 0
T(|R|,k)
≤ T(|R| - (1+δ)|xy|+|xy|), k-1)+|xy|
Die Lösung dieses Systems ist T(|R|,k) ≤
|R|
δ
.
4 ShortCut an einem Beispiel
Im Folgenden sei kurz ein Beispiel gegeben, wie ShortCut für einen konkreten Graphen einen Durchlauf vornimmt. Durchlaufen werden soll dieser Graph von a aus:
(1) ShortCut(a,b)
for(bc, bf) bc:
bf:
for(bc, bf) bc:
(2) ShortCut(b, c)
for(bf, cd) bf:
cd:
for(cd, CF) cd:
(f)
(f)
(w, w) Gehe (bc)
(w) addSK(CF) zu Inz(c), Inz(f)
(f)
(w, f)
(w, f)
CF: (w, f)
(w, w) Gehe(c, f)
(3) ShortCut(c, f)
for(cd, fg, fe, fd)
cd: (w) addSK(FD) zu Inz(f), Inz(d)
fg, fe, fd: (f)
for(fg, fe, fd, FD) fg, fe, fd: (f)
FD: (w, w) Gehe(f, d)
(4) ShortCut(f, d)
for(fg, fe, dg, de) (f)
for(dg, de) dg: (w, w) Gehe(dg)
(5) ShortCut(d, g)
for(fe, de) fe: (w) addSK(GE) zu Inz(g), Inz(e)
de: (f)
for(GE) (w, f)
(w, w) Gehe(g, e)
(6) ShortCut(g, e)
for()
for()
Gehe nach g
(5)
Gehe nach d
(4)
de (f)
Gehe nach f
(3)
Gehe nach c
(2)
Gehe nach b
(1)
bf: (f)
Gehe nach a
4
c
a
0
b
d
1
3
g
2
6
f
5
8
e
7
11
Dabei ergeben sich folgende Belegungen für die Listen Inzidenz(v) und Block(e)
Kanten in Großbuchstaben sind dabei Sprungkanten
bei Besuch von
Knoten v Inzidenz v
Knoten
b
b
bc, bf
c
bc
f
bf
c
b
bc, bf
c
bc, CF
f
bf, CF
d
cd
bc, bf
f
b
bc, cd, CF
c
bf, CF, fg, fe, fd, FD
f
cd, fd, FD
d
fg
g
fe
e
bc, bf
d
b
bc, cd, CF
c
bf, CF, fg, fe, fd, FD
f
cd, fd, FD, dg, de
d
fg, dg
g
fe, de
e
bc, bf
g
b
bc, cd, CF
c
bf, CF, fg, fe, fd, FD
f
cd, fd, FD, dg, de
d
fg, dg, GE
g
fe, de, GE
e
bc, bf
e
b
bc, cd, CF
c
bf, CF, fg, fe, fd, FD
f
cd, fd, FD, dg, de
d
fg, dg, GE
g
fe, de, GE
e
angrenzende Kante xy Block(xy)
bc
bf
bc
bf
cd
bf
cd
fg
fe
fd
cd, fe
cd
cd, fg, fe
fg
fe
dg
de
fe
de
fe, dg, de
dg
dg
fe
Es ergibt sich dann folgender Weg des TS:
a, b, c, b, f, b, c, d, g, f, e, f, g, d, c, b, f, b, c, b, a
mit einer Länge von 50.
Der optimale Weg (a, b, c, d, g, f, e, f, b, a) hat eine Länge von 26. Man sieht, daß die Abschätzung, welche die
competitive analysis liefert, übermäßig pessimistisch ist.
Als Kritikpunkt des Algorithmusses sei angemerkt, daß der Rückweg nochmals über den Hinweg führt. Dies
könnte man verbessern, indem der TS sein Wissen über den Graphen ausnutzt, das er hat, wenn er den letzten
Knoten besucht. Er könnte dann den kürzesten Weg zum Startpunkt zurück wählen.
12
5 Literaturverzeichnis
[FiWo98]
A. Fiat, G. J. Woeginger (eds.) (1998): Online algorithms: The state of the art; Lecture Notes in
Computer Science, vol. 1442; Springer
[HaSz94]
Magnus M. Halldórson, Mario Szgedy (1994): Lower bounds for on-line graph coloring; In:
Theoretical Computer Science 130 (1994) pp. 163-174; Elsevier
[KaPr94]
B. Kalyanasundaram, Kirk Pruhs (1994): Constructing competitive tours from local information; In: Theoretical Computer Science 130 (1994) pp. 125-138; Elsevier
[KaPr98]
B. Kalyanasundaram, Kirk Pruhs (1998): On-line Network Optimization Problems. In: [FiWo98, Kapitel 12]
[KrRa99]
S. O. Krumke, J. Rambau (1999): Online-Optimierung; Vorläufiges Skript zum Online-Teil der
Vorlesung „Ausgewählte Kapitel aus der ganzzahligen Optimierung“ im Wintersemester
1999/2000 an der Technischen Universität Berlin. Quelle (Stand 06/2000):
http://www.zib.de/projects/production-planning/docs/online-einfuehrung.html (Konrad-ZuseZentrum für Informationstechnik Berlin)
[MoRa95]
Rajeev Motwani, Prabhajar Raghavan (1995): Randomized Algorithms; Cambridge University
Press
[SlTa85]
D. D. Sleator, R. E. Tarjan (1985): Amortized efficiency of list update and paging rules; Communications of the ACM 28, no. 2, 202–208. (ACM = Assocation for Computing Machinery)
13