1 / 41

Kürzeste Wege

Kürzeste Wege. Implementierung des Algorithmus von Dijkstra. Helmut Paulus Speyer, 3.-5.11.08. Teil 1. Objektorientierte Modellierung von Graphen. Graphen. 3. Ein Graph beschreibt eine Struktur aus Objekten und den Beziehungen zwischen ihnen. Ein Graph besteht aus

marek
Download Presentation

Kürzeste Wege

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Kürzeste Wege Implementierung des Algorithmus von Dijkstra Helmut Paulus Speyer, 3.-5.11.08

  2. Teil 1 Objektorientierte Modellierung von Graphen

  3. Graphen 3 Ein Graphbeschreibt eine Struktur aus Objektenund den Beziehungenzwischen ihnen. Ein Graph besteht aus – einer Menge von Knoten(Objekten)und – einer Menge von Kanten(Beziehungen), die die Knoten verbinden. • Klassische Probleme • Eulersche Wanderungen • Hamiltonsche Rundreisen • Labyrinthproblem • Problem des Handlungsreisenden • Kürzeste Wege

  4. Algorithmus von Dijkstra 4 {Eingabe: Graph G; Startknoten s des Graphen} für alle Knoten w      setze dg(w) = ∞ setze dg(s) = 0 füge s in eine (zunächst leere) Datenstruktur D ein solange D nicht leer ist      entnimm einen Knoten w mit minimalem dg(w) aus D      für alle Kanten {w,u}           falls dg(u) = ∞                füge u in D ein           falls dg(u) > dg(w) + g({w,u})                setze dg(u) = dg(w)+g({w,u}) {Ausgabe: gewichteter Abstand dg(w) aller Knoten w vom Startknoten s} Quelle: http://www.matheprisma.uni-wuppertal.de/Module/Graphen/index.htm

  5. Algorithmus von Dijkstra 5 Abgewandelte Version: {Eingabe: Graph G; Startknoten s, Zielknoten z des Graphen} für alle Knoten w      setze Entfernung(w) = 0 füge s in eine (zunächst leere) Warteschlange WS ein solange erstesElement von WS <> z     entnimm den ersten Knoten w von WSfür alle Kanten {w,u} falls u noch nicht besuchtfalls Entfernung(u) = 0 setze Vorgänger von u auf w              füge u in WS ein setze Entfernung(u) = Entfernung(w) + gewicht({w,u}) sonst falls Entfernung(u) > Entfernung(w) + gewicht({w,u})                setze Vorgänger von u auf w setze Entfernung(u) = Entfernung(w) + gewicht({w,u}) füge u erneut in WS ein {Ausgabe: Abstand des Zielknotens z vom Startknoten s} w expandieren WS: Prioritätenwarteschlange, d. h. die Knoten werden nach ihrer Entfernung (Priorität) geordnet einsortiert! Der Knoten mit kleinsten Entfernung steht am Anfang.

  6. Algorithmus von Dijkstra 6 22 F A 10 Gesucht: Kürzester Weg von A nach E 16 12 B 25 6 E 5 C D 6 WS: A/0 12

  7. Algorithmus von Dijkstra 7 22 F A 10 Gesucht: Kürzester Weg von A nach E 16 12 B 25 6 E 5 C D 6 WS: 12

  8. Algorithmus von Dijkstra 8 22 0 22 F A 10 Gesucht: Kürzester Weg von A nach E 10 16 12 B 25 6 E 5 C D 6 WS: B/10, C/12, F/22 12 12

  9. Algorithmus von Dijkstra 9 22 0 22 F A 10 Gesucht: Kürzester Weg von A nach E 10 16 12 B 25 6 E 5 C D 6 WS: C12, F22 12 12

  10. Algorithmus von Dijkstra 10 22 0 22 F A 10 Gesucht: Kürzester Weg von A nach E 10 16 12 35 B 25 6 E 5 C D 6 WS: C/12, D/15, F/22, E/35 12 12 15

  11. Algorithmus von Dijkstra 11 22 0 22 F A 10 Gesucht: Kürzester Weg von A nach E 10 16 12 35 B 25 6 E 5 C D 6 WS: D/15, F/22, E/35 12 12 15

  12. Algorithmus von Dijkstra 12 22 0 22 F A 10 Gesucht: Kürzester Weg von A nach E 10 16 12 35 B 25 6 E 5 C D 6 WS: D/15, F/22, E/35 12 12 15

  13. Algorithmus von Dijkstra 13 22 0 22 F A 10 Gesucht: Kürzester Weg von A nach E 10 16 12 35 B 25 6 E 5 C D 6 WS: F/22, E/35 12 12 15

  14. Nach Ausführung 0 Jeder besuchte Knoten enthält den minimalen Abstand zum Startknoten, sowie einen Verweis zu seinem Vorgänger im Pfad (lineare Liste). 22 F 22 A 10 10 16 12 B 25 6 E 5 C D 6 21 12 12 15 Algorithmus von Dijkstra 14 22 0 22 F A 10 Gesucht: Kürzester Weg von A nach E 10 16 12 21 B 25 6 E 5 C D 6 WS: E/21, F/22 12 12 15 WS: F/22

  15. TKnoten - name : string • kanten : Tkantenliste • anzahlkanten : integer • entfernung : integer • nachfolger, vorgaenger : TKnoten TGraph * - anzahlKnoten : integer • knoten : TKnotenliste + create(n : string; x,y : integer) + fuegeKantehinzu(nachbar : Tknoten; e : integer) • initialisiere • + create • + berechneWeg(start, ziel : Tknoten) • + gibAlleKnoten : Tknotenliste • + gibKnoten(n : string) • + gibAnzahlKnoten : integer 1 * TKante - gewicht : integer • nachbar :TKnoten Das Graphobjekt verwaltet die Knoten und Kanten und stellt den Suchalgorithmus zur Verfügung. + create(k : TKnoten; e : integer) + gibGewicht : integer + gibNachbar : TKnoten Implementierung von Graphen 15 Objektorientierte Lösung: Jeder Knoten ist ein Objekt Jede Kante ist ein Objekt

  16. Zielsetzung 16 Ziel ist es, ein Programm zu entwickeln, mit dessen Hilfe man kürzeste Wege im Graphen ermitteln kann. Folgende Anforderungen soll das Programm erfüllen: /1/ Der Graph wird als Bild auf der Benutzungsoberfläche angezeigt. /2/ Man kann sich einen kürzesten Weg von einem eingegebenen Start- zu einem eingegebenen Zielknoten berechnen und anzeigen lassen. • Arbeitsschritte: • Grafik mit Delphi • Entwicklung einer (Prioritäten-)Warteschlange • Implementierung des Graphen • Implementierung des Dijkstra-Algorithmus

  17. Teil 2 Grafik mit Delphi

  18. TCanvas Brush : TBrush Pen : TPen Font : TFont ... moveto(x,y : integer); lineto(x, y : integer); ellipse(x1,y1,x2,y2 : integer) rectangle(x1,y1,x2,y2 : integer) polygon(p : array of Tpoint); TextOut(x, y: Integer; const Text: string); ... Zeichenfläche TCanvas 18 • Canvas-Objekte dienen als Zeichenfläche für grafische Elemente. • Sie kapseln eine Vielzahl von Methoden zur Ausgabe von Grafik und Text in einem rechteckigen Bereich. TCanvas-WerkzeugePen, Brush und Font, zuständig für bestimmte Teilaufgaben: Pinsel – Füllfarbe, Muster ... Stift – Linienfarbe, Stil ... Schriftart – Farbe, Schrifttyp ... Der Koordinatenursprung (0,0) ist in der linken oberen Ecke einer Komponenten, die ein Canvas-Objekt zur Verfügung stellen.

  19. Wie erhält man ein TCanvas-Objekt? 19 • TCanvas-Objekte werden von einigen Delphi-Komponenten als Property zur Verfügung gestellt: z. B.: Formular, Paintbox, Image, Bitmap • Der Koordinatenursprung ist die linke obere Ecke der jeweiligen Komponente. • Die positive y-Achse zeigt nach unten. • Die Image-Komponente speichert die Graphik zusätzlich in einer Hintergrundbitmap, so dass das Bild automatisch anzeigt wird, wenn das Formularfenster, nachdem es verdeckt war, wieder in den Vordergrund geholt wird. • Formular und Paintbox zeichnen das Bild nur einmalig. Damit es nach dem Verdecken wieder erscheint, muss das Zeichnen der Graphik in der OnPaint-Ereignismethode der jeweiligen Komponente erfolgen. Dieses Ereignis wird vom Betriebssystem automatisch ausgelöst.

  20. Objekthierarchie 20 Das Bild-Objekt Bild vom Typ TImage mit Hilfe seines Attributs Canvas ein Leinwand-Objekt der Klasse Tcanvas zur Verfügung. Dieses wiederum hat ein Zeichenstift-Objekt der Klasse TPen und ein Malpinsel-Objekt der Klasse Tbrush. Die entsprechenden Attribute Pen und Brush werden als Property zur Verfügung gestellt. Beispiel: Blaues Rechteck Bild.Canvas.Brush.Color := clbue; Bild.canvas.rectangle(10,10,100,20); Pinselfarbe blau Rechteck mit der linken oberen Ecke am Punkt (X1, Y1) und der rechten unteren Ecke am Punkt (X2, Y2).

  21. Aufgaben 1 21 • Testen Sie das Beispielprogramm Grafiktest.exeVariieren Sie verschiedene Modi der Pinsel und StifteTesten Sie insbesondere den NotXOR-Füllmodus • Entwickeln Sie ein Programm, das die Bilddatei Lageplan.jpg im Formular anzeigt.

  22. Teil 3 Entwicklung einer Warteschlange

  23. :Knoten :Schlange :Knoten nachfolger = name = B nachfolger = name = A Kopf = ... Datentyp Schlange 23 Eine Schlange realisiert das Prinzip FIFO (First In First Out), • d. h. die Ausgabe erfolgt in gleicher Reihenfolge wie die Eingabe. Spezialisierte Schlange: Kopf Hat kennt nil Jedes Element kennt einen Nachfolger • Das Objekt Schlange dient der Verwaltung • Mit Hilfe seines Attributs Kopf hat es Zugriff auf das erste Element • Die Knoten implementieren das Einfügen nach dem FIFO-Prinzip,neue Elemente werden vom Kopf an ans Ende gereicht • Der Nachfolger des letzten Elements zeigt immer auf nil;es ist die Stelle, wo neue Elemente eingefügt werden.

  24. :Knoten :Schlange :Knoten nachfolger = inhalt = nachfolger = inhalt = Kopf = ... Allgemeine Schlange 24 Schlange für beliebige Objekte kennt kennt nil :Object :Object Jedes Element erhält ein Inhaltsobjekt

  25. TKnoten - inhalt : string; - nachfolger : TKnoten; + create (wert: string); + fuegeKnotenEin (nK: TKnoten) + gibKnotenAus (liste: TStrings); + setzeInhalt (wert: string); + setzeNachfolger (k: TKnoten); + gibInhalt : string; + gibNachfolger : TKnoten; TSchlange - Kopf : TKnoten + create + istLeer: boolean + einfuegeKnotenein(k : Tknoten) + giberstesElement : TKnoten + entferneErstes + gibSchlangeAus(liste : TStrings) Klassendiagramm 25 hat kennt

  26. TSchlange - Kopf : TKnoten + create + istLeer: boolean + einfuegeKnotenein(k : Tknoten) + giberstesElement : TKnoten + entferneErstes + gibSchlangeAus(liste : TStrings) Klasse TSchlange 26 Operationen • prüfen, ob die Schlange leer ist • ein neues Element in die Warteschlange einfügen • auf das erste Element zugreifen • das erste Element der Schlange entfernen • alle Elemente ausgeben Implementierung TSchlange = class protected //Attribute kopf : TKnoten; public //Methoden constructor create; destructor destroy;override; function istLeer : boolean; function gibErstesElement : TKnoten; procedure entferneErstes; procedure fuegeKnotenEin (kn: TKnoten); procedure gibSchlangeAus (liste: TStrings); end;

  27. Implementation 27 Schlangeobjekt erzeugen Im Konstruktor wird Leerelement als Kopf erzeugt. Ein Leerelement erhält einen Verweis auf erste Element constructor TSchlange.create; begin kopf := TKnoten.create('leer'); end; und zerstören destructor TSchlange.destroy; begin while kopf.gibNachfolger <> nil do entferneErstes; kopf.Free; inherited destroy; end; Alle Elemente aus Schlange entfernen und freigeben Leerelement freigeben Destruktor der Vorfahrklasse aufrufen um das Schlangenobjekt zu zerstören

  28. TKnoten - inhalt : string; - nachfolger : TKnoten; + create (wert: string); + fuegeKnotenEin (neuerKnoten: TKnoten) + gibKnotenAus (liste: TStrings); + setzeInhalt (wert: string); + setzeNachfolger (k: TKnoten); + gibInhalt : string; + gibNachfolger : TKnoten; Einfügen am Ende der Schlange (FIFO – Prinzip) procedure TKnoten.fuegeKnotenEin (neuerKnoten: TKnoten); begin if nachfolger = nil then nachfolger := neuerKnoten else nachfolger.fuegeKnotenEin(neuerKnoten); end; Der neue Knoten wird bis zum letzten weitergereicht Klasse TKnoten 28 Die Knoten implementieren das FIFO – Prinzip

  29. Aufgabe 2 29 • Aufgabe 1 • Erstellen Sie ein Programm, mit dessen Hilfe die Implementierung der Klasse „TSchlange“ gestestet werden kann. • Z. B.: Es soll eine Städte [Köln;Frankfurt; ...] erstellt und angezeigt werden. • Es müssen nicht alle Methoden implementiert werden. • Benutzen Sie die vorgegebene Benutzungsoberfläche Aufgabe 2 Fügen Sie den Knoten das Attribut entfernung hinzu. Zu Testzwecken kann der Wert zufällig beim Erzeugen des Knotens gesetzt werden. Ändern Sie die Methode Tknoten.fuegeKnotenEin (...) so ab, dass die Knoten - abweichend vom FIFO-Prinzip - nach Entfernung geordnet eingefügt werden. (Prioritäten-Warteschlange)

  30. Teil 4 Implementierung des Graphen zum Lageplan mit Dijkstra Algorithmus

  31. OOA-Klassendiagramm

  32. Sequenzdiagramm: Weg berechnen Create() als besucht

  33. Anhang 1 Entwicklung der Prioritäten-Warteschlange durch Vererbung

  34. TPKnoten - inhalt : string; • nachfolger : TKnoten • entfernung : integer + create (wert: string); + fuegeKnotenEin(nK :TKnoten) + gibKnotenAus (liste: TStrings); + setzeInhalt (wert: string); + setzeNachfolger (k: TKnoten); + gibInhalt : string; + gibNachfolger : TKnoten; Prioritäten-Warteschlange 34 Im Unterschied zu einer gewöhnlichen Schlange werden die Dinge nach einer Priorität geordnet eingefügt und gemäß dieser Priorität wieder entnommen. Eine solche Schlange ist also im Prinzip eine geordnete Liste. • Die Knoten erhalten ein weiteres Attribut (Priorität), nach denen sie geordnet werden. • Außerdem ändert sich das Einfügen. • Ein neuer Knoten wird so lange weitergereicht, bis er einen Knoten höherer Priorität erreicht. Mit Hilfe von Vererbung kann der größte Teil des bisher geschriebenen Codes wiederverwendet werden.

  35. TKnoten - inhalt : string; - nachfolger : TKnoten + create (wert: string) + fuegeKnotenEin (nK: TKnoten) ... TPKnoten - entfernung : integer + create (wert: string; e : integer) + fuegeKnotenEin(nK :TKnoten) Spezialisierung der Knoten 35 Basisklasse - Die Methode fuegeKnotenEin() wird als virtuelleMethode deklariert Ist ein - Beziehung Abgeleitete Klasse - erhält ein Prioritätsattribut - überschreibt die Methode zum Einfügen

  36. Implementierung 36 Basisklasse TKnoten = class protected inhalt : string; nachfolger : TKnoten; public constructor create (wert: string); procedure fuegeKnotenEin (nk: TKnoten); virtual; ... end; Abgeleitete klasse TP_Knoten = class(TKnoten) protected entfernung : integer; public constructor create (wert: string; e : integer); procedure fuegeKnotenEin (nK : TKnoten); override; procedure setzeEntfernung (e: integer); function gibEntfernung : integer; end; Der statische Konstruktor wird neu implementiert (ersetzt).

  37. TSchlange - Kopf : TKnoten + create ... TPSchlange + create Klasse TPSchlange 37 Die Klasse TPSchlange wird von TSchlange abgleitet. Es wird lediglich den Konstruktor geändert. constructor TPSchlange.create; begin kopf := TP_Knoten.create(''); end; Dem geerbten Attribut Kopf wird ein TP_Knoten-Objekt zugewiesen

  38. TList + Count: integer+ Items[pos: integer]: Pointer + create + Delete(pos: integer) + Insert(pos: integer; obj: Pointer) ... Anhang 2 38 Delphi verfügt über eine vordefinierte Klasse „TList“. Informieren Sie sich über diese Klasse mit der Delphi-Hilfe. Implementieren Sie dann die Prioritätenschlange mit dieser vordefinierten Klasse „TList“. TList verwaltet eine Liste von Zeigern auf Objekte. Mit Hilfe des Properties (Attribut) Items kann auf jede Objektreferenz per Index zugegriffen werden. Der Parameter Index enthält den Index auf das Objekt, wobei das erste den Index 0 hat, der letzt den Index Count-1. Beispiel: var Knotenliste : Tlist; Knoten : TKnoten ... for i := 0 to Knotenliste.Count-1 do begin Knoten := Tknoten(Liste.items[i]); Knoten.gibAus(....); end; Durch Typumwandlung erhält man Zugriff auf das Objekt an der Position i

  39. TStringList + Count: integer + Strings: array[0..] of string + create + delete(p: integer) + insert(p: integer; s: String) ... TSchlange - liste : TList + create + istLeer: boolean + einfuegeKnotenein(k : Tknoten) + giberstesElement : TKnoten + entferneErstes + gibSchlangeAus(liste : TStrings) Anhang 2 39 Implementierung der Schlange mit einem TList-Objekt Die Klasse TSchlange liefert eine eingeschränkte Schnittstelle zum geschütztenTList-Objekt. Die Verwaltung der Objekte wird an das TList- Objekt delegiert. Stringlisten Für Listen von Strings bietet Delphi die Klasse TStringList. Einige Attribute (Properties) und Operationen sind im nebenstehenden Klassendiagramm aufgeführt. Die Bedeutung der Bestandteile kann mit der Delphi-Hilfe ermittelt werden. Die Delphi-Komponenten TListBox und TMemo enthalten ein Stringlistenobjekt.

  40. TStapel - liste : TList + create + istLeer: boolean + einfuegeKnotenein(k : Tknoten) + giberstesElement : TKnoten + entferneErstes + gibStapel(liste : TStrings) Aufgabe 3 40 Aufgabe 1 Implementieren Sie mit Hilfe der Delphi-Klasse TList eine Stapel. (Lineare Liste, die das FIFO-Prinzip realisiert) Aufgabe 2 Entwickeln Sie eine gemeinsame Oberklasse, aus der dann Stapel und Schlange abgeleitet werden.

  41. Quellen 41 • Klaus Becker: Weiterbildungslehrgang X "Informatik für Gymnasien“ Kurs http://informatik.bildung-rp.de/weiterbildungsmaterial/lehrgang-x-2005-2008/kurs-5.html • MathPrisma: http://www.matheprisma.uni-wuppertal.de/Module/Graphen/index.htm • H.W. Lang   FH Flensburg :  http://www.inf.fh-flensburg.de/lang/algorithmen/graph/ • swisseduc.ch : Informatik Graphbench: http://www.swisseduc.ch/informatik/graphbench/ • M. Pohlig: www.pohlig.de • Jürgen Dehmer, A. Sessler, G. LiebrichProjekt: Tauglichkeitstesterhttp://www.lehrer.uni-karlsruhe.de/~za714/informatik/infkurs

More Related