\documentclass{article}

\usepackage{amsmath}
\usepackage{algorithm}
\usepackage[noend]{algpseudocode}

\usepackage[utf8]{inputenc}

\makeatletter
\def\BState{\State\hskip-\ALG@thistlm}
\makeatother

\title{FOP Projektgruppe 175}
\author{Steffen Wagner\\
	Dennis Weinberger\\
	Jonas Süß\\
	Joachim Schmidt}

\begin{document}
	\maketitle
	
	\tableofcontents

	\section{Der Graph}

	\subsection{Bildung der Kanten}

	Der Algorithmus für die Bildung der Kanten ist folgender:

	\begin{algorithm}
		\caption{Bildung von Kanten}\label{euclid}
		\begin{algorithmic}[1]
		\Procedure{generateEdges}{}
		\EndProcedure
		\end{algorithmic}
	\end{algorithm}

	% Erklärung des Algorithmus
	Der Algorithmus ist in zwei Schritte aufgeteilt:
	\begin{itemize}
		\item Minimale Verbindung von allen Burgen
		\item Ästhetische Verbesserung der Kanten
	\end{itemize}

	Die minimale Verbindung aller Burgen erfolgt, indem
	sichergestellt wird, dass jede Burg mit einer anderen
	verbunden ist und dass alle Burgen in einer gemeinsamen
	Verbindung zusammenhängen. Der Algorithmus fängt bei
	einer bestimmten Start-Burg an und verbindet diese Burg
	mit der nächstliegenden Burg, die noch nicht verbunden
	wurde. Daraufhin wird das gleiche mit der nächsten,
	übernächsten, usw. Burg getan, bis die letzte Burg erreicht
	wurde. Zu diesem Zeitpunkt sind alle Burgen durch eine
	Linie verbunden.

	Die Ästhetische Verbesserung erfolgt, indem alle Burgen
	im Umkreis einer Burg durch eine Kante verbunden werden.

	\subsection{Überprüfung der Erreichbarkeit aller Knoten}

	Der Algorithmus, der prüft, ob alle Knoten erreichbar sind, ist
	folgender:

	\begin{algorithm}
		\caption{Erreichbarkeit aller Knoten}\label{euclid}
		\begin{algorithmic}[1]
		\Procedure{allNodesConnected}{}
		\State $\textit{firstNode} \gets \text{first element of }\textit{nodes}$
		\State $allVisitedNodes \gets \textit{empty}$
		\State $nextVisitNodes \gets empty$
		\State $\text{append } firstNode \text{ to } allVisitedNodes$
		\State $\text{neighborsOf } firstNode$
		\State $\rightarrow \text{filter out all } x \text{ where } allVisitedNodes \text{ contains } x$
		\State $\rightarrow \text{append to } nextVisitNodes$
		\BState \emph{loop}
		\If {$nextVisitNodes \text{ is empty}$}
		break
		\EndIf
		\State $\text{append first element of } nextVisitNodes \text{ to } allVisitedNodes$
		\State $\text{neighborsOf first element of } nextVisitNodes$
		\State $\rightarrow \text{filter out all } x \text{ where } allVisitedNodes \text{ contains } x$
		\State $\rightarrow \text{append to } nextVisitNodes$
		\State $\text{delete first element of } nextVisitNodes$
		\BState \emph{end loop}
		\EndProcedure
		\end{algorithmic}
	\end{algorithm}

	Der Algorithmus verwendet zwei unterschiedliche Datentypen:
	
	\begin{itemize}
		\item HashSet wird verwendet, um die bisher
		besuchten Knoten zu speichern. Eine HashSet
		hat den Vorteil, dass Elemente nur einmal
		gespeichert werden können. 
		\item ArrayDeque wird verwendet, um die nächsten
		Knoten, die besucht werden, zu speichern.
	\end{itemize}

	Der Algorithmus sammelt sozusagen alle Knoten, die 
	aufgrund von momentanen Erkenntnissen erreichbar
	sind, in der ArrayDeque \texttt{nextVisitNodes}. Hingegen sind
	alle Knoten, die schon erreicht worden sind, in dem HashSet
	\texttt{allVisitedNodes} gespeichert. 
	
	Der Algorithmus geht die ArrayDeque \texttt{nextVisitNodes}
	solange durch, bis diese leer ist. In jeder Iteration wird
	das erste Element der Liste aus der Liste entfernt. 
	Zunächst wird dieses Element dem HashSet \texttt{allVisitedNodes} 
	hinzugefügt. Daraufhin
	werden die Nachbarn dieses Elements herausgefunden. Diejenigen
	Nachbarn, die schon in dem HashSet \texttt{allVisitedNodes}
	vorhanden sind, werden verworfen. Die restlichen Nachbarn
	werden der ArrayDeque \texttt{nextVisitNodes} hinzugefügt.

	\subsection{Wege finden}

	\subsection{Kürzester Pfad zu allen Knoten}
    
\end{document}
