Vortr

Wegsuchealgorithmen in
Routenplanungssystemen
Vortrag von Markus Schäfer
Projektgruppe Intelligente Datenbanken
8.7.2003
Gliederung
1.
2.
3.
4.
Worum es heute geht – Routenplanung
Motivation und Ziel
Straßenkarten
Algorithmen
1.
2.
3.
4.
5.
Experimentelle Analyse der Laufzeit
1.
2.
6.
Iterative Breitensuche
Dijkstras Algorithmus
Bewertungsfunktionen
A*
Synthetischer Graph
Minneapolis
Zusammenfassung
Worum es heute geht Routenplanung
• Das heutige Verkehrsaufkommen verlangt ein
effizientes Management des Verkehrs.
• Eine Studie in den USA hat abgeschätzt, daß sich
durch geschickte Routenplanung 6% der Fahrzeiten
vermeiden lassen könnten.
• Routenplanungssysteme bestehen aus drei
Einheiten: Routenberechnung, Routenbewertung und
Routendarstellung
• Wir beschäftigen uns heute aber nur mit der
Routenberechnung (in Folge auch Wegsuche
genannt).
Motivation und Ziel
• Traditionelle Wegsuche-Algorithmen berechnen mehr
Wege als für unsere Zielsetzung notwendig sind.
• Sie sind auch nicht an dynamische Kantenkosten
(Verkehrsstau) angepasst.
• Außerdem nehmen sie häufig an, daß die Daten im
Hauptspeicher bearbeitet werden; das tatsächliche
Datenaufkommen ist aber so groß, daß es sinnvoll
nur mit Hilfe von Datenbankmanagmentsystemen
verwaltet werden kann.
Straßenkarten
• Wir wollen die Straßenkarten durch einen Graph
charakterisieren, dessen Kanten sowohl statische als
auch dynamische Attribute besitzen.
• Die Attribute können nun durch drei verschiedene
Verteilungen kategorisiert werden: gleichmäßig,
leicht-variiert und unregelmäßig
• Die Algorithmen lassen sich in drei Klassen einteilen:
alle-Paare-Probleme, einzel-Quelle-Probleme und
einzel-Paar-Probleme
Algorithmen
• Im folgenden werden drei Algorithmen vorgestellt, die
jeweils die jeweils eine Klasse repräsentieren:
Iterative Breitensuche (alle-Paare-Wegsuche),
Dijkstras Algorithmus (einzel-Quelle-Wegsuche) und
A* (einzel-Paar-Wegsuche)
• Ziel der Algorithmen ist es zu einem Paar (Quelle,
Ziel) den schnellsten Weg zu suchen.
• Da dynamische Attribute vorliegen, können wir nicht
einfach alle kürzesten Wege vorausberechnen und
speichern.
Algorithmen – Iterative Breitensuche
Procedure Iterative(N,E,s,d) {
foreach u in N do { C(s,u)=∞; C(u,u)=0;
path(u,v):=null }
frontierSet:=[s];
while not_empty(frontierSet) do {
foreach u in frontierSet do {
frontierSet:=frontierSet-[u];
fetch(u.adjacencyList);
foreach <v,C(u,v)> in u.adjacencyList {
if C(s,v)>C(s,u)+C(u,v) then {
C(s,v):=C(s,u)+C(u,v);
path(s,v):=path(s,u)+edge((u,v);
if not_in(v,frontierSet) then
frontierSet:=frontierSet+[v]; }}}}}
Algorithmen – Dijkstras Algorithmus
Procedure Dijkstra(N,E,s,d) {
foreach u in N do {C(s,u)=∞;
C(u,u)=0; path(u,v):=null;}
frontierSet:=[s]; exploredSet:=emptySet;
while not_empty(frontierSet) do {
select u from frontierSet with minimum C(s,u);
frontierSet:=frontierSet-[u];
exploredSet:=exploredSet+[u]
if (u=d) then terminate else {
fetch(u.adjacencyList);
foreach <v,C(u,v)> in u.adjacencyList
if C(s,v)>C(s,u)+C(u,v) then {
C(s,v):=C(s,u)+C(u,v);
path(s,v):=path(s,u)+(u,v);
if not_in(v,frontierSet∪exploredSet) then
frontierSet:=frontierSet+[v] }}}}
Algorithmen – Bewertungsfunktionen
• Bewertungsfunktionen benutzen wir um
auszusuchen, welcher der vielversprechendste
Knoten im aktuellen Rechenschritt ist.
Wir betrachten zwei Bewertungsfunktionen:
Euklidische Distanz:
(( x1  x2 ) 2  ( y1  y2 ) 2
Manhattan Distanz:
( x1  x2  y1  y2 )
Algorithmen – A*
Procedure A*(N,E,s,d,f) {
foreach u in N do { C(s,u)=∞; C(u,u)=0;
path(u,v):=null;}
frontierSet:=[s]; exploredSet:=emptySet;
while not_empty(frontierSet) do {
select u from frontierSet with min(C(s,u)+f(u,d));
frontierSet:=frontierSet-[u];
exploredSet:=exploredSet+[u];
if (u=d) then terminate else {
fetch(u.adjacencyList);
foreach <v,C(u,v)> in u.adjacencyList {
if C(s,v)>C(s,u)+C(u,v) then {
C(s,v):=C(s,u)+C(u,v);
path(s,v):=path(s,u)+(u,v);
if not_in(v,frontierSet) then
frontierSet:=frontierSet+[v]; }}}}}
Experimentelle Analyse der Laufzeit
– Synthetischer Graph 1/5
• Zum Vergleichen von A* mit den anderen Algorithmen, wollen
wir nun die Laufzeit der Algorithmen auf einem künstlichen
Graph untersuchen:
- Rechteckiger ungerichteter
Graph
- Jeder Knoten hat 4 Nachbarn
(außer den Randknoten)
- Wir betrachten drei verschiedene
Quelle-Ziel-Paare:
[(1,1), (k , k )]
[(1,1), (k ,1)]
 (1  k ) 
[(1,1), (k , 
)]

 2 
Experimentelle Analyse der Laufzeit
– Synthetischer Graph 2/5
• Wir untersuchen die drei im ersten Teil vorgestellten Algorithmen
und wählen die Manhattan-Distanz als Bewertungsfunktion für
A*
• Für unser Testgraph gibt es nun drei Variable Parameter:
- Größe des Graphen: 10*10, 20*20, 30*30
- Pfadlänge
- Kostenmodell:
gleichmäßig – Jeder Kante wird der Wert 1 als Kosten
zugewiesen
leicht-variiert – Jeder Kante wird 1+0,2*U[0,1] zugewiesen
unregelmäßig – Den Kanten [(i,1),(i+1,1)] und [(k,i),(k,i+1)]
werden kleine Kosten zugewiesen
Experimentelle Analyse der Laufzeit
– Synthetischer Graph 3/5
Auswirkungen der Größe des
Graphen
• Es wurde der diagonale Pfad
ausgewählt, um das worst-case
Verhalten zu untersuchen
• Die Größe des Graphen beeinflusst
die Laufzeit von A* und Dijkstra
linear
• Die Breitensuche wächst nur sublinear
mit der Graphengröße
Experimentelle Analyse der Laufzeit
– Synthetischer Graph 4/5
Auswirkungen der Pfadlänge
• Für horizontale Pfade ist A*
besser als die anderen beiden
Algorithmen, ansonsten die
Breitensuche
• Bei A* und Dijkstra steigt die
Ausführungszeit mit der
Pfadlänge
• Die Laufzeit verschlechtert sich
bei A* am stärksten mit der
Pfadlänge
Experimentelle Analyse der Laufzeit
– Synthetischer Graph 5/5
Auswirkungen des
Kostenmodels
Da A* und Dijkstra die Kantenkosten
in ihre Berechnung einbeziehen,
reagieren sie auf unterschiedliche
Kostenmodelle.
Aber auch die Breitensuche verhält
sich je nach Kostenmodell unterschiedlich.
Experimentelle Analyse der Laufzeit
– Minneapolis 1/2
• Als nächsten Schritt wollen wir jetzt die
Laufzeit der Algorithmen an einem
konkreten Fallbeispiel untersuchen.
Wir benutzen einen Ausschnitt
einer tatsächlichen Straßenkarte, die
die Autobahnen und Schnellstraßen
von Minneapolis zeigt
• Sie hat:
1089 Knoten
3300 Kanten (Straßensegmente)
und deckt eine Fläche von 20
Quadratmeilen ab
Experimentelle Analyse der Laufzeit
– Minneapolis 2/2
Der Graph ist ein wenig größer als
der synthetische 30*30 Graph
(1089 gegenüber 900 Knoten)
Wir wollen vier Pfade betrachten:
• 2 diagonale: A nach B
C nach D
• 2 kurze:
D nach G
E nach F
Die Ergebnisse decken sich
mit den Ergebnissen auf den
künstlichen Graphen
Zusammenfassung
Wir haben gesehen, daß aus verschiedenen Gründen
der A*-Algorithmus für unsere Anwendung ein sehr
aussichtsvoller Kandidat ist:
• Er arbeitet auf kurzen Wegen schneller als die anderen
Algorithmen und in der Anwendung werden die meisten
Weganfragen nicht quer über den ganzen Graphen gestellt
• Beim unregelmäßigen Kostenmodell, welches wir in der Praxis
erwarten, ist er der optimalste Algorithmus
Außerdem haben wir gesehen, daß der Algorithmus von
Dijkstra in der Praxis nicht so große Bedeutung hat