Graphdurchmusterung, Breiten- und Tiefensuche

Transkript

1 Prof. Thomas Richter 18. Mai 2017 Institut für Analysis und Numerik Otto-von-Guericke-Universität Magdeburg Material zur Vorlesung Algorithmische Mathematik II am Graphdurchmusterung, Breiten- und Tiefensuche 1 Zusammenang Folie 1 Wir haben einen Graphen G = (V, E) zusammenhängend genannt, wenn es zu je zwei Knoten x, y V einen Weg in G gibt, der x und y verbindet. Definition 1 (Zusammenhangskomponente). Es sei G = (V, E) ein ungerichteter Graph. Die maximalen zusammenhängenden Teilgraphen von G sind die Zusammenhangskomponenten von G Ein Graph mit zwei Zusammenhangskomponenten G 1 und G 2 G 1 = ({1, 2, 3}, {(1, 2), (2, 3)}), G 2 = ({4, 5}, {(4, 5)}). Im Folgenden untersuchen wir Algorithmen zum Bestimmen von Zusammenhangskomponenten. Der Grundalgorithmus ist die Durchmusterung von Graphen. Ausgehend von einem Knoten x V suchen wir alle Knoten y V, die von x aus erreichbar sind. 1

2 Wir benötigen einige weitere Begriffe. Folie 2 Definition 2 (Baum und Wald). Ein ungerichteter Graph heißt Wald, falls er keinen Kreis enthält. Ein Baum ist ein zusammenhängender Wald. Knoten vom Grad 1 in einem Baum heißten Blatt. Die Zusammenhangskomponenten eines Waldes sind Bäume. Bäume eignen sich, um die Zusammenhangskomponenten eines Graphen darzustellen. 2

3 Folie 3 Algorithmus 1: Graphdurchmusterung Gegeben Graph G = (V, E) sowie Knoten x V. Ausgabe Teilgraph G = (R, F) 1 R = {x} 2 Q = {x} 3 F = 4 Solange Q 5 Wä hle y Q 6 F a l l s e = (y, z) E mit z V \ R 7 R = R {z} 8 Q = Q {z} 9 F = F {(y, z)} 10 Sonst 11 Q = Q \ {y} Stück für Stück wird ein Graph (R, F) aufgebaut. Ausgehend von einer Menge Q werden alle Knoten z hinzugefügt, die von Elementen aus Q erreichbar sind. Knoten y Q, die keine Nachbarn ausserhalb von R haben werden aus Q entfernt. Neue Nachbarn werden Q hinzugefügt, da diese gegebenenfalls weitere Nachbarn haben. Folie 4 Satz 1 (Graphdurchmusterung). Der Algorithmus zur Graphdurchmusterung liefert eine maximale Zusammenhangskomponente (R, F) mit x R. Er kann in linearer Laufzeit implementiert werden. O( V + F ) Beweis. (i) Wir zeigen zunächst, dass der Graph G Verfahren ein Baum ist. Zu Beginn des Verfahrens ist = (R, F) zu jedem Zeitpunkt im G = ({x}, ), also zusammenhängend und kreisfrei und somit ein Baum. Der Graph G wird nur in Zeilen 7+9 durch hinzufügen eines Knotens z V \ R und einer Kante e E geändert. Der neue (ungerichtete) Graph ist weiterhin zusammenhängend und wegen z R weiterhin kreisfrei, also ein Baum. (ii) Angenommen, nach Abschluss des Verfahrens gebe es einen Knoten r V \ R, der aber vom Knoten x R erreichbar wäre. Dann gibt es einen Weg P in G, der x und r verbindet. Es sei (a, b) E eine Kante auf diesem Weg mit a R und b V \ R. Da 3

4 a R muss es einen Durchlauf des Algorithmus gegeben haben mit a Q. Dieser Knoten a wird jedoch nur dann aus Q entfernt, wenn es keine solche Kante (a, b) gibt. Dies ist ein Widerspruch, also kann es keine erreichbaren Knoten r V \ R geben. (iii) Wir merken uns zunächst in einer Liste der Länge V zu jedem Knoten die Anzahl der Kanten innerhalb der Adjazenzliste, die bereits untersucht wurden. (Linear in V ). Untersucht werden nur die Kanten, die von Knoten in R aus erreichbar sind. Auf diese Weise wird jede Kante (von jedem Endknoten aus) maximal einmal betrachtet. Der Algorithmus besteht somit aus maximal 2 F Schritten. In jedem dieser Schritte werden der Menge Q Elemente hinzugefügt bzw. entfernt. Verwenden wir Datenstrukturen, die dies in konstanter Laufzeit O(1) ermöglichen, so erhalten wir insgesamt lineare Laufzeit O( V + E ). Folie 5 Satz 2 (Zusammenhangskomponenten). Alle Zusammenhangskomponenten eines ungerichteten Graphen können in linearer Laufzeit bestimmt werden. O( V + E ) Beweis. Man startet das Verfahren mit einem beliebigen Knoten x V. Als Ergebnis erhält man in der Laufzeit O( V + F 1 ) eine Zusammenhangskomponente G 1 = (V 1, F 1 ). Wir führen das Verfahren weiter mit einem Knoten x V \ V 1 (falls vorhanden). Die entsprechende Zusammenhangskomponente G 2 = (V 2, F 2 ) können wir in Laufzeit O( F 2 ) bestimmen, da die anfängliche Initialisierung der Liste der besuchten Kanten nur einmal erfolgen muss. Nach m Schritten erhalten wir die Laufzeit O( V + F 1 + F F m ) = O( V + E ), da F F m E. Der Algorithmus zur Graphdurchmusterung ist noch nicht eindeutig festgelegt, da in Zeile 5 die Wahl eines Elements y Q spezifiziert werden muss. 4

5 Folie 6 Definition 3 (Breitensuche und Tiefensuche). Wählt man bei der Graphdurchmusterung jeweils den Knoten y Q, der zuletzt zu Q hinzugefügt wurde, so nennt man das Verfahren Tiefensuche. Wählt man den Knoten y Q, der als erstes zu Q hinzugefügt wurde, so nennt man das Verfahren Breitensuche. Die Grundideen der beiden Varianten beschreiben zwei verschiedene Datenstrukturen, last in first out sowie first in first out. Die Erste Datenstruktur wird mit einem Stack realisiert. Wie auf einen Bücherstapel werden Elemente oben abgelegt und auch wieder von oben entfernt. Die zweite Variante, first in first out beschreibt eine Warteschlange. Das Element welches zuerst in die Warteschlange zugefügt wurde, wir auch als erstes wieder entfernt. Stellen wir uns beide Datenstrukturen als Listen vor, so erfolgt bei einem Stack das Hinzufügen und Entfernen auf der gleichen Seite, bei einer Warteschlange erfolgen Hinzufügen und Entfernen auf unterschiedlichen Seiten. 2 Datentypen und Realisierung Folie 7 Zur Verwaltung eines Stacks eignet sich der bereits bekannte Datentyp vector. Die relevanten Befehle sind: clear (): Löscht alle Einträge und setzt die Länge auf Null size (): Liefert die Länge des Vektors zurück push_back(x): Hängt das neue Element x in konstanter Laufzeit O(1) hinten an den Vektor an back(): Gibt das letzte Element in konstanter Laufzeit O(1) zurück pop_back(): Entfernt das letzte Element in konstanter Laufzeit O(1) Mit einem vector kann die Tiefensuche implementiert werden. 5

6 Algorithmus 2: Tiefensuche Folie 8 1 void t i e f e n s u c h e ( i n t x, Graph& OUT, const Graph& IN ) 2 { 3 i n t N = IN.N( ) ; 4 OUT. i n i t (N) ; / / I n i t i a l i s i e r u n g von Ausgabe 5 6 vector <int > E_besucht (N, 1) ; / / B e s u c h t e Kanten 7 8 vector <bool> inout (N, f a l s e ) ; / / H i n z u g e f u e g t e Knoten 9 inout [ x ]= true ; vector <int > Q; / / S t a c k 12 Q. push_back ( x ) ; while (Q. s i z e ( ) >0) 15 { 16 i n t y = Q. back ( ) ; / / L e t z t e s Element im S t a c k i n t ni = E_besucht [ y ] + 1 ; / / E r s t e, n i c h t b e s u c h t e Kante 19 while ( ni <IN. adj [ y ]. s i z e ( ) ) / / D u r c h l a u f e Nachbarn 20 { 21 i n t n = IN. adj [ y ] [ ni ] ; 22 ++E_besucht [ y ] ; / / B e s u c h t e Kante merken i f (! inout [ n ] ) / / Neuer Knoten gefunden 26 { 27 OUT. neue_kante ( y, n ) ; / / Kante hinzu 28 inout [ n]= true ; / / Knoten a l s b e s u c h t m a r k i e r e n Q. push_back ( n ) ; / / Knoten a u f den S t a c k l e g e n 31 break ; / / Abbruch 32 } 33 ++ni ; 34 } 35 i f ( ni==in. adj [ y ]. s i z e ( ) ) / / Keine Nachbarn? 36 Q. pop_back ( ) ; 37 } 38 } 6

7 Zur Realisierung einer Warteschlage gibt es in C++ den Datentyp queue. Wie vector ist queue ein template, es können also Warteschlagen von verschiedenen Typen verwaltet werden, z.b. queue<int>. Folie 9 Zur Verwaltung einer Warteschlange eignet sich der Datentyp queue. Die relevanten Befehle sind: empty(): Liefert true zurück, wenn die Warteschlange leer ist push(x): Hängt das neue Element x in konstanter Laufzeit O(1) hinten an front (): Gibt das erste Element der Warteschlange in konstanter Laufzeit O(1) zurück. pop(): Entfernt das erste Element in konstanter Laufzeit O(1) Die Tiefensuche kann durch Verwendung einer Warteschlange anstelle eines Stacks einfach zu einer Breitensuche modifiziert werden. 7

8 Algorithmus 3: Breitensuche Folie 10 1 void breitensuche ( i n t x, Graph& OUT, const Graph& IN ) 2 { 3 i n t N = IN.N( ) ; 4 OUT. i n i t (N) ; / / I n i t i a l i s i e r u n g von Ausgabe 5 6 vector <int > E_besucht (N, 1) ; / / B e s u c h t e Kanten 7 8 vector <bool> inout (N, f a l s e ) ; / / H i n z u g e f u e g t e Knoten 9 inout [ x ]= true ; queue<int > Q; / / W a r t e s c h l a n g e 12 Q. push ( x ) ; while (Q. s i z e ( ) >0) 15 { 16 i n t y = Q. f r o n t ( ) ; / / E r s t e s Element im S t a c k i n t ni = E_besucht [ y ] + 1 ; / / E r s t e, n i c h t b e s u c h t e Kante 19 while ( ni <IN. adj [ y ]. s i z e ( ) ) / / D u r c h l a u f e Nachbarn 20 { 21 i n t n = IN. adj [ y ] [ ni ] ; 22 ++E_besucht [ y ] ; / / B e s u c h t e Kante merken i f (! inout [ n ] ) / / Neuer Knoten gefunden 26 { 27 OUT. neue_kante ( y, n ) ; / / Kante hinzu 28 inout [ n]= true ; / / Knoten a l s b e s u c h t m a r k i e r e n Q. push ( n ) ; / / Knoten anhaengen 31 } 32 ++ni ; 33 } 34 i f ( ni==in. adj [ y ]. s i z e ( ) ) / / Keine Nachbarn? 35 Q. pop ( ) ; 36 } 37 } 8

9 Die Breitensuche hat eine zur Suche von kürzesten Wegen wichtige Eigenschaft. Folie 11 Satz 3 (Breitensuche). Der durch Breitensuche ausgehend von x V erzeugte Baum B = (V, E ) enthält einen kürzesten Weg von Knoten x V zu allen anderen, von x aus erreichbaren Knoten y V. Die Länge des Weges dist(x, y) kann in linearer Laufzeit bestimmt werden. Beweis. (i) Wir estellen von x aus den Baum mit Hilfe der Breitensuche. Dabei speichern wir zusätzlich den Vektor vector<int> dist(n);, zu Beginn dist [ i]= 1; für alle Knoten i und dist [x]=0; für den Startknoten. Beim Hinzufügen einer neuen Kante in Zeile 27 wird der Abstand zum neuen Knoten n definiert dist [n]=dist[y]+1;. (ii) Wir zeigen nun dist G (x, y) = dist B (x, y), dass es also keinen kürzeren Weg im Graphen G = (V, E) als im Baum B = (V, E ) gibt. Die Relation ist klar, da B G ein Teilgraph ist. Wir gehen davon aus, dass es einen Knoten v V gibt mit dist G (x, v) < dist B (x, v). (1) Dabei sei v so gewählt, dass dist G (x, v) minimal ist. Mit P bezeichnen wir den kürzesten Weg von x nach v in G. Dann sei (u, v) die letzte Kante in diesem Weg P. Nach Voraussetzung gilt dist G (x, v) = dist G (x, u) + 1 = dist B (x, u) + 1, (2) da ja v der derjenige Knoten mit kleinstem Abstand in G ist, der die Ungleichung (1) erfüllt. Zu jedem Zeitpunkt im Algorithmus gilt dist B (x, y) dist B (x, z) + 1 y R, z Q sowie dist B (x, y) dist B (x, z) + 1 y, z Q falls y zuerst zugefügt wurde. Der Knoten v wird erst dann hinzugefügt, nachdem u aus Q entfernt wurde. Damit muss dist B (x, v) dist B (x, u) + 1 gelten, ein Widerspruch zu (1) und (2). 9