\documentclass{ngexrcs}
\usepackage{hyperref}
\title{1. Übungsblatt}
\subject{Algorithmische Graphentheorie}
\author{Jasper Gude \and Pia Röttgers}

\begin{document}
\maketitle
\points[\qquad]{20}
\section{Spannbäume \& Breitensuche}
Sei $G = \tup{V, E}$ ein zusammenhängender Graph mit Kantengewichten $w: E \to \NN$
und $s \in V \deg$ ein ausgezeichneter Knoten.

\begin{tasks}

\item
\begin{quote}
Wenn $w(e) = 1$ für alle $e \in E$, dann ist der Breitensuchbaum mit
Quelle $s$ ein minimaler Spannbaum.
\end{quote}
Die Breitensuche berechnet in diesem
Fall den kürzesten Weg von jedem Knoten zum Knoten $s$, also den
Breitensuchbaum. Dieser spannt also einen minimalen Spannbaum auf.
\points{2}

\item
\begin{quote}
Wenn $w(e) = 1$ für alle $e \in E$, dann ist jeder minimale Spannbaum
von $G$ ein Breitensuchbaum mit Quelle $s$.
\end{quote}
Falsch, siehe \autoref{fig:msb}.
\points{2}
\begin{figure}[h]
	\centering
	\includegraphics[width=0.2\textwidth]{msb.eps}
	\caption{$\pi$-Zeiger des Breitensuchbaums und MSB blau hinterlegt.}
	\label{fig:msb}
\end{figure}

\item 
\begin{quote}
Wenn $w(e) \in \set{1, 2, 3}$ für alle $e \in E$, dann ist jeder minimale
Spannbaum von $G$ ein Tiefensuchbaum mit Quelle $s$.
\end{quote}
Falsch, siehe \autoref{fig:dfs}. Der Minimale Spannbaum kann kein Tiefensuchbaum
sein.
\points{2}
\begin{figure}[h]
	\centering
	\includegraphics[width=0.2\textwidth]{dfs.eps}
	\caption{Tiefensuchbaum in orange und MSB blau hinterlegt.}
	\label{fig:dfs}
\end{figure}

\end{tasks}

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

\section{Eulerwege}
\begin{quote}
Sei $G = \tup{V, E}$ ein ungerichteter, zusammenhängender Graph. Dann gilt: $G$ hat genau
dann einen Eulerweg, wenn die Anzahl an Knoten $v \in V$, für die gilt, dass $deg(v)$
ungerade ist, genau $0$ oder $2$ ist.
\end{quote}

\begin{itemize}
	\item[$\seilpmi$]
		1. Fall: $0$ Knoten mit ungeradem Grad. Nach dem Satz in der Vorlesung
		gibt es einen Eulerkreis. Im Eulerweg sind also Start- und Endknoten
		identisch.

		2. Fall: $2$ Knoten mit ungeradem Grad. Die beiden Knoten bilden den Start-
		und Endknoten des Eulerwegs. Die Kante die den Eulerkreis schließen würde
		braucht genau zwei Knoten, zu denen sie inzident ist. Nehmen wir diese Kante
		weg, ergibt sich eine ungerader Grad an diesen beiden Knoten.
	\item[$\implies$]
		Ein Graph mit ungerader Anzahl an Knoten mit ungeradem Grad kann nicht
		existieren, da die Summe aller Knoten mit ungeradem Grad gerade ist.

		Für alle anderen Fälle gilt, wenn ein Knoten ungeraden Grad hat, dann gibt
		es keinen Weg aus dem Knoten heraus, wenn man hineingelaufen ist.
\end{itemize}
\points{4}

\section{Graphmodellierung}
\begin{quote}
Sie betreuen ein Projekt, das sich aus vielen vordefinierten Aufgaben zusammensetzt.
Manche Aufgaben können erst erledigt werden, wenn bestimmte andere Aufgaben ab-
geschlossen sind. Für jede Aufgabe ist vorher genau bekannt, von welchen Aufgaben
sie abhängt. Ihr Projektteam kann immer nur eine Aufgabe gleichzeitig bearbeiten und
eine angefangene Aufgabe wird immer abgeschlossen bevor eine neue Aufgabe begon-
nen werden kann.
\end{quote}
Wir modellieren das Problem als gerichteten Graph.
Die Aufgaben sind Knoten. Jede Aufgabe hat Kanten zu den Aufgaben, die von ihr
abhängen.

Eine Reihenfolge können wir mithilfe einer Topologischen Sortierung finden.

\points{3}


\end{document}