Graphen und ihre Verarbeitung Klaus Becker 2017 2

Graphen und ihre Verarbeitung Klaus Becker 2017

2 Graphen

3 Teil 1 Vernetzte Strukturen

4 Routenplanung Typisches Routenproblem: Wie kommt man am besten mit dem Auto von Worms nach Speyer?

5 Routenplanung mit dem Computer Modellierungsproblem: Wie wird das Verkehrsnetz im Computer repräsdentiert? Berechnungsproblem: Wie wird die optimale Route ermittelt?

6 Beschreibung vernetzter Strukturen Modellierung: Will man die Information über ein solches Straßennetz beschreiben, so konzentriert man sich auf die relevanten Fakten und lässt alles andere erst einmal weg. Ist man z. B. nur an den Autobahnverbindungen um Ludwigshafen / Mannheim interessiert, so könnte eine abstrahierende Beschreibung des Autobahnnetzes wie folgt aussehen:

7 Fachkonzept Graph Ein Graph besteht aus einer Menge von Knoten und einer Menge von Kanten (die jeweils zwei Knoten miteinander verbinden). Mathematisch: G = (V, E) V = {WO, KR-FR, . . . , SP, . . . } ist die Menge der Knoten. E = {{WO, KR-FR}, . . . {SP, HO}, . . . } ist die Menge der Kanten. Graphen dienen dazu, vernetzte Strukturen zu beschreiben. Die Knoten repräsentieren die Objekte des Anwendungsbereichs, die Kanten die Beziehungen zwischen den Objekten. Graphen sind ein wichtiges und häufig benutztes Modellierungsmuster in der Informatik (und Mathematik), das in ganz unterschiedlichen Anwendungsbereichen zum Einsatz kommt.

8 Graph-Editor siehe: http: //www. yworks. com/en/products_yed_about. html

9 Graphen in Anwendungssituationen Aufgabe (a) Wie sind die Verbindungslinien zwischen den Fährhäfen hier zu deuten? Warum beschreiben sie nicht die tatsächlichen Schifffahrsrouten? Warum reicht hier eine abstrahierende Darstellung der Fährverbindungen? (b) Man möchte zusätzlich die Streckenlängen der Fährverbindungen angeben. Wie könnte man solche Informationen in der gezeigten Darstellung integrieren? siehe auch: http: //www. ferrylines. com/de/europaeisch es-buchungsportal-fuer-faehren/

10 Graphen in Anwendungssituationen Aufgabe Wie kommt man über Land von Deutschland nach Finnland? Wie viele Ländergrenzen muss man dabei mindestens passieren? (a) Der (noch unfertige Graph) zeigt Deutschland und seine Nachbarländer. Trage erst einmal sämtliche noch fehlenden Nachbarländer in die bereits vorgegebenen Knoten ein. (b) Wie würde man die Kanten in der gezeigten Darstellung deuten? (c) Erweitere das Diagramm um die Nachbarländer von Polen usw. , bis du das oben beschriebene Problem mit Hilfe des Graphen lösen kannst. (d) Wie kommt man über Land von Finnland nach Irland? Wie würde man das am Graphen erkennen? siehe auch: http: //moritz. stefaner. eu/projects/relation-browser/relation. Viewer. swf

11 Graphen in Anwendungssituationen Aufgabe In Königsberg (heute Kaliningrad) teilt der Fluss Pregel die Stadt in mehrere Stadtteile auf. Der Stadtplan hebt die Brücken hervor, die Stadtteile miteinander verbinden. Der Mathematiker Euler beschäftigte sich mit der Frage, ob es einen Rundgang durch Königsberg gibt, der jede der sieben Brücken über den Fluss Pregel genau einmal benutzt. (a) Versuche erst einmal, das Problem von Euler zu lösen. (b) Der folgende Graph zeigt die Brückensituation in Königsberg in einer abstrahierenden Darstellung. Was stellen die Knoten des Graphen, was die Kanten dar? (c) Wie viele Kanten gehen von den jeweiligen Knoten aus? Was hat das mit der Lösung des Problems von Euler zu tun?

12 Graphen in Anwendungssituationen An: Daniel Hallo Daniel, Rebekka hat dich als Freund/Freundin auf. . . hinzugefügt. Wir benötigen deine Bestätigung, dass du Rebekka kennst, damit ihr Freunde/Freundinnen auf. . . sein könnt. Viele Grüße vom. . . Aufgabe (a) Beschreibe die Struktur des folgenden sozialen Netzwerks (siehe rechts Mitte) mit Hilfe eines Graphen. (b) Noch ein soziales Netzwerk (siehe rechts unten). Wie würde man hier die Vernetzungungsstruktur darstellen? (c) Bist du Mitglied in einem sozialen Netzwerk? Wie hoch ist dein Mitgliedsbeitrag? Nimm Stellung zu folgender Aussage: "Die Mitglieder zahlen mit ihren Daten. " Rebekka kennt Daniel, Florian, Lisa, Greta, Sophie, Maria Daniel kennt Tim, Rebekka, Jonas Florian kennt Rebekka, Sophie Lisa kennt Rebekka, Sophie, Jonas Greta kennt Rebekka, Sophie, Tim Sophie kennt Rebekka, Florian, Lisa, Greta Maria kennt Rebekka Tim kennt Daniel, Greta Jonas kennt Daniel, Lisa Martin kennt Markus kennt Martin Anna liebt Ben liebt Clara liebt Daniel liebt Anna

13 Graphen in Anwendungssituationen Aufgabe Zum Nudelkochen im Ferienlager werden genau 2 Liter Wasser benötigt. Zum Abmessen stehen nur ein kleiner Eimer, der 3 Liter fasst, und einen etwas größerer Eimer, der 4 Liter fasst, zur Verfügung. Kann das funktionieren? Um systematisch alle durch Umfüllen erzeugbaren Wassermengen zu bestimmen, kann man einen Zustandsgraphen erstellen. Die Knoten des Graphen sind die aktuellen Füllinhalte der beiden Eimer. Die Kanten des Graphen stellen die Umfüllvorgänge dar. Vervollständige den bereits begonnenen Graphen. Ermittle mit diesem Graphen verschiedene Möglichkeiten, eine 2 -Liter. Wassermenge durch Umfüllen zu erzeugen.

14 Graphen in Anwendungssituationen Aufgabe Am Flussufer befinden sich ein Wolf, eine Ziege, ein Kohlkopf und ein Fährmann. Der Fährmann soll Wolf, Ziege und Kohlkopf auf die andere Seite des Flusses bringen. Er kann aber immer nur einn der drei mit an das andere Ufer nehmen und muss die beiden anderen so lange allein lassen. Da nun der Wolfe gerne die Ziege frisst und die Ziege auf den Kohlkopf scharf ist, kann der Fährmann diese Paarungen nicht allein lassen. Kann der Fährmann das Transportproblem lösen? Versuche, das Transportproblem systematisch zu lösen, indem du den bereits begonnenen Transport-Graphen vervollständigst.

Graphenterminologie 15 Je nach Anwendung ist es sinnvoll, Kanten gerichtet oder ungerichtet zu modellieren. Bei gerichteten Graphen werden in der Regel auch sog. Schlingen zugelassen. Werden die Kanten mit zusätzlichen Gewichten versehen, so spricht man von gewichteten oder bewerteten Graphen. E B 5 12 8 F A 11 F A D D 17 G C gerichteter, unbewerteter Graph 3 H C 6 8 G 5 ungerichteter, bewerteter Graph H

16 Graphenterminologie In einem Multigraphen können Knoten über mehrere Kanten miteinander verbunden werden. Multigraph

17 Graphenterminologie Ist in einem gerichteten Graphen ein Knoten über eine Kante mit einem anderen Knoten verbunden, so heißt dieser andere Knoten Nachbar des Ausgangsknoten. In ungerichteten Graphen sind zwei Knoten Nachbarn, wenn sie über eine Kante miteinander verbunden sind. Ein Knoten, der keine Nachbarn hat, wird auch isolierter Knoten genannt. Ein Weg innerhalb eines Graphen ist eine Folge von Knoten des Graphen, die sukzessive über eine Kante miteinander verbunden sind. Ein einfacher Weg ist ein Weg, in dem - außer gegebenenfalls Startknoten und Endknoten - kein Knoten mehrfach vorkommt. Ein einfacher Weg heißt Kreis oder Zyklus, wenn der Startknoten des Weges gleichzeitig Endknoten ist.

18 Übungen Aufgabe "Die Leute vom Planeten Chator schreiben gern Schlechtes übereinander. Wer vielen über andere Schlechtes schreibt, gilt als besonders charmant. Aber natürlich nur, wenn die Kompromittierten nichts davon erfahren. Chatonen schreiben nur an Leute, die ihnen sympathisch sind. Doch die können den Tratsch weitertragen, und eventuell genau an den Falschen. Ein Chatone muss also gut aufpassen, dass er keinen Charmefehler macht. Dieses Missgeschick passierte unlängst Ator, als er Btor Schlechtes über Dtor schrieb. Zu dumm: Dtor ist dem Ctor sympathisch, der wiederum Btor sympathisch ist. Und so landete der Tratsch bei Dtor, der über Ator verständlicherweise sehr verärgert war. Dies hätte Ator mit ein wenig Übersicht vermeiden können, denn schließlich wissen alle Chatonen voneinander, wer wem sympathisch ist. " (Quelle: Bundeswettbewerb Informatik 2004/2005 - 1. Runde) (a) Stelle die Sympathiebeziehungen der Chatonen mit einem gerichteten Graphen dar. (b) Welches Problem muss hier gelöst werden. Beschreibe es mit Hilfe der Graphenterminologie.

19 Teil 2 Implementierung von Graphen

20 Graphen als Daten Problem: Wie kann man alle Informationen, die in einem Graph „stecken“, mit Hilfe elementarer Datenstrukturen repräsentieren?

Ansatz: Nachbarschaftstabelle 21 Sämtliche Informationen eines Graphen lassen sich in einer Nachbarschaftstabelle darstellen. Nachbarschaftstabelle Darstellen A B C D A 0 1 0 0 B 0 1 1 1 C 1 1 0 0 D 0 0 0 0 knotenliste = ['A', 'B', 'C', 'D'] kantenmatrix = [[0, 1, 0, 0], [0, 1, 1, 1], [1, 1, 0, 0], [0, 0, 0, 0]] g = (knotenliste, kantenmatrix) Kantenmatrix Adjazenzmatrix

22 Ansatz: Nachbarschaftslisten Sämtliche Informationen eines Graphen lassen sich in einer Nachbarschaftsliste darstellen. Darstellen Nachbarschaftslisten Adjazenzlisten g = [ ['A', ['B', ['C', ['D', ] ['B']], ['B', 'C', 'D']], ['A', 'B']], []] A: B B: B C C: A B D: D

23 Graph-Operationen Aufgabe: Stelle den sich ergebenden Graphen jeweils mit Listen dar. g = [ ['A', ['B']], ['B', 'C', 'D']], ['C', ['A', 'B']], ['D', []] ] # Knoten E hinzufügen g = [ … ] # … Knoten E hinzufügen Kante von E nach A hinzufügen Knoten F hinzufügen Kante von B nach H hinzufügen

24 Graph-Operationen Aufgabe: Stelle den sich ergebenden Graphen jeweils mit Listen dar. g = [ ['A', ['B']], ['B', 'C', 'D']], ['C', ['A', 'B']], ['D', []] ] # Kante von C nach A löschen g = [ … ] # … Kante von C nach A löschen Knoten B löschen Knoten E löschen

25 Graph als Objekt Bei der Implementierung von Graphen ist es günstig, objektorientiert vorzugehen und eine Klasse Graph zu konzipieren, die alle benötigten Operationen bereitstellt.

26 Modellierung der Klasse Graph Ein Objekt der Klasse Graph soll die Knoten und Kanten eines Graphen verwalten. Zum einen soll es geeignete Operationen bereitstellen, um einen Graphen aufzubauen und zu verändern. Mit diesen Operationen soll man z. B. neue Knoten hinzufügen oder bereits vorhandene Knoten entfernen können. Zum anderen soll es Operationen bereitstellen, um an Informationen über den Graphen zu gelangen. So soll man mit einer geeigneten Operation ermitteln können, ob es den Knoten. . . gibt oder ob es eine Kante von Knoten. . . zu Knoten. . . gibt. Aufgabe: Erstelle zunächst eine Liste mit den Operationen, die ein Objekt der Klasse Graph zur Verfügung stellen sollte. Ergänze dann das Klassendiagramm. Beschreibe die gewünschten Operationen möglichst genau.

Implementierung der Klasse Graph 27 Aufgabe: Ergänze die Implementierung der Klasse Graph. Du kannst auch eine Nachbarschaftstabelle zur Repräsentation des Graphen benutzen. Teste natürlich auch deine Implementierung der Klasse Graph. class Graph(object): def __init__(self): self. knoten. Mit. Nachbarn = [] def get. Alle. Knoten(self): knoten. Liste = [] for eintrag in self. knoten. Mit. Nachbarn: knoten. Liste = knoten. Liste + [eintrag[0]] return knoten. Liste def existiert. Knoten(self, name. Knoten): if name. Knoten in self. get. Alle. Knoten(): return True else: return False #. . .

28 Nutzung der Klasse Graph Das Testprogramm unten zeigt, wie man eine (gegebene) Implementierung der Klasse Graph nutzen kann. from graph import * # Erzeugung des Graph-Objekts g = Graph() # Hinzufügen von Knoten und Kanten g. add. Knoten('A') g. add. Knoten('B') g. add. Kante('A', 'B') # Ausgabe der Nachbarschaftslisten for knoten in g. get. Alle. Knoten(): print(knoten, ': ', g. get. Alle. Nachbarn(knoten)) Aufgabe: Nutze die Implementierung der Klasse Graph, um den Graphen in der Abbildung zu erstellen. Nimm anschließend folgende Veränderungen am Graphen vor und kontrolliere die Ergebnisse: (1) Kante von B nach C löschen (2) Kante von C nach B löschen (3) Kante von C nach C hinzufügen (4) Knoten B löschen (5) Knoten C löschen

Erweiterung der Klasse Graph 29 Die Klasse Graph soll um eine Operation erweitert werden, mit der man überprüfen kann, ob es einen Weg von einem vorgegebenen Start- zu einem vorgegebenen Zielknoten gibt. class Graph(object): … def existiert. Weg(self, name. Start. Knoten, name. Ziel. Knoten): … Aufgabe: Implementiere die neue Operation und teste sie am Graph der Chatonen (vgl. Folie 18).

30 Erweiterung der Klasse Graph Erweiterung: Verwaltung zusätzlicher Daten Zunächst einmal sind hier alle Kanten mit Gewichten versehen. Die Zahlen an den Kanten repräsentieren die Entfernung zwischen den Autobahnknotenpunkten. An einer der Kanten ist zusätzlich die Autobahnbezeichnung eingetragen. Auch diese Information ist für praktische Anwendungen oft wichtig. Interessant könnten auch die Geo. Koordinaten von Autobahnknotenpunkten sein. Diese würde man benötigen, wenn eine Darstellung auf einer Landkarte angestrebt würde. An einem der Knoten sind solche zusätzlichen Geo. Informationen eingetragen.

31 Erweiterung der Klasse Graph Erweiterung: Speicherung der Daten in einer externen Datei Die Daten von Graphen werden während der Verarbeitung von einem Objekt der Klasse Graph verwaltet. Nach der Verarbeitung (wenn das Programm beendet ist) wird das Objekt vernichtet. Danach sind sämtliche Daten des verwalteten Graphen nicht mehr zugänglich. Wünschenswert ist eine Möglichkeit, die Daten eines Graphen in einer externen Datei abspeichern zu können und Daten einer externen Datei wieder einlesen zu können. Als externes Speicherformat benutzen wir im Folgenden Graph. ML, ein XMLbasiertes Standardformat zur Repräsentation von Graphen. <? xml version="1. 0" encoding="iso-8859 -1"? > <graph id="bundesautobahnen Lu Ma"> <!--Knoten--> <node id="Kreuz Frankenthal"> <data key="lat">49. 5534891</data> <data key="lon">8. 3199207</data> </node>. . . <!--Kanten--> <edge source="Kreuz Frankenthal" target="Viernheimer Dreieck"> <data key="A">A 6</data> <data key="entfernung">19</data> </edge>. . . </graph>

32 Erweiterung der Klasse Graph Die Klasse Graph wird um geeignete Operationen erweitert.

33 Erweiterung der Klasse Graph Aufgabe Teste die erweiterte Klasse mit den Daten zum Autobahnnetz (siehe inf-schule). Aufgabe Teste die Klasse Graph. Mit. Daten. Erzeuge ein Objekt, mit dem der folgende gewichtete Graph verwaltet wird. Die Daten des Graphen sollen auch in einer externen Datei gespeichert werden.

34 Teil 3 Kürzeste Wege in Graphen

35 Das Problem Viele Wege führen vom Kreuz Frankenthal zum Kreuz Heidelberg. Aber welcher dieser Wege ist der kürzeste? allgemein: Gegeben ist ein (gerichteter oder ungerichtetet, gewichteter) Graph. Gegeben ist zusätzlich ein Start- und ein Zielknoten. Welcher Weg des Graphen vom Startknoten zum Zielknoten ist der kürzeste. Dabei soll die Länge des Weges durch die Summe der Gewichte der Kanten längs des Weges erfasst werden.

36 Ein vereinfachtes Problem Viele Wege führen vom Kreuz Frankenthal zum Kreuz Heidelberg. Aber welcher dieser Wege benötigt die wenigsten "Hops"? allgemein: Gegeben ist ein (gerichteter oder ungerichtetet) Graph. Gegeben ist zusätzlich ein Start- und ein Zielknoten. Welcher Weg des Graphen vom Startknoten zum Zielknoten führt über die geringste Anzahl an Zwischenknoten?

37 Lösung des vereinfachten Problems Im Alltag kommt es gelegentlich vor, dass jemand sagt: "Den kenne ich um mehrere Ecken". Das heißt dann wohl, dass derjenige jemanden kennt, der wiederum jemanden kennt, der. . . Adriana kennt Clara, Erik, Greta Betül kennt Clara, Dominik Clara kennt Adriane, Dominik, Erik Dominik kennt Betül, Erik Ziel ist es, den "Bekanntheitsabstand" von Adriana zu Betül, Clara, Dominik, . . . , Hannah zu bestimmen. Dabei soll direkte Bekanntschaft durch den Bekanntheitsabstand 1 beschrieben werden. Erik kennt Dominik, Greta Fabian kennt Hannah Greta kennt Dominik, Hannah Aufgabe: Versuche (ohne den Bekanntschaftsgraphen zu zeichnen), die gesuchten Bekannheitsabstände systematisch zu ermitteln. Beschreibe dein Vorgehen. Hannah kennt Fabian

38 Lösungsverfahren - Abstand

39 Ein Lösungsverfahren Grün: besucht und noch zu verarbeiten Blau: besucht und erledigt Rot markiert: aktuell ausgewählt # Vorbereitung für alle Knoten knoten des Graphen: knoten. abstand = 'u' start. Knoten. abstand = 0 füge start. Knoten hinten in eine Liste zu. Verarbeiten ein (hier grün)

40 Ein Lösungsverfahren Grün: besucht und noch zu verarbeiten Blau: besucht und erledigt Rot markiert: aktuell ausgewählt # Verarbeitung der Knoten SOLANGE die Liste zu. Verarbeiten nicht leer ist: bestimme ausgewaehlter. Knoten aus zu. Verarbeiten entferne ausgewaehlter. Knoten aus zu. Verarbeiten (hier blau) für alle Nachbarn nachbar. Knoten von ausgewaehlter. Knoten: wenn nachbar. Knoten. abstand == 'u': füge nachbar. Knoten hinten in die Liste zu. Verarbeiten ein nachbar. Knoten. abstand = ausgewaehlter. Knoten. abstand + 1

41 Ein Lösungsverfahren Grün: besucht und noch zu verarbeiten Blau: besucht und erledigt Rot markiert: aktuell ausgewählt # Verarbeitung der Knoten SOLANGE die Liste zu. Verarbeiten nicht leer ist: bestimme ausgewaehlter. Knoten aus zu. Verarbeiten entferne ausgewaehlter. Knoten aus zu. Verarbeiten (hier blau) für alle Nachbarn nachbar. Knoten von ausgewaehlter. Knoten: wenn nachbar. Knoten. abstand == 'u': füge nachbar. Knoten hinten in die Liste zu. Verarbeiten ein nachbar. Knoten. abstand = ausgewaehlter. Knoten. abstand + 1

42 Ein Lösungsverfahren Grün: besucht und noch zu verarbeiten Blau: besucht und erledigt Rot markiert: aktuell ausgewählt # Verarbeitung der Knoten SOLANGE die Liste zu. Verarbeiten nicht leer ist: bestimme ausgewaehlter. Knoten aus zu. Verarbeiten entferne ausgewaehlter. Knoten aus zu. Verarbeiten (hier blau) für alle Nachbarn nachbar. Knoten von ausgewaehlter. Knoten: wenn nachbar. Knoten. abstand == 'u': füge nachbar. Knoten hinten in die Liste zu. Verarbeiten ein nachbar. Knoten. abstand = ausgewaehlter. Knoten. abstand + 1

43 Ein Lösungsverfahren Grün: besucht und noch zu verarbeiten Blau: besucht und erledigt Rot markiert: aktuell ausgewählt # Verarbeitung der Knoten SOLANGE die Liste zu. Verarbeiten nicht leer ist: bestimme ausgewaehlter. Knoten aus zu. Verarbeiten entferne ausgewaehlter. Knoten aus zu. Verarbeiten (hier blau) für alle Nachbarn nachbar. Knoten von ausgewaehlter. Knoten: wenn nachbar. Knoten. abstand == 'u': füge nachbar. Knoten hinten in die Liste zu. Verarbeiten ein nachbar. Knoten. abstand = ausgewaehlter. Knoten. abstand + 1

44 Lösungsverfahren - Abstand / Herkunft

45 Algorithmus von Moore ALGORITHMUS # von Moore Übergabedaten: Graph, start. Knoten, ziel. Knoten # Vorbereitung des Graphen für alle knoten des Graphen: setze abstand auf 'u' setze herkunft auf None setze abstand von start. Knoten. abstand auf 0 füge start. Knoten hinten in eine Liste zu. Verarbeiten ein # Verarbeitung der Knoten SOLANGE die Liste zu. Verarbeiten nicht leer ist: bestimme einen Knoten ausgewaehlter. Knoten aus zu. Verarbeiten (z. B. den ersten in der Liste) entferne ausgewaehlter. Knoten aus zu. Verarbeiten für alle nachbar. Knoten von ausgewaehlter. Knoten: wenn abstand von nachbar. Knoten == 'u': füge nachbar. Knoten hinten in die Liste zu. Verarbeiten ein neuer. Abstand = (abstand von ausgewahlter. Knoten) + 1 setze abstand von nachbar. Knoten auf neuer. Abstand setze herkunft von nachbar. Knoten auf ausgewaehlter. Knoten weglaenge = abstand von ziel. Knoten # Erzeugung des Weges zum ziel. Knoten weg = [] knoten = ziel. Knoten SOLANGE knoten != start. Knoten und herkunft von knoten != None: weg = [(herkunft von knoten, knoten)] + weg knoten = herkunft von knoten Rückgabedaten: (weg, weglaenge)

46 Exkurs "Graph durchlaufen" {Eingabe: Graph G; Startknoten s des Graphen} für alle Knoten w markiere w als nicht besucht füge s in eine (zunächst leere) Datenstruktur D ein solange D nicht leer ist entnimm einen Knoten w aus D für alle Kanten {w, u} falls u nicht markiert ist markiere u füge u in D ein {Ausgabe: Markierungen für alle Knoten w von G; ein Knoten ist genau dann als 'besucht' markiert, wenn er üben einen Weg mit s verbindbar ist} Quelle: http: //www. matheprisma. uni-wuppertal. de/Module/Graphen/index. htm

Beispiel 47 B F D C 0 0 B D C E S A S Vorbereitungsschritt markiere alle Knot. als nicht besucht (hier 0) markiere S als besucht (hier 1) füge s in e. Datenstruktur D (hier grün) ein 0 B F D C 1 0 0 A 0 0 1 entnimm einen Knoten w (hier blau) aus D für alle Kanten {w, u} falls u nicht markiert ist markiere u füge u in D ein Wiederholungsschritt 0 1 B F D C E S 0 E 0 F 0 E A S 0 1 1 A 0 0

Beispiel 48 0 1 B F D C 0 0 0 1 B D C E S 1 A S 0 1 Auswahlstrategie First In First Out -> Breitensuche 1 B F D C 1 1 B D 1 1 B A S 0 1 F D C S 0 1 1 Auswahlstrategie Last In First Out -> Tiefensuche 1 0 1 B F D C E A 0 E 1 0 0 F C entnimm einen Knoten w (hier blau) aus D für alle Kanten {w, u} falls u nicht markiert ist markiere u füge u in D ein E S 0 0 E 1 0 F 1 E A S 1 1 1 A 1 0

Beispiel 49 1 1 B F D C 1 0 1 1 B D C E S F 0 1 E 1 1 A S 1 1 A 1 1 entnimm einen Knoten w (hier blau) aus D für alle Kanten {w, u} falls u nicht markiert ist markiere u füge u in D ein 1 1 B F D C 1 1 0 1 1 1 F D C E S B Ergebnis: Von S aus gibt es Wege zu den folgenden Knoten: A, B, C, D, E. 1 E A S 1 1 1 A 1 0

50 Das verallgemeinerte Problem Gegeben ist ein (gerichteter oder ungerichtetet, gewichteter) Graph. Gegeben ist zusätzlich ein Startknoten (z. B. A) und ein Zielknoten (z. B. C). Welcher Weg des Graphen vom Startknoten zum Zielknoten ist der kürzeste. Dabei soll die Länge des Weges durch die Summe der Gewichte der Kanten längs des Weges erfasst werden.

51 Lösungsverfahren Aufgabe: Benutze das Simulationsprogramm "Shortest Path Animation", um die Grundidee des Lösungsverfahrens von Dijkstra herauszufinden.

52 Lösungsverfahren - Abstand / Herkunft

53 Ein Lösungsverfahren # Verarbeitung der Knoten SOLANGE die Liste zu. Verarbeiten nicht leer ist: bestimme e. Knoten min. Knoten a. zu. Verarbeiten mit min. Abstand entferne min. Knoten aus zu. Verarbeiten (hier blau) für alle Nachbarn nachbar. Knoten von min. Knoten: wenn nachbar. Knoten. abstand == 'u': füge nachbar. Knoten in zu. Verarbeiten ein nachbar. Knoten. abstand = min. Knoten. abstand+gewicht((minknoten, nachbar. Knoten)) nachbar. Knoten. herkunft = min. Knoten sonst: wenn nachbar. Knoten in zu. Verarbeiten liegt: wenn min. Knoten. abstand+ gewicht((minknoten, nachbar. Knoten)) < nachbar. Knoten. abstand: aktualisiere nachbar. Knoten. abstand aktualisiere nachbar. Knoten. herkunft

54 Algorithmus von Dijkstra Übergabedaten: Graph, start. Knoten, ziel. Knoten # Vorbereitung des Graphen für alle knoten des Graphen: setze abstand auf 'u' setze herkunft auf None setze abstand von start. Knoten. abstand auf 0 füge start. Knoten in eine Liste zu. Verarbeiten ein # Verarbeitung der Knoten SOLANGE die Liste zu. Verarbeiten nicht leer ist: bestimme einen Knoten min. Knoten aus zu. Verarbeiten mit minimalem Abstand entferne min. Knoten aus zu. Verarbeiten für alle nachbar. Knoten von min. Knoten: gewicht = Gewicht der Kante von min. Knoten zu nachbar. Knoten neuer. Abstand = (abstand von min. Knoten) + gewicht WENN abstand von nachbar. Knoten == 'u': füge nachbar. Knoten in die Liste zu. Verarbeiten ein (z. B. am Listenende) setze abstand von nachbar. Knoten auf neuer. Abstand setze herkunft von nachbar. Knoten auf min. Knoten SONST: WENN nachbar. Knoten in zu. Verarbeiten liegt: WENN abstand von nachbar. Knoten > neuer. Abstand: setze abstand von nachbar. Knoten auf neuer. Abstand setze herkunft von nachbar. Knoten auf min. Knoten weglaenge = abstand von ziel. Knoten # Erzeugung des Weges zum ziel. Knoten weg = [] knoten = ziel. Knoten SOLANGE knoten != start. Knoten und herkunft von knoten != None: weg = [(herkunft von knoten, knoten)] + weg knoten = herkunft von knoten # Rückgabedaten: (weg, weglaenge)

55 Implementierung des Moore-Alg. Aufgabe: Die folgende Implementierung dieses Algorithmus beruht auf einer Darstellung von Graphen mit Nachbarschaftlisten. Sie benutzt eine Reihe von Hilfsfunktionen (siehe inf-schule). Teste zunächst die Hilfsfunktionen. Was leisten sie jeweils? def existiert. Knoten(graph, knoten): #. . . def get. Alle. Knoten(graph): #. . . def get. Alle. Nachbarn(graph, knoten): #. . . def get. Abstand(erweiterter. Graph, knoten): #. . . def get. Herkunft(erweiterter. Graph, knoten): #. . . def set. Abstand(erweiterter. Graph, knoten, wert): #. . . def set. Herkunft(erweiterter. Graph, knoten, wert): #. . . def init. Erweiterter. Graph(graph, start. Knoten): #. . .

56 Implementierung des Moore-Alg. def kuerzester. Weg. Moore(graph, start. Knoten, ziel. Knoten): if existiert. Knoten(graph, start. Knoten) and existiert. Knoten(graph, ziel. Knoten): # Vorbereitung erweiterter. Graph = init. Erweiterter. Graph(graph, start. Knoten) zu. Verarbeiten = [start. Knoten] # Verarbeitung der Knoten while zu. Verarbeiten != []: # bestimme einen Knoten ausgewaehlter. Knoten aus zu. Verarbeiten ausgewaehlter. Knoten = zu. Verarbeiten[0] # entferne ausgewaehlter. Knoten aus zu. Verarbeiten = zu. Verarbeiten[1: ] # bearbeite die Nachbarn von ausgewaehlter. Knoten for nachbar. Knoten in get. Alle. Nachbarn(graph, ausgewaehlter. Knoten): if get. Abstand(erweiterter. Graph, nachbar. Knoten) == 'u': zu. Verarbeiten = zu. Verarbeiten + [nachbar. Knoten] neuer. Abstand = get. Abstand(erweiterter. Graph, ausgewaehlter. Knoten)+ 1 erweiterter. Graph = set. Abstand(erweiterter. Graph, nachbar. Knoten, neuer. Abstand) erweiterter. Graph = set. Herkunft(erweiterter. Graph, nachbar. Knoten, ausgewaehlter. Knoten) weglaenge = get. Abstand(erweiterter. Graph, ziel. Knoten) # Erzeugung des Weges zum ziel. Knoten weg = [] knoten = ziel. Knoten while knoten != start. Knoten and get. Herkunft(erweiterter. Graph, knoten) != None: weg = [(get. Herkunft(erweiterter. Graph, knoten)] + weg knoten = get. Herkunft(erweiterter. Graph, knoten) else: weg = [] weglaenge = 'u' return (weg, weglaenge)

57 Implementierung des Moore-Alg. # Erzeugung des Testgraphen testgraph_ohne_gewichte = [ ['A', ['C', 'E', 'G']], ['B', ['C', 'D']], ['C', ['A', 'D', 'E']], ['D', ['B', 'E']], ['E', ['D', 'G']], ['F', ['B', 'D', 'H']], ['G', ['D']], ['H', ['F', 'G']] ] # Test des Moore-Algorithmus start = 'A' ziel = 'B' print('kürzester Weg von', start, 'nach', ziel, ': ') (weg, laenge) = kuerzester. Weg. Moore(testgraph_ohne_gewichte, start, ziel) for w in weg: print(w) print('Weglänge: ', laenge) Aufgabe: Ergänze Ausgaben in der Funktion kuerzester. Weg. Moore so, dass die Verarbeitung des Graphen Schritt für Schritt (wie in den Abbildungen zum Algorithmus von Moore ) nachvollzogen werden kann. Führe auch weitere Tests der Funktion kuerzester. Weg. Moore aus.

58 Implementierung des Moore-Alg. Aufgabe: Eine weitere Implementierung des Algorithmus von Moore findest du in der Klasse Graph. Moore (siehe inf-schule). Objekte der Klasse Graph. Moore stellen die Operation kuerzester. Weg. Moore zur Verfügung, mit der man Wege mit geringster Anzahl von Zwischenknoten in Graphen bestimmen kann. Teste auch diese Implementierung. from graph_moore import * # Erzeugung des Graph-Objekts g = Graph. Moore() # Erzeugung der Knoten und Kanten aus einer Graph. ML-Datei datei = open("graph_ohne_gewichte. xml", "r") xml_quelltext = datei. read() g. graphml. To. Graph(xml_quelltext) # Kontrollausgabe des Graphen print('Graph: ') for knoten in g. get. Alle. Knoten(): print(knoten, ': ', g. get. Alle. Nachbarn(knoten)) print() # Test des Moore-Algorithmus start = 'A' ziel = 'B' print('kürzester Weg von', start, 'nach', ziel, ': ') (weg, laenge) = g. kuerzester. Weg. Moore(start, ziel) for w in weg: print(w) print('Weglänge: ', laenge)

59 Implementierung des Dijkstra-Alg. Aufgabe: Mit den Hilfsfunktionen init. Erweiterter. Graph, get. Abstand, get. Herkunft, set. Abstand, set. Herkunft, . . . lässt sich auch der Algorithmus von Dijkstra implementieren. Du kannst dich an der Implementierung des Algorithmus von Moore orientieren. Zum Testen kannst du das folgende Testprogramm nutzen und variieren. # Erzeugung des Testgraphen testgraph_mit_gewichten = [ ['A', [('C', 20), ('E', 2), ('G', 9)]], ['B', [('C', 1), ('D', 8)]], ['C', [('A', 20), ('D', 10), ('E', 13)]], ['D', [('B', 8), ('E', 16)]], ['E', [('D', 16), ('G', 5)]], ['F', [('B', 3), ('D', 4), ('H', 5)]], ['G', [('D', 2)]], ['H', [('F', 5), ('G', 7)]] ] # Test des Dijkstra-Algorithmus start = 'A' ziel = 'B' print('kürzester Weg von', start, 'nach', ziel, ': ') (weg, laenge) = kuerzester. Weg. Dijkstra(testgraph_mit_gewichten, start, ziel) for w in weg: print(w) print('Weglänge: ', laenge)

60 Implementierung des Dijkstra-Alg. Aufgabe: Eine weitere Implementierung des Algorithmus von Dijkstra findest du in der Klasse Graph. Dijkstra (siehe inf-schule). Objekte der Klasse Graph. Dijkstra stellen die Operation kuerzester. Weg. Dijkstra zur Verfügung, mit der man kürzeste Wege in gewichteten Graphen bestimmen kann. Teste auch diese Implementierung. from graph_dijkstra import * # Erzeugung des Graph-Objekts g = Graph. Dijkstra() # Erzeugung der Knoten und Kanten aus einer Graph. ML-Datei datei = open("graph_mit_gewichten. xml", "r") xml_quelltext = datei. read() g. graphml. To. Graph(xml_quelltext) # Kontrollausgabe des Graphen print('Graph: ') for knoten in g. get. Alle. Knoten(): print(knoten, ': ', g. get. Alle. Nachbarn(knoten)) print() # Test des Dijkstra-Algorithmus start = 'A' ziel = 'B' print('kürzester Weg von', start, 'nach', ziel, ': ') (weg, laenge) = g. kuerzester. Weg. Dijkstra(start, ziel) for w in weg: print(w) print('Weglänge: ', laenge)

61 Routenplanung mit dem Dijkstra-Alg. Aufgabe: Zunächst betrachten wir das vereinfachte Autobahnnetz rund um Ludwigshafen und Mannheim. Benutze die Implementierung des Algorithmus von Dijkstra, um den kürzesten Weg vom Kreuz Frankenthal zum Kreuz Heidelberg zu ermitteln. Die Daten zum Autobahnnetz findest du in der Datei graph_bab_lu_ma. xml (siehe inf-schule).

62 Routenplanung mit dem Dijkstra-Alg. Aufgabe: Benutze die Daten zum Autobahnnetz in Deutschland, um den kürzesten Weg vom 'KREUZ FRANKENTHAL' zum 'KREUZ HEIDELBERG' bzw. von 'TRIER - VERTEILERKREIS (A 602)' nach 'KREUZ MÜNCHEN - WEST' zu bestimmen. Vergleiche die Ergebnisse auch mit denen, die ein professioneller Routenplaner liefert. Die Daten zum Autobahnnetz findest du in der Datei graph_bab. xml (siehe infschule). Quelle: http: //de. wikipedia. org/wiki/Autobahn_%28 Deutschland%29 Autor der Karte: M. Stadthaus

63 Routenplanung mit dem Dijkstra-Alg. Aufgabe: Teste auch die GUI-Version des Routenplanerprogramms (siehe infschule). Vergleiche auch die vom Simulationsprogramm gelieferten Daten auch mit den Ergebnissen realer Routenplaner.

64 Routenplanung mit dem Dijkstra-Alg. Aufgabe: Die Bestimmung kürzester Wege mit dem Algorithmus von Dijstra in der bisher gezeigten Form dauert bei einer großen Datebasis sehr lange. Woran liegt das? Entwickle Ideen, wie man den Suchaufwand verringern könnte. Versuche eventuell auch, diese Ideen umzusetzen.

65 Routenplanung mit dem Dijkstra-Alg. Aufgabe: Die Aufbereitung der Ergebnisse (Auflistung der Stationen der Route) kann ebenfalls noch verbessert werden. ('TRIER - VERTEILERKREIS (A 602)', 'TRIER - EHRANG (A 602)') ('A 602', 5. 0) ('TRIER - EHRANG (A 602)', 'TRIER - RUWER (A 602)') ('A 602', 2. 0) ('TRIER - RUWER (A 602)', 'SCHWEICH (A 602)') ('A 602', 2. 0) ('SCHWEICH (A 602)', 'DREIECK MOSELTAL') ('A 602', 1. 0) ('DREIECK MOSELTAL', 'MEHRING (A 1)') ('A 1', 8. 0) ('MEHRING (A 1)', 'REINSFELD (A 1)') ('A 1', 14. 0) ('REINSFELD (A 1)', 'HERMESKEIL (A 1)') ('A 1', 2. 0) ('HERMESKEIL (A 1)', 'BIERFELD (A 1)') ('A 1', 7. 0) ('BIERFELD (A 1)', 'DREIECK NONNWEILER') ('A 1', 2. 0) ('DREIECK NONNWEILER', 'OTZENHAUSEN (A 62)') ('A 62', 0. 3) ('OTZENHAUSEN (A 62)', 'NOHFELDEN - TÜRKISMÜHLE (A 62)') ('A 62', 8. 0) ('NOHFELDEN - TÜRKISMÜHLE (A 62)', 'BIRKENFELD (A 62)') ('A 62', 6. 0) ('BIRKENFELD (A 62)', 'FREISEN (A 62)') ('A 62', 9. 0) ('FREISEN (A 62)', 'REICHWEILER (A 62)') ('A 62', 4. 0) ('REICHWEILER (A 62)', 'KUSEL (A 62)') ('A 62', 7. 0) ('KUSEL (A 62)', 'GLAN - MÜNCHWEILER (A 62)') ('A 62', 9. 0) ('GLAN - MÜNCHWEILER (A 62)', 'HÜTSCHENHAUSEN (A 62)') ('A 62', 6. 0) ('HÜTSCHENHAUSEN (A 62)', 'KREUZ LANDSTUHL - WEST') ('A 62', 3. 0). . .

66 Teil 4 Rundreisen in Graphen

67 Das Problem Wenn ein neuer Außenminister im Amt ist, dann versucht er (oder sie), möglichst rasch Antrittsbesuche bei den wichtigsten Bündnispartnern zu machen. Zu diesen Partner gehören natürlich auch die Länder Europäischen Union (EU). Wir werden hier folgende Situation durchspielen: Nach einer Bundestagswahl soll der neue Außenminister alle Hauptstädte der EU besuchen. Die Reihenfolge soll sich nicht nach der Bedeutung der Länder oder anderen Kriterien richten. Sie soll so gewählt werden, dass der gesamte Reiseweg für den Minister möglichst gering wird.

Das Problem 68 Als Willy Brand 1966 Außenminister wurde, bestand die EU (damals EWG) aus nur 6 Ländern: Deutschland, Frankreich, Italien, Niederlande, Belgien und Luxemburg. Die Tabelle zeigt die Entfernungen der jeweiligen Hauptstädte. Bonn 0 Paris 401 Rom 1066 Den Ha. 245 Brüssel 195 Luxemb. 145 Paris 401 0 1108 383 262 287 Rom 1066 1108 0 1289 1174 989 Den Ha. 244 383 1289 0 137 302 Brüssel 195 262 1174 137 0 187 Luxemb. 145 287 989 302 187 0 Aufgabe: Versuche, eine möglichst kurze Rundreise mit Start- und Zielort Bonn zu finden. Bestimme auch die Gesamtlänge der Rundreise.

69 Das Problem Die EU (bzw. EWG bzw. EG) ist seit ihrer Gründung 1957 mehrfach erweitert worden. Zu Beginn bestand sie aus 6 Mitgliedsstaaten. Diese 6 -er-Gemeinschaft ist 1973 zu einer 9 -er. Gemeinschaft, 1981 bis 1986 zu einer 12 -er-Gemeinschaft, 1995 zu einer 15 -er-Gemeinschaft, 2004 zu einer 25 -er-Gemeinschaft und 2007 zu einer 27 -er-Gemeinschaft gewachsen. Weitere Staaten warten auf den baldigen Beitritt zu dieser Gemeinschaft. Aufgabe: Welche Schwierigkeiten sind bei der Bestimmung der kürzesten Rundreise zu erwarten?

70 Ein einfacher Lösungsalgorithmus Idee: Erzeuge alle möglichen Rundreisen und bestimme jeweils die Länge der Rundreise. Ermittle aus den erzeugten Längenwerten die optimale Route. Aufgabe: Teste das beschriebene Verfahren mit dem Simulationsprogramm (siehe inf-schule) und bestimme den kürzesten Rundweg bei den vorgegebenen Hauptstädten.

71 Ein einfacher Lösungsalgorithmus Idee: Erzeuge alle möglichen Rundreisen und bestimme jeweils die Länge der Rundreise. Ermittle aus den erzeugten Längenwerten die optimale Route. ALGORITHMUS Rundreise start. Route. Ohne. Start. Knoten = Liste aller Knotennamen ohne den start. Knoten start. Route = [start. Knoten] + start. Route. Ohne. Start. Knoten + [start. Knoten] route. Ohne. Start. Knoten = Kopie von start. Route. Ohne. Start. Knoten route = start. Route min. Laenge = Länge von route min. Route = route ende. Permutationen = False while not ende. Permutationen: route. Ohne. Start. Knoten = naechste_permutation(route. Ohne. Start. Knoten) route = [start. Knoten] + route. Ohne. Start. Knoten + [start. Knoten] if self. laenge(route) < min. Laenge: min. Laenge = self. laenge(route) min. Route = route ende. Permutationen = (route. Ohne. Start. Knoten == start. Route. Ohne. Start. Knoten)

72 Erzeugung von Permutationen def naechste_permutation(L): # best. max. Index i mit L[i] < L[i+1] i = len(L)-2 gefunden = False while not gefunden: if i < 0: gefunden = True else: if L[i] < L[i+1]: gefunden = True else: i = i-1 if i >= 0: # best. max. Index j mit L[j] > L[i] j = i+1 m = j while j < len(L)-1: j = j+1 if L[j] > L[i]: m = j j = m. . . # vertausche L[i] und L[j] h = L[i] = L[j] = h # kehre Restliste ab Position i+1 um i = i+1 j = len(L)-1 while i < j: h = L[i] = L[j] = h i = i+1 j = j-1 else: # Liste ist absteigend sortiert # kehre Liste um i = 0 j = len(L)-1 while i < j: h = L[i] = L[j] = h i = i+1 j = j-1 return L

73 Erzeugung von Permutationen Aufgabe: Teste die Funktion naechste_permutation durch Funktionsaufrufe wie die folgenden. Versuche auch zu verstehen, wie die jeweils nächste Permutation gebildet wird. >>> naechste_permutation(['A', 'B', 'C', 'D', 'E']) ['A', 'B', 'C', 'E', 'D'] >>> naechste_permutation(['A', 'B', 'C', 'E', 'D']) ['A', 'B', 'D', 'C', 'E'] Aufgabe: Entwickle ein Testprogramm, mit dem man ermitteln kann, wie viele verschiedene Permutationen bei einer Liste mit 5 (bzw. 6, . . . ) verschiedenen Elementen möglich sind.

74 Suche nach der kürzesten Rundreisen from graph import * def naechste_permutation(L): # siehe oben def laenge(g, rundreise): weglaenge = 0 anzahl. Knoten = len(rundreise) i = 1 while i < anzahl. Knoten: weglaenge = weglaenge + float(g. get. Gewicht. Kante(rundreise[i-1], rundreise[i])) i = i+1 return weglaenge def min. Rundreise(g, start. Knoten): # siehe nächste Seite # Erzeugung des Graph-Objekts g = Graph. Mit. Daten() # Erzeugung der Knoten und Kanten aus einer Graph. ML-Datei datei = open("graph_eu_6. xml", "r") xml_quelltext = datei. read() g. graphml. To. Graph(xml_quelltext) # Test des Rundreise-Algorithmus (min. Route, min. Laenge) = min. Rundreise(g, 'Bonn') print('Route: ', min. Route) print('Länge: ', min. Laenge)

75 Suche nach der kürzesten Rundreisen def min. Rundreise(g, start. Knoten): start. Route. Ohne. Start. Knoten = [] for knoten in g. get. Alle. Knoten(): if knoten != start. Knoten: start. Route. Ohne. Start. Knoten = start. Route. Ohne. Start. Knoten + [knoten] start. Route = [start. Knoten] + start. Route. Ohne. Start. Knoten + [start. Knoten] route. Ohne. Start. Knoten = start. Route. Ohne. Start. Knoten[: ] route = start. Route min. Laenge = laenge(g, route) min. Route = route ende. Permutationen = False while not ende. Permutationen: route. Ohne. Start. Knoten = naechste_permutation(route. Ohne. Start. Knoten) route = [start. Knoten] + route. Ohne. Start. Knoten + [start. Knoten] if laenge(g, route) < min. Laenge: min. Laenge = laenge(g, route) min. Route = route ende. Permutationen = (route. Ohne. Start. Knoten == start. Route. Ohne. Start. Knoten) return (min. Route, min. Laenge) Aufgabe: Führe das Testprogramm aus. Ändere es auch wie folgt ab: Es sollen alle erzeugten Routen mit ihren Längen ausgegeben werden. Es soll zusätzlich mitgezählt werden, wie viele Routen erzeugt werden (zur Kontrolle: 120). Bevor du anfängst, bei 27 (bzw. 25) Hauptstädten alle Rundreisen zu erzeugen, berechne erst einmal, wie viele das sind.

76 Aufwandsanalyse Die Problemgröße wird durch die Anzahl n der Mitgliedsländer EU (Knoten des Graphen) festgelegt. Je größer n ist, desto größer ist auch der Aufwand zur Berechnung der Problemlösung. Als Kostenmaß für den Berechnungsaufwand wählen wir die Anzahl der zu erzeugenden und verarbeitenden Rundreisen R(n). Wir gehen dabei davon aus, dass jede zu erzeugende und verarbeitende Rundreise in etwa den gleichen Berechnungsaufwand hat. Für R(n) kann man einen recht einfachen Berechnungsterm entwickeln: Bei n Knoten gibt es vom Startknoten aus n-1 Möglichkeiten, den nächsten Knoten zu wählen. Von jedem dieser n-1 Knoten gibt es dann noch n-2 Möglichkeiten, den nächsten Knoten zu wählen, usw. . Insgesamt erhält man die folgende Formel: R(n) = (n-1)*(n-2)*. . . *2*1 = (n-1)! 0 ! = 1 1 ! = 1 2 ! = 2 3 ! = 6 4 ! = 24 5 ! = 120 6 ! = 720 7 ! = 5040 8 ! = 40320 9 ! = 362880 10 ! = 3628800 11 ! = 39916800 12 ! = 479001600 13 ! = 6227020800 14 ! = 87178291200 15 ! = 1307674368000 16 ! = 20922789888000 17 ! = 355687428096000 18 ! = 6402373705728000 19 ! = 121645100408832000 20 ! = 2432902008176640000 21 ! = 51090942171709440000 22 ! = 1124000727777607680000 23 ! = 25852016738884976640000 24 ! = 620448401733239439360000 25 ! = 15511210043330985984000000

77 Anwendbarkeit des Algorithmus Aufgabe: Man kann recht einfach ermitteln, wie lange ein Rechner zur Erzeugung und Verarbeitung einer Rundreise benötigt: Ergänze hierzu einen Zähler und eine Ausgabe des Zählers nach z. B. 1000 oder 100000 Zählschritten. Aus der grob gemessenen Zeit kann man dann die gesuchte Zeit abschätzen. Wir gehen im folgenden davon aus, dass man für 1000 Rundreisen etwa 1 Sekunde benötigt. Schätze mit den oben gezeigten Daten ab, wie lange es dauert, bis die kürzeste Rundreise mit dem vorliegenden Algorithmus bei 25 Knoten gefunden ist. Beurteile mit dem Ergebnis die praktische Anwendbarkeit des Algorithmus. 0 ! = 1 1 ! = 1 2 ! = 2 3 ! = 6 4 ! = 24 5 ! = 120 6 ! = 720 7 ! = 5040 8 ! = 40320 9 ! = 362880 10 ! = 3628800 11 ! = 39916800 12 ! = 479001600 13 ! = 6227020800 14 ! = 87178291200 15 ! = 1307674368000 16 ! = 20922789888000 17 ! = 355687428096000 18 ! = 6402373705728000 19 ! = 121645100408832000 20 ! = 2432902008176640000 21 ! = 51090942171709440000 22 ! = 1124000727777607680000 23 ! = 25852016738884976640000 24 ! = 620448401733239439360000 25 ! = 15511210043330985984000000

78 Aufgabe: Überlege dir eine Strategie, wie man "mit Köpfchen" statt der "Holzhammermethode" bei der Suche nach der kürzesten Rundreise vorgehen könnte. Näherungsverfahren

79 Stategie: zum am nächst lieg. Knoten Aufgabe: Eine naheliegende Strategie besteht darin, vom jeweils aktuellen Knoten zum am nächst liegenden Knoten zu gehen. Die Abbildung zeigt die Route, die nach der Strategie "zum am nächst liegenden Knoten" berechnet wurde. Versuche, die Route / Strategie zu bewerten: Gibt es kürzere Routen? Welche Nachteile hat die Strategie?

80 Stategie: Integration entfernter Knoten In einem ersten Schritt wird die Stadt gesucht, die am weitesten von Berlin entfernt ist. Im vorliegenden Fall ist es die Hauptstadt Nikosia von Zypern. Das Rundreisegerüst besteht jetzt aus Berlin - Nikosia - Berlin.

81 Stategie: Integration entfernter Knoten In einem nächsten Schritt wird die Stadt gesucht, die zu den Knoten des aktuellen Rundreisegerüsts den größten Abstand hat. Im vorliegenden Fall ist es die Hauptstadt Lissabon von Portugal. Diese Stadt wird jetzt so in das Rundreisengerüst eingebaut, dass das neue Rundreisegerüst eine möglichst geringe Länge hat. Es ergibt sich Berlin - Nikosia - Lissabon - Berlin.

82 Stategie: Integration entfernter Knoten Es wird die Stadt gesucht, die zu den Knoten des aktuellen Rundreisegerüsts den größten Abstand hat. Im vorliegenden Fall ist es Dublin, die Hauptstadt von Irland. Diese Stadt wird jetzt so in das Rundreisengerüst eingebaut, dass das neue Rundreisegerüst eine möglichst geringe Länge hat. Es ergibt sich Berlin - Nikosia - Valetta - Lissabon - Dublin - Berlin.

83 Stategie: Integration entfernter Knoten Wenn man auf diese Weise weiterverfährt, ergibt sich insgesamt die folgende Rundreise. Aufgabe: Vergleiche das Ergebnis der Stategie "Integration der am weitesten entfernten Knoten" mit dem Ergebnis der Strategie "zum am nächst liegenden Knoten". Kann man mit Sicherheit behaupten, dass die Strategie "Integration der am weitesten entfernten Knoten" die kürzeste Rundreise liefert?

84 Näherungslösungen statt exakter Lös. Bei 27 Hauptstädten ist es unmöglich, die exakte Lösung nach der Holzhammer-Methode in der zur Verfügung stehenden Zeit zu bestimmen. In vertretbarem Aufwand (mehrere Stunden) geht das noch bei 12 Hauptstädten. Hier ist dann ein Vergleich der exakten Lösung mit Näherungslösungen möglich. Methode: zum am nächst lieg. Knoten Methode: Integration entfernter Knoten Methode: Erzeugung aller Rundreisen Länge der Rundreise: 10444. 6 Länge der Rundreise: 9012. 6 Länge der Rundreise: 8945. 1

85 Literaturhinweise U. Schöning: Ideen der Informatik. Oldenbourg Verlag 2002. P. Gritzmann, R. Brandenburg: Das Geheimnis des kürzesten Weges. Springer 2002. Mathe-Prisma: Graphen http: //www. matheprisma. uni-wuppertal. de/Module/Graphen/index. htm D. Jonietz: Graphen http: //informatik. bildung-rp. de/fileadmin/user_upload/informatik. bildungrp. de/Weiterbildung/pdf/WB-VIII-6 -Graphen. pdf. . . Die Darstellung hier orientiert sich an den Materialien auf den Webseiten: http: //www. inf-schule. dew/