78 lines
2.5 KiB
TeX
78 lines
2.5 KiB
TeX
\section{Kreissuche}
|
|
\begin{tasks}
|
|
\item
|
|
Wähle Startknoten $s$ und füge ihn in eine neue Queue $Q$ ein.
|
|
|
|
Nimm den vordersten Knoten $u$ aus $Q$ und füge seine noch nicht entdeckten (weißen)
|
|
Nachbarn ein und färbe sie grau. Wenn einer der Nachbarn schon entdeckt wurde,
|
|
also grau ist, gibt es einen Kreis in $G$.
|
|
Markiere den Knoten $u$ als abgeschlossen ($black$) und entferne ihn aus $Q$
|
|
|
|
Wiederhole den Schritt solange bis $Q$ leer ist.
|
|
|
|
% \begin{pseudocode}[caption=Hello World Algorithmische]
|
|
% EinfacherKreis(|Graph| $G$, |Vertex| $s$)
|
|
% Initialize($G$, $s$)
|
|
% $Q \gets$ new Queue
|
|
% $Q.$Enqueue($s$)
|
|
% $t_1 \gets nil$
|
|
% $t_2 \gets s$
|
|
% // Comment
|
|
% while $Q \neq \emptyset$ do
|
|
% $u \gets Q.$Dequeue
|
|
% $t_1 \gets t_2$
|
|
% $t_2 \gets u$
|
|
% foreach $v \in Adj[u]$ do
|
|
% if $v.color = white$ then
|
|
% $Q.$Enqueue($v$)
|
|
% $u.color \gets black$
|
|
% if $t_1 = t_2$ then
|
|
% return $true$
|
|
% else
|
|
% return $false$
|
|
% \end{pseudocode}
|
|
\begin{algorithm}[h]
|
|
\centering
|
|
\begin{algorithmic}
|
|
\alg{EinfacherKreis}{Graph $G$, Vertex $s$} \+ \\
|
|
\alg{Initialize}{$G$, $s$} \com{So wie in der Breitensuche} \\
|
|
$Q \gets$ new \alg{Queue}{} \\
|
|
$Q.$\alg{Enqueue}{$s$} \\
|
|
while $Q \neq \emptyset$ do \+ \\
|
|
$u \gets Q.$\alg{Dequeue}{} \\
|
|
$u.color \gets gray$ \\
|
|
foreach $v \in Adj[u]$ do \+ \\
|
|
\com{Füge alle noch nicht entdeckten Knoten ein} \\
|
|
if $v.color = white$ then \+ \\
|
|
$v.color \gets gray$ \\
|
|
$Q.$\alg{Enqueue}{$v$} \- \\
|
|
\com{Wenn ein Knoten schon entdeckt wurde, gibt es einen Kreis} \\
|
|
else return $true$ \- \\
|
|
$u.color \gets black$ \- \\
|
|
return $false$
|
|
\end{algorithmic}
|
|
\end{algorithm}
|
|
\points{4}
|
|
|
|
\item
|
|
Dadurch, dass wir nur Knoten
|
|
einfügen, die noch nicht entdeckt wurden, können wir nie auf dem selben Pfad
|
|
zu einem Knoten kommen. Das heißt, wenn wir einen schon entdeckten Knoten
|
|
finden, haben wir einen Kreis im Graphen gefunden.
|
|
|
|
Der Algorithmus kann aufgrund der Struktur des Graphens (kein Multigraph,
|
|
keine Selbstkanten) nur Kreise der Länge mindestens 3 finden.
|
|
|
|
Jeder Knoten wird nur einmal in die Queue eingefügt und nur einmal herausgenommen.
|
|
Somit läuft der Algorithmus in $\Oh(\abs{V})$.
|
|
\points{2}
|
|
|
|
\item
|
|
Solange es weiße Knoten im Graphen gibt, wählen wir einen neuen Startknoten
|
|
für diese Zusammenhangskomponente. Als Ausgabe geben wir ein Array von
|
|
Tupeln $\tup{s_i, c_i}$ zurück, wobei $s_i$ der Startknoten einer
|
|
Zusammenhangskomponente und $c_i \in \set{true, false}$ der Wahrheitswert, ob
|
|
ein Kreis in der Komponente existiert.
|
|
\points{1}
|
|
\end{tasks}
|
|
|