\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}

