157 lines
4.9 KiB
TeX
157 lines
4.9 KiB
TeX
\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}
|
|
Sei $w(e) = 1$ für
|
|
alle $e \in E$ so gilt das Gegenbeispiel von oben. Also ist die Aussage
|
|
falsch.
|
|
\points{2}
|
|
|
|
\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}
|
|
|
|
\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 herasgenommen.
|
|
Somit läuft der Algorithmus in $\Oh(\abs{V})$.
|
|
|
|
\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.
|
|
\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}
|
|
|
|
|
|
\section{Graphmodellierung}
|
|
|
|
\end{document}
|