AuK/Minimaler Spannbaum WS13-14

Wiki-Quelltext dieser Seite.

<language>Processing</language>
Autoren:
* [mailto:s3darich@stud.hs-zigr.de Daniel Richter]
* [mailto:s3addank@stud.hs-zigr.de Adrian Danker]

Als minimale Spannbäume wird die Menge aller Verbindungen zwischen Punkten bezeichnet, die nötig sind, um alle Punkte mit minimaler Distanz zu verbinden.

==Spannbäume, Motivation==

Mit Hilfe von minimalen Spannbäumen lassen sich effiziente Lösungen für Vernetzungen von Punkten finden, bei denen die Gesamtstrecke möglichst klein werden soll.


<popup name = "Spielanleitung">
Getreu dem Spruch "Be''greifen'' kommt von anfassen", wollen wir minimale Spannbäume kurz demonstrieren.

'''Spielregeln:'''
# Neun Freiwillige stehen auf
# Eine Person bekommt das Wollknäul
# Der Faden wird festgehalten und das Wollknäul an eine beliebige andere Person weitergegeben
# Der Faden muss straff gehalten werden
# Das Wollknäul wird insgesamt 15x weitergegeben
# Jeder muss mindestens einen Faden in der Hand halten
# Nachdem das Wollknäul insgesamt 15x weitergegeben wurde, bleiben alle stehen und heben das entstandene Netz (den "Spannbaum") über ihre Köpfe, sodass er gut zu sehen ist.
# Die längsten redundanten Verbindungen werden nacheinander durchtrennt, sodass am Ende der "minimale Spannbaum" übrig bleibt
</popup>

...sie sind sehr nützlich, um Probleme wie das TSP zu vereinfachen oder kostengünstige Lösungen für zusammenhängende Netzwerke (Telefonnetz, Gas-/Wasser-/Abwasserversorgung, Internet) zu finden.


=== Minimale Spannbäume ===
Bei Spannbäumen wird immer von einem gewichteten, ungerichteten und zusammenhängenden Graphen $G=(V,E)$ ausgegangen.
*$V$ ist die Menge der Knoten 
*$E$ ist die Menge der Kanten des Graphen
*Jede Kante $(u,v)\in E$ besitzt ein Gewicht $w(u,v)$ ('''gewichtet'''), das die Länge, bzw. Kosten angibt
*Ein Graph $G$ ist '''ungerichtet''', wenn für eine Kante $(u,v)$ direkt von $u$ nach $v$ und umgekehrt gegangen werden kann
*Ein ungerichteter Graph heißt '''zusammenhängend''', wenn für alle Knoten gilt, dass es zu je zwei beliebigen Knoten $u$ und $v$ einen ungerichteten Weg gibt mit $u$ als Startknoten und $v$ als Endknoten


Die azyklische Teilmenge $T \subseteq E$, die alle Knoten miteinander verbindet, ist ein Spannbaum. Ist das Gesamtgewicht minimal so ist dies ein minimaler Spannbaum.

$$w(T)=\sum_{(u,v)\in{}T}{w(u,v)}$$

==Aufbau minimaler Spannbäume==

Um einen minimalen Spannbaum, für einen ungerichteten, zusammenhängenden Graphen $G=\left(V , E\right)$ mit der Gewichtsfunktion $w:E\rightarrow \mathbf{R}$ zu bestimmen, nutzen wir den [http://programmingwiki.de/AuK/Greedy-Algorithmen_WS13-14  Greedy-Ansatz]. Der Algorithmus von Kruskal und auch der Algorithmus von Prim nutzen beide diesen Ansatz, jedoch ist die Art wie dieser Ansatz verfolgt wird unterschiedlich. Zuerst wird ein generischer Ansatz gezeigt, um zu illusteren wie im allgemeinen ein minimaler Spannbaum aufgebaut wird. 

===generischer Ansatz===
'''Allgemeine Festlegung'''
 
'''Invariante:''' ist eine Aussage, die über die Ausführung bestimmter Programmbefehle hinweg gilt.
Unmittelbar vor jeder Iteration ist $A$ eine Teilmenge eines minimalen Spannbaumes.
In jedem Schritt wird eine Kante $\left(u,v\right)$ bestimmt, welche zu dem minimalen Spannbaum $A$ hinzugefügt werden kann. Dadurch sind $A\cup\lbrace\left(u,v\right)\rbrace$
eine Teilmenge von einem minimalen Spannbaum. Diese Kante wird als sichere Kante für $A$ bezeichnet, ohne die Invariante zu verletzen.

'''Baum:''' Mengen werden durch gerichtete Bäume dargestellt. Jeder Knoten ist ein Element der Menge und jeder Baum stellt eine Menge da. 

'''Wald disjunkter Mengen:''' Jedes Element zeigt nur auf seinem Vater. Die Wurzel Jedes Baumes enthält den Repräsentanten und ist sein eigener Vater. 

Die genauen Definitionen sind im Buch Algorithmen - Eine Einführung noch ein mal genau erläutert. Es ist Empfohlen dies im Selbststudium noch einmal nachzuarbeiten. 

<div style="background-color:#EEE; max-width:500px">
'''Generischer Algorithmus'''  <br>
1  $A\longleftarrow \emptyset$ <br>
2  '''while''' A bildet keinen Spannbaum<br>
3  $\;\;\;\ $'''do''' bestimme eine Kante $\left(u,v\right)$, die  sicher für A ist<br>
4  $\;\;\;\  A\leftarrow A\cup\lbrace\left(u,v\right)\rbrace$ <br>
5  '''return''' A <br>
</div>

Die Schleifeninvariante wird wie folgt verwendet:
#'''Initialisierung''' :  Nach der ersten Zeile wird die Schleifeninvariante erfüllt.
#'''Fortsetzung''' : In den Zeilen 2-4 erhält die Schleife die Schleifeninvariante, da nur sichere Kanten hinzugefügt werden.
#'''Terminierung''' : Alle Kanten die A hinzugefügt werden, sind in einem minimalem Spannbaum. Also ist die Menge A, ein minimaler Spannbaum und wird zurückgegeben.

===Bestimmung einer sicheren Kante===

Dies ist das eigentlich wichtige. Eine sichere Kante muss existieren. Denn wenn, wie im Pseudocode die dritte Zeile ausgeführt wird, ist dies durch die Schleifeninvariante festgelegt. Das heißt es existiert ein Spannbaum $T$ mit $A\subseteq T$.
In der While-Schleife muss $A$ eine echte Teilmenge von $T$ sein. Es existiert also eine Kante$\left(u,v\right) \in E$, welche sicher für $A$ ist aber nicht zu $A$ gehört.
Um diese Kanten genau bestimmen zu können, benötigen wir einige Definitionen.

'''Schnitt eines ungerichteten Graphen'''

Ein Schnitt $\left(S,V / S\right)$, ist eine Partitionierung von $V$, eines ungerichteten Graphen $G=\left( V,E\right)$.
Wenn eine Kante $\left( u,v\right) \in E$ mit einem ihrer Endpunkte in $S$ und der andere in $V / S$ liegt, dann kreuzt die Kante $\left( u,v\right)$  den Schnitt $\left(S,V /S\right)$. Ein Schnitt respektiert eine Kantenmenge A, falls keine Kante von A den Schnitt kreuzt. Wenn eine Kante das kleinste Gewicht aller Kanten besitzt, welche den Schnitt kreuzen, ist es eine leichte Kante.

[[Bild:S3darich_Schnitt.jpg]]

'''Regel zu Identifizierung sicherer Kanten'''

$G=\left(V,E\right)$ sei ein zusammenhängender, ungerichteter Graph, für den eine reellwertige Gewichtsfunktion auf $E$ definiert ist. Weiter seien $A$ eine Teilmenge von $E$, die zu einem minimalen Spannbaum für $G$ gehört $\left(S,V /S\right)$ ein Schnitt von $G$, der $A$ respektiert und $\left( u,v\right)$ ist eine leichte Kante, die $\left(S,V /S\right)$ kreuzt. Dann ist die Kante $\left( u,v\right)$ für $A$ sicher.

==Algorithmus von Kruskal==
Joseph Bernard Kruskal, geboren am 28 Januar 1929 in New York, gestorben am 19. September 2010 in Princeton, entwickelte 1956 einen Algorithmus ,der auf den generischen Ansatz aufbaut und minimale Spannbäume erstellt. Dieser Algorithmus basiert auf dem generischen Ansatz, welcher im vorherigen Abschnitt betrachtet wurde. Eine sichere Kante wird bestimmt, die einem wachsenden Wald hinzugefügt wird. Es werden hierbei von allen Kanten, welche zwei beliebige Bäume des Waldes verbinden, die Kante $\left(u,v\right)$ mit dem geringsten Gewicht ausgewählt. 

===Arbeitsweise am Pseudocode ===

Bevor wir uns den Pseudocode anschauen müssen wir noch kurz andere Methoden ansehen und erläutern damit wir verstehen wie der der Algorithmus arbeitet. Auch sollte erwähnt werden das der Algorithmus mit der Datenstruktur disjunkten Mengen arbeitet. Die genauen Definitionen, wie auch die genaue Arbeitsweise der folgenden Operationen können Sie [http://www2.cs.uni-paderborn.de/cs/agmonien/LEHRE/SS03/DuA/Monien10.pdf hier] oder im Buch Algorithmen - Eine Einführührung nachlesen.

'''Make-Set'''$\left(v\right)$

Erzeugt Menge $\lbrace v\rbrace$ mit Namen $\lbrace v\rbrace$.

'''Find-Set'''$\left(u\right)$

Die Operation Find-Set$\left( u\right)$ gibt ein repräsentatives Element aus der Menge, welche $u$ enthält, zurück.

'''Union''' $\left( u,v\right)$

$u$ sei in $A^{i}$, $v$ sei in $A^{j}$ $\longrightarrow$ erzeuge $A^{i} \cup A^{j}$, gebe der Menge beliebigen Namen aus $A^{i} \cup A^{j}$.

<div style="background-color:#EEE; max-width:500px">
'''Algorithmus von Kruskal'''  <br>
1  $A\longleftarrow \emptyset$ <br>
2  '''for''' alle Knoten $ v \in V\left[ G\right]$<br>
3  $\;\;\;\ $Make-Set$\left(v\right)$<br>
4   sortiere die Kanten $E$ in nichtfallender Reihenfolge nach dem Gewicht $w$ <br>
5  $\;\;\;\ $ '''for''' alle Kanten$\left(u,v\right) \in E$ in nichtfallender Reihenfolge nach dem Gewicht <br>
6  $\;\;\;\;\;\;\;\;\  $'''do if''' FIND-SET$\left(u\right)\neq$ FIND-SET$\left(v\right)$ <br>
7  $\;\;\;\;\;\;\;\;\;\;\;\;\;\;\ $ '''then''' $A\longleftarrow A\cup \lbrace \left( u,v \right)\rbrace$ <br>
8  $\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\;\ $'''UNION'''$\left(u,v\right)$<br>
9  '''return''' A <br>
</div>

'''Abarbeitung des Algorithmus'''

Der Algorithmus initialisiert in den ersten drei Zeilen, die leere Menge A und es werden $\vert V\vert$  Bäume erzeugt, welche jeweils einen Knoten enthalten. Danach werden die Kanten von $E$ in nichtfallender Reihenfolge und nach dem Gewicht sortiert. Die zweite FOR - Schleife prüft für jede Kante $\left( u,v \right)$ ob die jeweiligen Knoten zum gleichen Baum gehören. Gehören die beiden Knoten zum gleichen Baum, kann die Kante $\left( u,v \right)$ nicht zum Wald hinzugefügt werden. Da sonst ein Zyklus erzeugt wird. Sollte die Kante $\left( u,v \right)$ nicht zum gleichen Baum gehören wird die Kante in Zeile 7 zur Menge A hinzugefügt. Mit der UNION Methode werden die beiden Bäume verschmolzen.
Als letztes wird die Menge $A$ zurückgegeben.  

'''Die Arbeitsweise lässt sich  auch relativ einfach ausdrücken.''' 

# . Es wird die Kante mit dem kleinsten Gewicht des gesamten Graphen ausgewählt und wird als Startkante des minimalen Spannbaumes gesetzt. Bei mehreren Kanten mit dem selben Gewicht werden auch diese verwendet.
# . Danach wird wieder die kleinste Kante, welche noch nicht gesetzt wurde, gesucht und deren Punkte werden miteinander Verbunden.
# . Dieses Verfahren wird solang wiederholt bis alle Punkte untereinander verbunden sind. Dabei darf kein Zyklus entstehen.

[[Bild:S3darich_Bsp.jpg]]

<popup name = "Einzelschritte">
# [[Bild:S3darich_Bsp.jpg]]
# [[Bild:Bsp2.jpg]]
# [[Bild:Bsp3.jpg]]
# [[Bild:Bsp4.jpg]]
# [[Bild:Bsp5.jpg]]
# [[Bild:S3darichBsp6.jpg]]
# [[Bild:S3darichBsp7.jpg]]
# [[Bild:S3darichBsp8.jpg]]
# [[Bild:S3darichBsp9.jpg]]
</popup>



Abschließend lässt sich Festhalten das dieser Algorithmus, mit dieser gewählten Implementierung, der disjunkten Mengen einen Aufwand von $\mathcal{O}\left( E\ \log V\right)$ ensteht.

==Algorithmus von Prim==

Der Algorithmus von Prim dient wie der Algorithmus von Kruskal der Berechnung eines minimalen Spannbaumes in einem zusammenhängenden, ungerichteten, kantengewichteten Graphen.

Der Mathematiker und Informatiker Robert Clay Prim arbeitete 1957 bei den Bell Laboratories und entdeckte dort den später primär nach ihm benannten Algorithmus, der knapp 30 Jahre zuvor von dem tschechischen Mathematiker Vojtěch Jarník entwickelt wurde. 1959 widmete sich auch Edsger W. Dijkstra der Weiterentwicklung. In der Literatur ist daher auch gelegentlich von ''Prim-Dijkstra-Algorithmus'' oder ''Algorithmus von Jarnik, Prim und Dijkstra'' die Rede, im englischen Sprachraum auch ''Jarnik's algorithm'' oder ''DJP algorithm''.

'''Verständnis-Aufgabe:''' [http://students.ceid.upatras.gr/~papagel/project/prim.htm Applet Prim-Algorithmus]<br>
Hinweis in der Hochschule funktioniert dieser Link nur über einen Proxy wie [http://kproxy.com/ kproxy.com].

===Arbeitsweise===

Die Arbeitsweise lässt sich sehr einfach erklären:
1. Nimm einen beliebigen Knoten aus der Menge der Knoten in einem zusammenhängenden, ungerichteten, kantengewichteten Graphen
2. Suche die Kürzeste Kante, die von diesem Knoten ausgeht
3. Nun suche die kürzeste Kante die von einem der bereits angelaufenen Knoten ausgeht
4. Wurde der Zielknoten bereits angelaufen, nimm die nächste Kante
5. Wiederhole Schritt 3 und 4 so lange, bis alle Knoten verbunden sind
6. Das Ergebnis ist ein minimaler Spannbaum

[[Bild:s3addank_MinSpann_9.jpg]]

<popup name = "Einzelschritte">
# [[Bild:s3addank_MinSpann_1.jpg]]
# [[Bild:s3addank_MinSpann_2.jpg]]
# [[Bild:s3addank_MinSpann_3.jpg]]
# [[Bild:s3addank_MinSpann_4.jpg]]
# [[Bild:s3addank_MinSpann_5.jpg]]
# [[Bild:s3addank_MinSpann_6.jpg]]
# [[Bild:s3addank_MinSpann_7.jpg]]
# [[Bild:s3addank_MinSpann_8.jpg]]
# [[Bild:s3addank_MinSpann_9.jpg]]
</popup>

===Vergleich zum Algorithmus von Kruskal===

Bei dem Algorithmus von Prim wird die nächste Kante aus allen möglichen Verbindungen zu noch nicht angelaufenen Knoten im Graphen ermittelt. Im Gegensatz dazu sucht der Algorithmus von Kruskal die günstigste Kante aus der Gesamtmenge aller Kanten im Graphen.