diff --git a/doc/Dokumentation.tex b/doc/Dokumentation.tex index 8b3347a..5202872 100644 --- a/doc/Dokumentation.tex +++ b/doc/Dokumentation.tex @@ -17,159 +17,159 @@ Joachim Schmidt} \begin{document} - \maketitle - - \tableofcontents +\maketitle - \section{Der Graph} +\tableofcontents - \subsection{Bildung der Kanten} +\section{Der Graph} - Der Algorithmus für die Bildung der Kanten ist folgender: +\subsection{Bildung der Kanten} - \begin{algorithm} - \caption{Bildung von Kanten}\label{euclid} - \begin{algorithmic}[1] - \Procedure{generateEdges}{} - \If{nodes is empty} return \EndIf - \State $castle \gets allCastles[0]$ - \State $remainingCastles \gets allCastles$ - \Loop - \If{$remainingCastles$ is empty} break - \EndIf - \State connect $castle$ to nearest castle - \State $castle \gets nearest castle$ - \State remove $castle$ from $remainingCastles$ - \EndLoop - \ForAll{castle in allCastles} - \ForAll{nearCastle in allCastlesInRadius(castle)} - \State connect $castle$ to $nearCastle$ - \EndFor - \EndFor - \EndProcedure - \end{algorithmic} - \end{algorithm} +Der Algorithmus für die Bildung der Kanten ist folgender: - % 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} +\begin{algorithm} + \caption{Bildung von Kanten}\label{euclid} + \begin{algorithmic}[1] + \Procedure{generateEdges}{} + \If{nodes is empty} return \EndIf + \State $castle \gets allCastles[0]$ + \State $remainingCastles \gets allCastles$ + \Loop + \If{$remainingCastles$ is empty} break + \EndIf + \State connect $castle$ to nearest castle + \State $castle \gets nearest castle$ + \State remove $castle$ from $remainingCastles$ + \EndLoop + \ForAll{castle in allCastles} + \ForAll{nearCastle in allCastlesInRadius(castle)} + \State connect $castle$ to $nearCastle$ + \EndFor + \EndFor + \EndProcedure + \end{algorithmic} +\end{algorithm} - 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. +% 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 Ästhetische Verbesserung erfolgt, indem alle Burgen - im Umkreis einer Burg durch eine Kante verbunden werden. +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. - \subsection{Überprüfung der Erreichbarkeit aller Knoten} +Die Ästhetische Verbesserung erfolgt, indem alle Burgen +im Umkreis einer Burg durch eine Kante verbunden werden. - Der Algorithmus, der prüft, ob alle Knoten erreichbar sind, ist - folgender: +\subsection{Überprüfung der Erreichbarkeit aller Knoten} - \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$ - \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$ - \EndLoop - \EndProcedure - \end{algorithmic} - \end{algorithm} +Der Algorithmus, der prüft, ob alle Knoten erreichbar sind, ist +folgender: - 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} +\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$ + \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$ + \EndLoop + \EndProcedure + \end{algorithmic} +\end{algorithm} - 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. +Der Algorithmus verwendet zwei unterschiedliche Datentypen: - \subsection{Wege finden} - \subsubsection{Teil (a)} +\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} - \begin{algorithm} - \caption{Berechnung der Distanzen}\label{euclid} - \begin{algorithmic}[1] - \Procedure{run}{} - \State $v \gets$ getSmallestNode() - \Loop - \If{$v$ is null} break \EndIf - \State $v \gets getSmallestNode()$ - \EndLoop - \EndProcedure - \end{algorithmic} - \end{algorithm} +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} +\subsubsection{Teil (a)} + +\begin{algorithm} + \caption{Berechnung der Distanzen}\label{euclid} + \begin{algorithmic}[1] + \Procedure{run}{} + \State $v \gets$ getSmallestNode() + \Loop + \If{$v$ is null} break \EndIf + \State $v \gets getSmallestNode()$ + \EndLoop + \EndProcedure + \end{algorithmic} +\end{algorithm} - $$O(n) = $$ +$$O(n) = $$ - $n$ soll in diesem Fall die Anzahl an Knoten wiedergeben. +$n$ soll in diesem Fall die Anzahl an Knoten wiedergeben. - Da es sich bei \texttt{availableNodes} um eine - \texttt{LinkedList>} handelt, muss bei jedem - Durchgehen der Liste jedes Element einzeln abgearbeitet - werden. In der Funktion \texttt{getSmallestNode()} ist - dies der Fall. +Da es sich bei \texttt{availableNodes} um eine +\texttt{LinkedList>} handelt, muss bei jedem +Durchgehen der Liste jedes Element einzeln abgearbeitet +werden. In der Funktion \texttt{getSmallestNode()} ist +dies der Fall. - \subsubsection{Teil (b)} +\subsubsection{Teil (b)} - Anstelle einer \texttt{LinkedList} braucht man eine - Datenstruktur, die bereits nach der Größe sortiert ist, - damit bei dem Zugriff auf das kleinste Element nur ein - Schritt erforderlich ist. +Anstelle einer \texttt{LinkedList} braucht man eine +Datenstruktur, die bereits nach der Größe sortiert ist, +damit bei dem Zugriff auf das kleinste Element nur ein +Schritt erforderlich ist. - $$O(n) = $$ +$$O(n) = $$ - \subsubsection{Teil (c)} +\subsubsection{Teil (c)} - Invariante: Nach $h \geq 0$ Durchläufen gilt: +Invariante: Nach $h \geq 0$ Durchläufen gilt: - \subsection{Kürzester Pfad zu allen Knoten} +\subsection{Kürzester Pfad zu allen Knoten} \end{document}