Tiefensuche (Depth-First Search) Robert Hilbrich

Transkript

1 Tiefensuche (Depth-First Search) Robert Hilbrich

2 Gliederung. Einführung. Tiefensuche, der Algorithmus. Modellierung der Arbeitsumgebung. Programmablauf. Korrektheit. Partielle Korrektheit. Totale Korrektheit. Einordnung der Tiefensuche

3 . Einführung Adventure: Indiana Jones and the Fate of Atlantis (Fiktive) Spielsituation: Indy gerät in ein Labyrinth sucht Ausgang (z.b. Sophia) Verfügbare Gegenstände: Peitsche Revolver (beliebig lange) rote Schnur Wie geht Indy möglichst systematisch vor?

4 . Einführung Indiana Jones And The Fate of Atlantis systematische Vorgehensweise: roten Faden spannen bereits gesehene Wege markieren Wenn Sackgasse zurück zur letzten ungesehenen Gabelung Vermeidung doppelter Wege

5 . Einführung Heutige Bedeutung in der Informatik abstrakt: bekanntes Suchverfahren für Graphenprobleme z.b.: Ist der Graph verbunden? Wenn nicht, was sind die Zusammenhangskomponenten? Existiert ein Kreisschluss im Graphen? konkret: Routenplaner Roboter Steuerungslogik Spiele Logik Prolog

6 . Tiefensuche, der Algorithmus

7 . Modellierung der Arbeitsumgebung Tiefensuche arbeitet mit Graphen Sei ein (ungerichteter) Graph G mit V Knoten und E Kanten gegeben alle Knoten seien eindeutig nummeriert (,,,...) Modellierung von G:. Knoteninformationen. Kanteninformationen

8 . Modellierung der Arbeitsumgebung. Feld der Länge V (=maxv) für die Knoten VAR val: array[..maxv-]of Integer; Index = Knotennummer in G Eintrag = Markierung des Knoten, durch: i-te Knoten noch nicht besucht : val[i] = j-te Knoten schon besucht : val[j] >

9 . Modellierung der Arbeitsumgebung. Adjazenzliste zur Speicherung der Kanten Array der Länge v von einfach verketteten Listen Index des Array = Knotennummer Listen Elemente = direkte Nachbarn im Graphen Array Listen Graph 9

10 . Programmablauf Tiefensuche der Algorithmus PROGRAM tiefensuche; VAR id, k : INTEGER; val : array [..V-] of INTEGER; PROCEDURE visit(k : INTEGER); VAR t : Zeiger; BEGIN id := id+; val[k] := id; t := adj[k]; WHILE t!= NULL DO BEGIN IF val[t^.v] = THEN visit(t^.v); t := t^.next; END; END; BEGIN { HAUPTPROGRAMM } id := ; FOR k := TO (V-) DO val[k] := ; FOR k := TO (V-) DO IF val[k] = THEN visit(k); END;

11 . Programmablauf Tiefensuche der Algorithmus PROGRAM tiefensuche; VAR id, k : INTEGER; val : array [..V-] of INTEGER; PROCEDURE visit(k : INTEGER); VAR t : Zeiger; BEGIN id := id+; val[k] := id; t := adj[k]; WHILE t!= NULL DO BEGIN IF val[t^.v] = THEN visit(t^.v); t := t^.next; END; END; BEGIN id := ; FOR k := TO (V-) DO val[k] := ; FOR k := TO (V-) DO IF val[k] = THEN visit(k); END; id : entdeckte Knoten k : aktueller Knoten visit: sucht rekursiv alle Knoten einer Zusammenhangskomponent t: Zeiger auf Nachbarknoten von k val[k]: Eintrag im Knotenfeld (Markierung) adj[k]: Adjazenzliste (Nachfolger)

12 . Programmablauf Beispiel: Graph G und zugehörige Adjazenzliste

13 . Programmablauf Initialisierung Graph G, Adjazenzliste und val[..maxv-] Feld FOR k := TO V- DO val[k] := ; Graph Index Index Eintrag val[k] Adjazenzliste

14 . Programmablauf Start im Hauptprogramm FOR k := TO V- DO IF val[k] = THEN visit(k);

15 . Programmablauf visit() visit()

16 . Programmablauf visit() check()

17 . Programmablauf visit() visit()

18 . Programmablauf visit() check()

19 9. Programmablauf visit() visit()

20 . Programmablauf visit() check()

21 . Programmablauf visit() visit()

22 . Programmablauf visit() check()

23 . Programmablauf visit() visit()

24 . Programmablauf visit() check()

25 . Programmablauf Hauptprogramm visit()

26 . Programmablauf visit() visit()

27 . Programmablauf visit() check()

28 . Programmablauf visit() visit()

29 9. Programmablauf visit() check() 9

30 . Programmablauf Ende der FOR Schleife, da k = V FOR k := TO (V-) DO IF val[k] = THEN visit(k); 9

31 . Programmablauf Zusammenfassung Tiefensuche durchsucht Graphen Stack (Rekursion) Backtracking TS stößt immer zuerst in die maximale Tiefe vor

32 . Korrektheit

33 . Partielle Korrektheit Partielle Korrektheit mit Hoare Kalkül sehr umfangreich ( A Seiten) langwierig sich wiederholend monoton Beschränkung auf Interessantes Anfangs- und Endbedingungen Schleifeninvarianten Rekursion

34 . Partielle Korrektheit Hoare Kalkül und Nassi-Schneidermann Diagramme { P } Anweisung { Q } { I } B { I und B} Anweisung Anweisung { I } { I und nicht (B) }

35 . Partielle Korrektheit Anfangs- und Endbedingungen V = Anzahl aller Knoten im Graphen V = Anzahl aller markierten Knoten im Graphen V = Anzahl aller nicht markierten Knoten in der aktuellen Zusammenhangskomponente (ZK) V = Anzahl aller nicht markierten Knoten, die nicht in der aktuellen ZK sind k = aktueller Knoten { P } V=V+V+V und V> Hauptprogramm { Q } V=V und V= und V= und k=v

36 . Partielle Korrektheit Anfangs- und Endbedingungen val[k] = : unbesichtigter Knoten t^.v : Nachbarknoten von k in Adjazenzliste (t^.next).v : NachbarNachbarknoten von k in Adjazenzliste P: val[k] = PROCEDURE visit(k) Q: nicht(val[k] = ) und nicht(val[t^.v] = ) und nicht(val[(t^.next)^.v] = ) und nicht...

37 . Partielle Korrektheit Invarianten im Hauptprogramm (FOR Schleifen durch WHILE ersetzt) FOR k := TO (V-) DO IF val[k] = THEN visit(k); { I }: V = V + V + V und V-k >= Wiederhole, solange wie k <= V { I } V = V + V + V und { B } k <= V Anweisung(en) { I } V = V + V + V und V - k >= { I } V = V + V + V und V-k >= und nicht (k <= V)

38 Invarianten in VISIT. Partielle Korrektheit WHILE t!= NULL DO BEGIN IF val[t^.v] = THEN visit(t^.v); t := t^.next; END; { I } t = NULL oder t^.next = NULL oder (t^.next)^.next = NULL oder... Wiederhole solange wie nicht (t = NULL) { I und B} (t = NULL oder t^.next = NULL oder (t^.next)^.next = NULL oder...) und nicht (t = NULL) Anweisung(en) { I } t = NULL oder t^.next = NULL oder (t^.next)^.next = NULL oder... { I und nicht B} (t = NULL oder t^.next = NULL oder (t^.next)^.next = NULL oder...) und t = NULL

39 Rekursion in VISIT. Partielle Korrektheit IF val[t^.v] = THEN visit(t^.v); Nach Hoare gilt... (Beweis: über Induktion, K. Schmidt, ThI ) val[t^.v] = visit(t^.v) nicht(val[t^.v] = ) und nicht(val[(t^.next)^.v] = ) und nicht... 9

40 . Totale Korrektheit Totale Korrektheit = Terminierung der WHILE Schleifen Hauptprogramm: Für die Terminierungsfunktion f(v,k) gilt: f(v,k) = V k +, denn: = f(v,k) k = V + k > V

41 . Totale Korrektheit Totale Korrektheit = Terminierung der WHILE Schleifen Prozedur VISIT Zusätzliche Funktionen nötig, da Terminierungsfunktion f(t) nach N abbildet. LE sei ein Listenelement nachfolger(le) := Anzahl der Nachfolger + f(t) = nachfolger(t) f(t) =, falls t!= NULL, falls t = NULL

42 . Einordnung der Tiefensuche

43 . Einordnung der Tiefensuche Tiefensuche = ein typischer Vertreter von Suchalgorithmen weitere Vertreter : Breitensuche Allgemeine Kostensuche Tiefenbeschränkte Suche bidirektionale Suche Gierige Suche Hill Climbing Suche [...] Informationen:

44 . Einordnung der Tiefensuche FAZIT moderater Speicherverbrauch Keine Tiefensuche bei großen (infiniten) Tiefen Tiefenbeschränkte Suche als Alternative

45 Quellen Gerald Futschek; Programmentwicklung und Verifikation; Springer-Verlag Wien New-York; 99; Robert Sedgewick; Algorithms in Java; Addison Wesley; /slides/kap suche.pdf

46 Abschluss Indiana Jones Der Entdecker der Tiefensuche? Indys Vorgehen entspricht dem Ablauf des Algorithmus der Tiefensuche Dennoch, Indiana Jones ist nicht der Entdecker... Die Tiefensuche ist schon aus dem Altertum und aus der griechischen Sage bekannt unter dem Namen Labyrinth-Suche. Dieser bezieht sich auf die Erzählung von dem griechischen Helden Theseus, der nach Kreta reiste, um dort ein Untier namens Minotauros zu erlegen, das dort in einem unterirdischen Höhlensystem, genannt Labyrinth, sein Unwesen trieb. [...] jedenfalls fand Theseus den Minotauros mittels Tiefensuche, und als Markierungshilfsmittel verwendete er das Wollknäuel aus dem Strickzeug der Königstochter Ariadne, [...]