Alda - User contributions [en]

Greedy-Algorithmen und Dynamische Programmierung

2008-07-21T09:00:59Z

LDream: /* Beispiel zur Dynamischen Programmierung: Wighted Intervall Scheduling */

== Einführung ==
:Viele Probleme sind durch einen Entscheidungsbaum systematisch lösbar.
:Dabei wird die zu suchende Lösung auf den optimalen Weg durch den Entscheidungsbaum reduziert.

=== Beispiel ===
:''Erklärung des Algorithmus ist zu finden in [[Graphen und Graphenalgorithmen]]''
:Traveling Salesman Problem mit 4 Knoten

[[Image:tsm_points.JPG]]

:'''Dabei entsteht folgender Entscheidungsbaum:'''

[[Image:tsm4.JPG]]

::'''Vorteil des Entscheidungsbaums:''' Lösungsmöglichkeiten werden nicht übersehen
::'''Nachteil:''' Eventuell muss der gesamte Baum durchsucht werden (exponentielle Komplexität)
:Um diesen Nachteil auszugleichen gibt es verschiedene Verfahren:
:* Divide & Conquer (Problem auf triviale Teilprobleme zurückführen, welche jeweils einfach zu lösen sind)
:* Greedy Algorithmen
:* Dynamische Programmierung

== Greedy Algorithmen ==
:Greedy (dt. "Gierig") Algorithmen entscheiden an jedem Knoten '''lokal''' über die beste Fortsetzung der Suche,
:d.h. es wird jeweils die beste Entscheidung im Kleinen getroffen - ohne Rücksicht auf Konsequenzen für den gesamten Suchverlauf.

=== Beispiele ===
==== Anwendung beim Traveling Salesman Problem ====
:''Erklärung des Algorithmus ist zu finden in [[Graphen und Graphenalgorithmen]]''
:Reise immer zum nächstgelegenen, noch nicht besuchten Knoten:

[[Image:tsm_greedyb.JPG]]

:In diesem Beispiel wurde eine optimale Lösung gefunden. '''Dies muss im Allgemeinen aber nicht immer der Fall sein!'''

==== Anwendung beim Algorithmus von Kruskal für Minium Spanning Tree ====
:''Erklärung des Algorithmus ist zu finden in [[Graphen und Graphenalgorithmen]]''
:* Sortiere die Kanten nach Gewicht
:* Wähle stets die Kante mit niedrigstem Gewicht (d.h. im Allgemeinen die nächsgelegene), die keinen Zyklus verursacht

:Hierbei wird der Minimum Spanning Tree stets gefunden.

== Dynamische Programmierung ==
(''Programmierung'' hat hier eine Bedeutung die sich nicht auf Programmiersprachen bezieht)

:Oft ist dasselbe Teilproblem in mehreren Pfaden vorhanden.
=== Beispiel ===

[[Image:fib1.JPG]]

:Im Beispiel mit Fibonacci-Zahlen wird Fib(2) gleich dreimal benötigt.

:Zur Erinnerung: Die Fibonacci-Folge <math>(f_0, f_1,\ldots)</math> ist durch das rekursive Bildungsgesetz
:<math> f_n = f_{n-1} + f_{n-2}\ </math>   für <math>n\geq 2</math>
:mit den Anfangswerten
:<math>f_0=0\ </math>   und   <math>f_1=1\ </math>
:definiert.

=== Konzept der Dynamische Programmierung ===
:Jedes Teilproblem soll nur einmal gelöst werden, d.h. einige Knoten werden mehrmals genutzt:

[[Image:fib2.JPG]]

:Wie im Beispiel erkennbar, hat sich die Zahl der Knoten drastisch reduziert (von 9 auf 5).
:Allerdings müssen die '''Graphen jetzt gerichtet''' sein.

:Wenn der neue Graph '''azyklisch''' ist, kann man die Teilprobleme so anordnen, dass jedes
:* nur einmal gelöst wird
:* nur von bereits gelösten Teilproblemen abhängt

:Wenn der Graph nicht azyklisch ist (weil z.B. Teilproblem A die Lösung von Teilproblem B erfordert und umgekehrt),
:ist die Dynamische Programmierung auf dieses Problem nicht anwendbar.

==== Dynamisch programmierter Dijkstra Alrogithmus ====
:''Erklärung des Algorithmus ist zu finden in [[Graphen und Graphenalgorithmen]]''
:Löse Teilprobleme entsprechend ihrer Priorität, d.h. Priorität definiert die Ordnung

:'''Problem:''' Der Suchbaum ist bei diesem Algorithmus ungerichtet

:'''Lösung:''' Die Richtung der Kanten wird festgelegt, wenn man die Nachbarn eines Knotens in die Queue eingefügt
:Wenn man den Abstand vom Start bestimmt (Teilproblem), ist der Abstand von allen näher gelegenen bereits bekannt.

[[Image:dijkstra.JPG]]

== Greedy oder Dynamische Programmierung? ==
:Für viele Probleme gibt es unterschiedliche Entscheidungsräume und/oder unterschiedliche Entscheidungskriterien.
:Ein und dasselbe Problem kann also mit einer der Darstellungen (Greedy, Dynamische Programmierung, weitere...) effizient lösbar sein, mit anderen eventuell nicht.
:Das finden einer geeigneten Darstellung ist also eine zentrale Herausforderung.

== Anwendungsbeispiel: Interval Scheduling ==
:'''gegeben:'''
::Mehrere Aufgaben mit unterschiedlichen Anfangszeiten <math>s_i</math> und Endzeiten <math>f_i</math>.
::Es kann immer nur eine Aufgabe gleichzeitig bearbeitet werden: zwei Aktivitäten sind kompatibel, wenn deren Zeiten sich nicht überlappen.
::<math>a_k\,\text{komp}\, a_j \Leftrightarrow s_k\geq f_j\, \or \, s_j\geq f_k</math>
:'''gesucht:'''
::Arbeitsplan um möglichst viele Aufgaben nacheinander abzuarbeiten.
::Dabei haben alle Aufgaben dieselbe Priorität, obwohl die Dauer oft unterschiedlich ist.

=== Mögliche Lösungsansätze für einen Greedy Algorithmus ===
:# Wähle (unter kompatiblen) die Aktivität, die als erste startet
:# '''Wähle (unter kompatiblen) die Aktivität, die als erste endet (oder: die als letzte startet)'''
:# Wähle (unter kompatiblen) die Aktivität, die am kürzesten dauert
:# Wähle (unter kompatiblen) die Aktivität, die die wenigsten Inkompatibilitäten (überlappungen mit anderen Aktivitäten) hat

'''Ungünstige Ansätze:'''
:In den folgenden Beispielen werden die Aktivitäten mit | als Anfangs- bzw Endzeit markiert, --- steht für den Verlauf einer Aktivität.
:Weiter rechts bedeutet später in der Zeit.
:'''Gegenbeispiel zu 1.'''
<math>L_1=</math> |--| |--| |--| |--|
<math>L_2=</math>|---------------------|
<math>|L_1|</math>=4 <math>|L_2|</math>=1
:Der Ansatz würde Lösung 2 wählen, da die lange Aktivität am frühesten beginnt. Es wird dann nur 1 statt der optimalen 4 abgearbeitet.
:'''Gegenbeispiel zu 3.'''
<math>L_1=</math>|---------| |---------|
<math>L_2=</math> |----|
<math>|L_1|</math>=2 <math>|L_2|</math>=1
:Der Ansatz würde Lösung 2 wählen, da die mittlere Aktivität am kürzesten dauert. Es wird dann nur 1 statt der optimalen 2 abgearbeitet.
:'''Gegenbeispiel zu 4. (Anzahl der Inkompatibilitäten stehen jeweils in der Mitte der Aktivität)'''
|-3-| |-4-| |-4-| |-3-|
|-4-| |-2-| |-4-|
|-4-| |-4-|
|-4-| |-4-|
:Der Ansatz würde erst die mit 2, dann die beiden mit 3 Inkompatibilitäten wählen. Es werden dann nur 3 statt der optimalen 4 (obere Zeile) abgearbeitet.

Es verbleibt der 2. Ansatz, dessen Optimalität noch zu beweisen ist...

== Greedy Stays Ahead ==
==== Idee der Beweismethode ====
'''Es genügt zu zeigen:'''
:die Greedy-Lösung ist nicht schlechter als die optimale Lösung

=== Beweis der Optimalität des 2. Ansatzes mit ''Greedy Stays Ahead'' ===
==== Ansatz ====
:Wähle (unter kompatiblen) die Aktivität, die als erste endet (oder: die als letzte startet)
:Die Wahl dieses Ansatzes sei <math>U={i_1,...,i_k}</math>.
:Eine (unbekannte) optimale Lösung sei <math>O={j_1,...,j_m}</math>.

==== Ziel ====
:Die Lösung des Ansatzes soll genausoviele Aktivitäten schaffen wie die optimale Lösung (d.h. k=m)
==== Voraussetzungen ====
:* Sortiere <math>i_1,...,i_k</math> nach aufsteigender Endzeit <math>f_i</math>
:* Sortiere <math>j_1,...,j_m</math> nach aufsteigender Endzeit <math>f_j</math>

(Da die Aktivitäten kompatibel sind, werden die Anfangszeiten automatisch auch sortiert)

==== Schritt 1 ====
:Für die Indizes <math>p\leq r</math> (inbesondere <math>p=r</math>) gilt: <math>f(i_p)\leq f(j_r)</math>
==== Beweis durch vollständige Induktion ====
:'''Induktions-Anfang:'''
::<math>f(i_1)\leq f(j_1)</math>, da <math>i_1</math> die erste Aktivität ist, die überhaupt endet
:'''Induktions-Voraussetzung:'''
::<math>f(i_{r-1})\leq f(j_{r-1})</math>
:'''Induktions-Schritt:'''
::Wegen Kompatibilität gilt:
::<math>f(j_{r-1})\leq s(j_r)</math>
::=> <math>f(i_{r-1})\leq s(i_r)</math>
::=> Die Greedy Strategie ''kann'' Aktivität <math>j_r</math> wählen, denn sie ist kompatibel mit <math>i_{r-1}</math>
::* Wenn die Greedy Strategie tatsächlich <math>j_r</math> wählt, folgt daraus:
:::<math>f(i_r)=f(j_r)</math>
::* Wenn nicht, kann nur gelten:
:::<math>f(i_r)\leq f(j_r)</math>

==== Schritt 2 ====
:Zu zeigen: <math>k=m</math>
==== Beweis durch Widerspruchsannahme ====
:* Falls <math>m<k</math>, wäre die Lösung der Strategie besser als die optimale.
:* Angenommen <math>m>k</math>, dann enthält <math>O</math> eine Aktivität <math>j_{k+1}</math>.

:Nach Schritt 1 gilt:
::<math>f(i_k)\leq f(j_k)\leq f(j_{k+1})</math>

:Wegen Kompatibilität gilt aber:
::<math>s(j_{k+1})\geq f(j_k)\geq f(i_k)</math>
:-> Die Greedy Strategie hätte also noch die Aktivität <math>j_{k+1}</math> wählen können.
:-> Widerspruch zur Annahme, dass die Greedy Strategie durchgelaufen ist, bis keine Aktivität mehr hinzugefügt werden kann
:-> m>k ist falsch
:-> m=k ist richtig

=== Beispiel zur Dynamischen Programmierung: Weighted Intervall Scheduling ===
:Die Problemstellung ähnelt dem des normalen Intervall Scheduling, hier haben die Aktivitäten aber Gewichte <math>w_i</math>
:(z.B. Bringt eine längere Aufgabe in einem Übunsgzettel in der Regel auch mehr Punkte, d.h. sie hat eine hohe Gewichtung)
==== Ziel ====
:Wähle die Aktivitäten so, dass der Gewinn (Summe der Gewichtungen der bearbeiteten Aktivitäten) maximal wird.
==== Ansatz ====
:* Sortiere Aktivitäten nach ihrer Endzeit.
:* Definiere eine Funktion <math>p(i)</math>, welche für die Aktivität steht, die vor <math>a_i</math> endet, mit <math>a_i</math> kompatibel ist, unter allen Aktivitäten mit diesen Eigenschaften die letzte (d.h. mit der spätesten Endzeit) ist.

In folgendem Beispiel wird die Aktivität <math>a_i</math> mit der Symbolik |-!-| betrachtet um deren p-Funktion zu evaluieren.

Für die p-Funktion kommen lediglich die Funktionen mit der Symbolik |===| und |====| in Frage, die untere der beiden ist die gesuchte Aktivität.
|====| |-!-| |--|
|===| |-----| |----|

:Trivial ist, dass <math>a_n</math> entweder zur Lösung gehört, oder nicht:

[[Image:wis1.JPG]]

:Dadurch ergibt sich folgende Funktion:
:<math>OPT(n)=\begin{cases}
\ \;\, \{a_n\}\cup OPT(p(n))\\
\ \;\, OPT(a_{n-1})
\end{cases}
</math>

:Um den höchstmöglichen Gewinn zu erzielen, wird <math>\{a_n\}\cup OPT(p(n))</math> verwendet falls gilt:
:<math>w_n + Gewinn(OPT(p(n))\leq Gewinn(OPT(n-1))</math>

:Ansonsten wird <math>OPT(a_{n-1})</math> angewandt.

== Erinnerung: Intervalle ==

[[Image:bild1.JPG]]

Sortiere Intervalle nach aufsteigender <math> f_{i} </math>:
:Gewinn <math>(a_{n})</math> = max <math>(w_{n})</math> + Gewinn (p(n)), Gewinn <math> (a_{n-1})</math>
:Gewinn <math> (a_{n-1})</math> = max (<math>w_{n-1}</math> + Gewinn <math>(p(n-1)</math>), Gewinn <math> (a_{n-2})</math>
:usw.

[[Image:bild2.JPG]]

Bearbeite Teilprobleme in Reihenfolge der Sortierung
:=> azyklischer Graph
:(a2 hängt von a1 ab, a3 von a2, a4 von a2 und a3 usw.)

Wie erkennt man, ob der Graph azyklisch ist, und wie fndet man die Reihenfolge?
* azyklischer, gerichteter Graph: „directed acyclic graph“ – DAG
* Ein Graph ist genau dann ein DAG, wenn es eine topologische Sortierung der Knoten gibt.
:Def.: Zeichne die Knoten so auf eine Gerade, dass alle Kanten nach rechts/in dieselbe Richtung zeigen

[[Image:bild3.JPG]]

:=> arbeite topologische Sortierung von rechts nach links ab.

=== Beispiel ===
Wie erklärt man einem zerstreuten Professor, wie er sich morgens anziehen soll?

[[Image:bild4.JPG]]

:=> Die topologische Sortierung ist hier nicht eindeutig, z.B. ist nicht klar, ob zuerst die Strümpfe angezogen werden sollen oder die Unterhose. Wann die Uhr angelegt werden soll, ist überhaupt nicht festgelegt. Mit dieser Beschreibung käme der arme Professor wohl kaum zurecht.

[[Image:bild5.JPG]]

== Zwei Algorithmen zum Finden der topologischen Sortierung ==

=== Algorithmus 1 ===
# Suche einen Knoten mit Eingangsgrad 0 (ohne eingehende Pfeile), => in einem gerichteten azyklischen Graphen gibt es immer einen solchen Knoten
# Platziere diesen Knoten auf der Geraden (beliebig)
# Entferne den Knoten aus dem Graphen zusammen mit den ausgehenden Kanten
# Gehe zu 1., aber platziere in 2. immer rechts der vorhandenen Knoten (also der Knoten, die schon auf der Geraden vorhanden sind)
: => Wenn noch Knoten übrig sind, aber keiner Eingangsgrad 0 hat, muss der Graph zyklisch sein.

[[Image:bild6.JPG]]

Bild: Ein zyklischer Graph

=== Algorithmus 2 ===
Verwende Tiefensuche, um die Finishing Time zu bestimmen
: => zeichne Knoten nach abnehmender Finishing Time auf die Gerade

== Anwendung: Sequence Alignment / Edit Distance ==

:gegeben: zwei Wörter (allgemein: beliebige Zeichenfolgen)
:gesucht: Wie kann man die Buchstaben am besten in Übereinstimmung bringen?

:Beispiel: worte – norden

[[Image:bild7.JPG]]

Fälle:
# Matche a[i] mit b[j]. Falls a[i] == b[j], ist das gut. Andernfalls entstehen Kosten <math>K_{a[i], b[j]}</math>
# Wir überspringen a[i] oder b[j], => Kosten L

:gesucht: Alignment mit minimalen Kosten

[[Image:bild8.JPG]]

Lösung:
:Suche kürzesten Pfad von links oben nach rechts unten (z.B. mit dem [[Graphen und Graphenalgorithmen#Algorithmus von Dijkstra|Algorithmus von Dijkstra]])
:In unserem Beispiel von oben:

[[Image:bild9.JPG]]

=== Problemlösung durch einen Entscheidungsbaum ===
Greedy Algorithm und dynamische Programmierung:
Transformationen des Problems, sodass '''nicht''' der ganze Entscheidungsbaum durchlaufen werden muss.
=> effizient

* bei vielen Problemen ist keine Möglichkeit bekannt, das vollständige Durchlaufen des Entscheidungsbaumes zu vermeiden, z.B. [[Problem des Handlungsreisenden]] (TSP), 3-SAT
* Frage: Gibt es prinzipiell keinen effizienten Algorithmus, oder sind wir nur zu blöd?
* Derzeitiger Stand: viele dieser Probleme sind fundamental äquivalent „NP complete problems“ – „NP vollständig“ (NP = "nicht-deterministisch polynomiell")

Graphen und Graphenalgorithmen

2008-07-08T20:23:12Z

LDream: /* strongCC */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

= [http://de.wikipedia.org/wiki/Erfüllbarkeitsproblem_der_Aussagenlogik Erfüllbarkeitsproblem] =

geg.:
* n Boolsche Variablen <math>x_i \in \{True,False\}</math> und deren Negation <math>\neg x_i (i=1..n)</math>
* Logischer Ausdruck in <math>x_i,\neg x_i</math>
** zB <math>(x_1 \vee x_2) \wedge (x_3 \vee x_4)</math> ...

Grammatik eines logischen Ausdrucks(in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <DISJ>
<DISJ> ::= <CONJ> | <DISJ> <math>\vee</math> <CONJ>
<CONJ> ::= <TERM> | <CONJ> <math>\wedge</math> <TERM>
<TERM> ::= ( <EXPR> ) | <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

ges.: Eine Belegung der <math>x_i</math>, so dass der gegebene Ausdruck "True" wird

=== Naive Lösung ===
Probiere alle Bedingungen aus <math>\to</math> Komplexität <math>\mathcal{O}(2^{n}) \!</math> 
'''Im Allgemeinen ist das der effizienteste bekannte Algorithmus'''

== '''Normalformen''' von logischen Ausdrücken ==

=== k-Konjunktionen-Normalform(k-CNF) ===

* ein "Literal" ist eine Variable <math>x_i</math> oder deren Negation
* jeweils ''k'' Literale werden mit <math>\vee</math> in einer '''Disjunktion''' verknüpft
* Disjunktionen werden mit <math>\wedge</math> in einer '''Konjunktion''' verbunden

Grammatik eines Ausdrucks in k-CNF(wieder in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <CONJ>
<CONJ> ::= <DISJ> | <CONJ> <math>\wedge</math> <DISJ>
<DISJ> ::= ( <LIT> <math>\vee</math> ... <math>\vee</math> <LIT> ) 
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Beispiele:
* 3-CNF: <math>(x_1 \vee \neg x_2 \vee x_4) \wedge (x_2 \vee x_3 \vee \neg x_4) \wedge (\neg x_1 \vee x_4 \vee \neg x_5)</math>
* 2-CNF: <math>(x_1 \vee \neg x_2) \wedge (x_3 \vee x_4)</math> ...

Satz:
* Jeder logische Ausdruck kann in polynomieller Zeit in 3-CNF umgewandelt werden
* Im Allgemeinen kann ein logischer Ausdruck nicht in 2-CNF umgeschrieben werden

=== Implikationen-Normalform(INF) ===

Konjunktionen von Implikationen:
* zB <math>(x_1 \to x_2) \wedge (x_2 \to \neg x_3) \wedge (x_4 \to x_3)</math>

Grammatik eines Ausdrucks in INF(you know the drill ;)):
<EXP> ::= <CONJ>
<CONJ> ::= <IMPL> | <CONJ> <math>\wedge</math> <IMPL>
<IMPL> ::= ( <LIT> <math>\to</math> <LIT> )
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Satz:
* jeder Ausdruck in 2-CNF kann in INF umgewandelt werden:
*: <math> (x_i \vee x_j) \Leftrightarrow (\neg x_i \to x_j) \wedge (\neg x_j \to x_i) </math> ([http://de.wikipedia.org/wiki/Implikation#Eigenschaften_und_logische_Gesetze warum?])

Außerdem kann jeder Ausdruck in INF als gerichteter Graph dargestellt werden
# Jede Variable und ihre Negation sind 1 Knoten(dh insgesamt 2 Knoten)
# Jede Implikation ist eine gerichtete Kante

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

=== postOrderTime ===

## In einem Baum: besuche erst die Kinder, dann die Wurzel
def postOrderTime(graph):
visited = [None] * len(graph)
def visit(node, count):
#markiert, dass 'node' besucht wurde, aber noch nicht fertig ist
visited[node] = -1
for neighbor in graph[node]:
if visited[neighbor] is not None: continue
count = visit(neighbor, count)
visited[node] = count
count += 1
return count
count = 0
for node in range(len(graph)):
if visited[node] is not None: continue
count = visit(node, count)
return visited

=== transpose ===

## Kehre die Richtung der Pfeile in einem Graphen um (tut nichts fuer ungerichtete Pfeile und Graphen).
def transpose(graph):
grapht = [[] for k in range(len(graph))]
for node in range(len(graph)):
for neighbor in graph[node]:
grapht[neighbor].append(node)
return grapht

=== strongCC ===

## Jede Komponente durch e. Ankerknoten repräsentiert
## Jedes SCC ist die Menge aller Knoten mit identischem Ankterknoten
def strongCC(graph):
# Prinzip: Tiefensuche mit absteigender Post-Order-Time
postOrder = postOrderTime(graph)
# ordered = [(knotenindex, POT), ...]
ordered = zip(range(len(graph)), postOrder)
ordered.sort(lambda x,y: -cmp(x[1],y[1]))

grapht = transpose(graph)
anchors = [None] * len(graph)
def visit(node, anchor):
if anchors[node] is not None: return
anchors[node] = anchor
for neighbor in grapht[node]:
visit(neighbor, anchor)

for node in ordered:
visit(node[0], node[0])
return anchors

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>x_i == \neg x_i</math> ein Widerspruch ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit von INF: teste diese Eigenschaft für jede stark zusammenhängende Komponente
des Implikationengraphen

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T20:20:23Z

LDream: /* transpose */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

= [http://de.wikipedia.org/wiki/Erfüllbarkeitsproblem_der_Aussagenlogik Erfüllbarkeitsproblem] =

geg.:
* n Boolsche Variablen <math>x_i \in \{True,False\}</math> und deren Negation <math>\neg x_i (i=1..n)</math>
* Logischer Ausdruck in <math>x_i,\neg x_i</math>
** zB <math>(x_1 \vee x_2) \wedge (x_3 \vee x_4)</math> ...

Grammatik eines logischen Ausdrucks(in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <DISJ>
<DISJ> ::= <CONJ> | <DISJ> <math>\vee</math> <CONJ>
<CONJ> ::= <TERM> | <CONJ> <math>\wedge</math> <TERM>
<TERM> ::= ( <EXPR> ) | <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

ges.: Eine Belegung der <math>x_i</math>, so dass der gegebene Ausdruck "True" wird

=== Naive Lösung ===
Probiere alle Bedingungen aus <math>\to</math> Komplexität <math>\mathcal{O}(2^{n}) \!</math> 
'''Im Allgemeinen ist das der effizienteste bekannte Algorithmus'''

== '''Normalformen''' von logischen Ausdrücken ==

=== k-Konjunktionen-Normalform(k-CNF) ===

* ein "Literal" ist eine Variable <math>x_i</math> oder deren Negation
* jeweils ''k'' Literale werden mit <math>\vee</math> in einer '''Disjunktion''' verknüpft
* Disjunktionen werden mit <math>\wedge</math> in einer '''Konjunktion''' verbunden

Grammatik eines Ausdrucks in k-CNF(wieder in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <CONJ>
<CONJ> ::= <DISJ> | <CONJ> <math>\wedge</math> <DISJ>
<DISJ> ::= ( <LIT> <math>\vee</math> ... <math>\vee</math> <LIT> ) 
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Beispiele:
* 3-CNF: <math>(x_1 \vee \neg x_2 \vee x_4) \wedge (x_2 \vee x_3 \vee \neg x_4) \wedge (\neg x_1 \vee x_4 \vee \neg x_5)</math>
* 2-CNF: <math>(x_1 \vee \neg x_2) \wedge (x_3 \vee x_4)</math> ...

Satz:
* Jeder logische Ausdruck kann in polynomieller Zeit in 3-CNF umgewandelt werden
* Im Allgemeinen kann ein logischer Ausdruck nicht in 2-CNF umgeschrieben werden

=== Implikationen-Normalform(INF) ===

Konjunktionen von Implikationen:
* zB <math>(x_1 \to x_2) \wedge (x_2 \to \neg x_3) \wedge (x_4 \to x_3)</math>

Grammatik eines Ausdrucks in INF(you know the drill ;)):
<EXP> ::= <CONJ>
<CONJ> ::= <IMPL> | <CONJ> <math>\wedge</math> <IMPL>
<IMPL> ::= ( <LIT> <math>\to</math> <LIT> )
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Satz:
* jeder Ausdruck in 2-CNF kann in INF umgewandelt werden:
*: <math> (x_i \vee x_j) \Leftrightarrow (\neg x_i \to x_j) \wedge (\neg x_j \to x_i) </math> ([http://de.wikipedia.org/wiki/Implikation#Eigenschaften_und_logische_Gesetze warum?])

Außerdem kann jeder Ausdruck in INF als gerichteter Graph dargestellt werden
# Jede Variable und ihre Negation sind 1 Knoten(dh insgesamt 2 Knoten)
# Jede Implikation ist eine gerichtete Kante

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

=== postOrderTime ===

## In einem Baum: besuche erst die Kinder, dann die Wurzel
def postOrderTime(graph):
visited = [None] * len(graph)
def visit(node, count):
#markiert, dass 'node' besucht wurde, aber noch nicht fertig ist
visited[node] = -1
for neighbor in graph[node]:
if visited[neighbor] is not None: continue
count = visit(neighbor, count)
visited[node] = count
count += 1
return count
count = 0
for node in range(len(graph)):
if visited[node] is not None: continue
count = visit(node, count)
return visited

=== transpose ===

## Kehre die Richtung der Pfeile in einem Graphen um (tut nichts fuer ungerichtete Pfeile und Graphen).
def transpose(graph):
grapht = [[] for k in range(len(graph))]
for node in range(len(graph)):
for neighbor in graph[node]:
grapht[neighbor].append(node)
return grapht

=== strongCC ===

def strongCC(graph):
# Prinzip: Tiefensuche mit absteigender Post-Order-Time
postOrder = postOrderTime(graph)
ordered = zip(range(len(graph)), postOrder)
ordered.sort(lambda x,y: -cmp(x[1],y[1]))

grapht = transpose(graph)
anchors = [None] * len(graph)
def visit(node, anchor):
if anchors[node] is not None: return
anchors[node] = anchor
for neighbor in grapht[node]:
visit(neighbor, anchor)

for node in ordered:
visit(node[0], node[0])
return anchors

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>x_i == \neg x_i</math> ein Widerspruch ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit von INF: teste diese Eigenschaft für jede stark zusammenhängende Komponente
des Implikationengraphen

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T20:19:47Z

LDream: /* transpose */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

= [http://de.wikipedia.org/wiki/Erfüllbarkeitsproblem_der_Aussagenlogik Erfüllbarkeitsproblem] =

geg.:
* n Boolsche Variablen <math>x_i \in \{True,False\}</math> und deren Negation <math>\neg x_i (i=1..n)</math>
* Logischer Ausdruck in <math>x_i,\neg x_i</math>
** zB <math>(x_1 \vee x_2) \wedge (x_3 \vee x_4)</math> ...

Grammatik eines logischen Ausdrucks(in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <DISJ>
<DISJ> ::= <CONJ> | <DISJ> <math>\vee</math> <CONJ>
<CONJ> ::= <TERM> | <CONJ> <math>\wedge</math> <TERM>
<TERM> ::= ( <EXPR> ) | <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

ges.: Eine Belegung der <math>x_i</math>, so dass der gegebene Ausdruck "True" wird

=== Naive Lösung ===
Probiere alle Bedingungen aus <math>\to</math> Komplexität <math>\mathcal{O}(2^{n}) \!</math> 
'''Im Allgemeinen ist das der effizienteste bekannte Algorithmus'''

== '''Normalformen''' von logischen Ausdrücken ==

=== k-Konjunktionen-Normalform(k-CNF) ===

* ein "Literal" ist eine Variable <math>x_i</math> oder deren Negation
* jeweils ''k'' Literale werden mit <math>\vee</math> in einer '''Disjunktion''' verknüpft
* Disjunktionen werden mit <math>\wedge</math> in einer '''Konjunktion''' verbunden

Grammatik eines Ausdrucks in k-CNF(wieder in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <CONJ>
<CONJ> ::= <DISJ> | <CONJ> <math>\wedge</math> <DISJ>
<DISJ> ::= ( <LIT> <math>\vee</math> ... <math>\vee</math> <LIT> ) 
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Beispiele:
* 3-CNF: <math>(x_1 \vee \neg x_2 \vee x_4) \wedge (x_2 \vee x_3 \vee \neg x_4) \wedge (\neg x_1 \vee x_4 \vee \neg x_5)</math>
* 2-CNF: <math>(x_1 \vee \neg x_2) \wedge (x_3 \vee x_4)</math> ...

Satz:
* Jeder logische Ausdruck kann in polynomieller Zeit in 3-CNF umgewandelt werden
* Im Allgemeinen kann ein logischer Ausdruck nicht in 2-CNF umgeschrieben werden

=== Implikationen-Normalform(INF) ===

Konjunktionen von Implikationen:
* zB <math>(x_1 \to x_2) \wedge (x_2 \to \neg x_3) \wedge (x_4 \to x_3)</math>

Grammatik eines Ausdrucks in INF(you know the drill ;)):
<EXP> ::= <CONJ>
<CONJ> ::= <IMPL> | <CONJ> <math>\wedge</math> <IMPL>
<IMPL> ::= ( <LIT> <math>\to</math> <LIT> )
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Satz:
* jeder Ausdruck in 2-CNF kann in INF umgewandelt werden:
*: <math> (x_i \vee x_j) \Leftrightarrow (\neg x_i \to x_j) \wedge (\neg x_j \to x_i) </math> ([http://de.wikipedia.org/wiki/Implikation#Eigenschaften_und_logische_Gesetze warum?])

Außerdem kann jeder Ausdruck in INF als gerichteter Graph dargestellt werden
# Jede Variable und ihre Negation sind 1 Knoten(dh insgesamt 2 Knoten)
# Jede Implikation ist eine gerichtete Kante

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

=== postOrderTime ===

## In einem Baum: besuche erst die Kinder, dann die Wurzel
def postOrderTime(graph):
visited = [None] * len(graph)
def visit(node, count):
#markiert, dass 'node' besucht wurde, aber noch nicht fertig ist
visited[node] = -1
for neighbor in graph[node]:
if visited[neighbor] is not None: continue
count = visit(neighbor, count)
visited[node] = count
count += 1
return count
count = 0
for node in range(len(graph)):
if visited[node] is not None: continue
count = visit(node, count)
return visited

=== transpose ===

## Kehre die Richtung der Pfeile in einem Graphen um(tut nichts fuer ungerichtete Pfeile und Graphen).
def transpose(graph):
grapht = [[] for k in range(len(graph))]
for node in range(len(graph)):
for neighbor in graph[node]:
grapht[neighbor].append(node)
return grapht

=== strongCC ===

def strongCC(graph):
# Prinzip: Tiefensuche mit absteigender Post-Order-Time
postOrder = postOrderTime(graph)
ordered = zip(range(len(graph)), postOrder)
ordered.sort(lambda x,y: -cmp(x[1],y[1]))

grapht = transpose(graph)
anchors = [None] * len(graph)
def visit(node, anchor):
if anchors[node] is not None: return
anchors[node] = anchor
for neighbor in grapht[node]:
visit(neighbor, anchor)

for node in ordered:
visit(node[0], node[0])
return anchors

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>x_i == \neg x_i</math> ein Widerspruch ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit von INF: teste diese Eigenschaft für jede stark zusammenhängende Komponente
des Implikationengraphen

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T20:18:26Z

LDream: /* postOrderTime */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

= [http://de.wikipedia.org/wiki/Erfüllbarkeitsproblem_der_Aussagenlogik Erfüllbarkeitsproblem] =

geg.:
* n Boolsche Variablen <math>x_i \in \{True,False\}</math> und deren Negation <math>\neg x_i (i=1..n)</math>
* Logischer Ausdruck in <math>x_i,\neg x_i</math>
** zB <math>(x_1 \vee x_2) \wedge (x_3 \vee x_4)</math> ...

Grammatik eines logischen Ausdrucks(in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <DISJ>
<DISJ> ::= <CONJ> | <DISJ> <math>\vee</math> <CONJ>
<CONJ> ::= <TERM> | <CONJ> <math>\wedge</math> <TERM>
<TERM> ::= ( <EXPR> ) | <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

ges.: Eine Belegung der <math>x_i</math>, so dass der gegebene Ausdruck "True" wird

=== Naive Lösung ===
Probiere alle Bedingungen aus <math>\to</math> Komplexität <math>\mathcal{O}(2^{n}) \!</math> 
'''Im Allgemeinen ist das der effizienteste bekannte Algorithmus'''

== '''Normalformen''' von logischen Ausdrücken ==

=== k-Konjunktionen-Normalform(k-CNF) ===

* ein "Literal" ist eine Variable <math>x_i</math> oder deren Negation
* jeweils ''k'' Literale werden mit <math>\vee</math> in einer '''Disjunktion''' verknüpft
* Disjunktionen werden mit <math>\wedge</math> in einer '''Konjunktion''' verbunden

Grammatik eines Ausdrucks in k-CNF(wieder in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <CONJ>
<CONJ> ::= <DISJ> | <CONJ> <math>\wedge</math> <DISJ>
<DISJ> ::= ( <LIT> <math>\vee</math> ... <math>\vee</math> <LIT> ) 
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Beispiele:
* 3-CNF: <math>(x_1 \vee \neg x_2 \vee x_4) \wedge (x_2 \vee x_3 \vee \neg x_4) \wedge (\neg x_1 \vee x_4 \vee \neg x_5)</math>
* 2-CNF: <math>(x_1 \vee \neg x_2) \wedge (x_3 \vee x_4)</math> ...

Satz:
* Jeder logische Ausdruck kann in polynomieller Zeit in 3-CNF umgewandelt werden
* Im Allgemeinen kann ein logischer Ausdruck nicht in 2-CNF umgeschrieben werden

=== Implikationen-Normalform(INF) ===

Konjunktionen von Implikationen:
* zB <math>(x_1 \to x_2) \wedge (x_2 \to \neg x_3) \wedge (x_4 \to x_3)</math>

Grammatik eines Ausdrucks in INF(you know the drill ;)):
<EXP> ::= <CONJ>
<CONJ> ::= <IMPL> | <CONJ> <math>\wedge</math> <IMPL>
<IMPL> ::= ( <LIT> <math>\to</math> <LIT> )
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Satz:
* jeder Ausdruck in 2-CNF kann in INF umgewandelt werden:
*: <math> (x_i \vee x_j) \Leftrightarrow (\neg x_i \to x_j) \wedge (\neg x_j \to x_i) </math> ([http://de.wikipedia.org/wiki/Implikation#Eigenschaften_und_logische_Gesetze warum?])

Außerdem kann jeder Ausdruck in INF als gerichteter Graph dargestellt werden
# Jede Variable und ihre Negation sind 1 Knoten(dh insgesamt 2 Knoten)
# Jede Implikation ist eine gerichtete Kante

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

=== postOrderTime ===

## In einem Baum: besuche erst die Kinder, dann die Wurzel
def postOrderTime(graph):
visited = [None] * len(graph)
def visit(node, count):
#markiert, dass 'node' besucht wurde, aber noch nicht fertig ist
visited[node] = -1
for neighbor in graph[node]:
if visited[neighbor] is not None: continue
count = visit(neighbor, count)
visited[node] = count
count += 1
return count
count = 0
for node in range(len(graph)):
if visited[node] is not None: continue
count = visit(node, count)
return visited

=== transpose ===

def transpose(graph):
grapht = [[] for k in range(len(graph))]
for node in range(len(graph)):
for neighbor in graph[node]:
grapht[neighbor].append(node)
return grapht

=== strongCC ===

def strongCC(graph):
# Prinzip: Tiefensuche mit absteigender Post-Order-Time
postOrder = postOrderTime(graph)
ordered = zip(range(len(graph)), postOrder)
ordered.sort(lambda x,y: -cmp(x[1],y[1]))

grapht = transpose(graph)
anchors = [None] * len(graph)
def visit(node, anchor):
if anchors[node] is not None: return
anchors[node] = anchor
for neighbor in grapht[node]:
visit(neighbor, anchor)

for node in ordered:
visit(node[0], node[0])
return anchors

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>x_i == \neg x_i</math> ein Widerspruch ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit von INF: teste diese Eigenschaft für jede stark zusammenhängende Komponente
des Implikationengraphen

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T20:17:21Z

LDream: /* postOrderTime */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

= [http://de.wikipedia.org/wiki/Erfüllbarkeitsproblem_der_Aussagenlogik Erfüllbarkeitsproblem] =

geg.:
* n Boolsche Variablen <math>x_i \in \{True,False\}</math> und deren Negation <math>\neg x_i (i=1..n)</math>
* Logischer Ausdruck in <math>x_i,\neg x_i</math>
** zB <math>(x_1 \vee x_2) \wedge (x_3 \vee x_4)</math> ...

Grammatik eines logischen Ausdrucks(in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <DISJ>
<DISJ> ::= <CONJ> | <DISJ> <math>\vee</math> <CONJ>
<CONJ> ::= <TERM> | <CONJ> <math>\wedge</math> <TERM>
<TERM> ::= ( <EXPR> ) | <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

ges.: Eine Belegung der <math>x_i</math>, so dass der gegebene Ausdruck "True" wird

=== Naive Lösung ===
Probiere alle Bedingungen aus <math>\to</math> Komplexität <math>\mathcal{O}(2^{n}) \!</math> 
'''Im Allgemeinen ist das der effizienteste bekannte Algorithmus'''

== '''Normalformen''' von logischen Ausdrücken ==

=== k-Konjunktionen-Normalform(k-CNF) ===

* ein "Literal" ist eine Variable <math>x_i</math> oder deren Negation
* jeweils ''k'' Literale werden mit <math>\vee</math> in einer '''Disjunktion''' verknüpft
* Disjunktionen werden mit <math>\wedge</math> in einer '''Konjunktion''' verbunden

Grammatik eines Ausdrucks in k-CNF(wieder in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <CONJ>
<CONJ> ::= <DISJ> | <CONJ> <math>\wedge</math> <DISJ>
<DISJ> ::= ( <LIT> <math>\vee</math> ... <math>\vee</math> <LIT> ) 
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Beispiele:
* 3-CNF: <math>(x_1 \vee \neg x_2 \vee x_4) \wedge (x_2 \vee x_3 \vee \neg x_4) \wedge (\neg x_1 \vee x_4 \vee \neg x_5)</math>
* 2-CNF: <math>(x_1 \vee \neg x_2) \wedge (x_3 \vee x_4)</math> ...

Satz:
* Jeder logische Ausdruck kann in polynomieller Zeit in 3-CNF umgewandelt werden
* Im Allgemeinen kann ein logischer Ausdruck nicht in 2-CNF umgeschrieben werden

=== Implikationen-Normalform(INF) ===

Konjunktionen von Implikationen:
* zB <math>(x_1 \to x_2) \wedge (x_2 \to \neg x_3) \wedge (x_4 \to x_3)</math>

Grammatik eines Ausdrucks in INF(you know the drill ;)):
<EXP> ::= <CONJ>
<CONJ> ::= <IMPL> | <CONJ> <math>\wedge</math> <IMPL>
<IMPL> ::= ( <LIT> <math>\to</math> <LIT> )
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Satz:
* jeder Ausdruck in 2-CNF kann in INF umgewandelt werden:
*: <math> (x_i \vee x_j) \Leftrightarrow (\neg x_i \to x_j) \wedge (\neg x_j \to x_i) </math> ([http://de.wikipedia.org/wiki/Implikation#Eigenschaften_und_logische_Gesetze warum?])

Außerdem kann jeder Ausdruck in INF als gerichteter Graph dargestellt werden
# Jede Variable und ihre Negation sind 1 Knoten(dh insgesamt 2 Knoten)
# Jede Implikation ist eine gerichtete Kante

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

=== postOrderTime ===

## In einem Baum: besuche erst die Kinder, dann die Wurzel
def postOrderTime(graph):
visited = [None] * len(graph)
def visit(node, count):
visited[node] = -1
for neighbor in graph[node]:
if visited[neighbor] is not None: continue
count = visit(neighbor, count)
visited[node] = count
count += 1
return count
count = 0
for node in range(len(graph)):
if visited[node] is not None: continue
count = visit(node, count)
return visited

=== transpose ===

def transpose(graph):
grapht = [[] for k in range(len(graph))]
for node in range(len(graph)):
for neighbor in graph[node]:
grapht[neighbor].append(node)
return grapht

=== strongCC ===

def strongCC(graph):
# Prinzip: Tiefensuche mit absteigender Post-Order-Time
postOrder = postOrderTime(graph)
ordered = zip(range(len(graph)), postOrder)
ordered.sort(lambda x,y: -cmp(x[1],y[1]))

grapht = transpose(graph)
anchors = [None] * len(graph)
def visit(node, anchor):
if anchors[node] is not None: return
anchors[node] = anchor
for neighbor in grapht[node]:
visit(neighbor, anchor)

for node in ordered:
visit(node[0], node[0])
return anchors

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>x_i == \neg x_i</math> ein Widerspruch ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit von INF: teste diese Eigenschaft für jede stark zusammenhängende Komponente
des Implikationengraphen

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T20:13:05Z

LDream: /* strongSCC */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

= [http://de.wikipedia.org/wiki/Erfüllbarkeitsproblem_der_Aussagenlogik Erfüllbarkeitsproblem] =

geg.:
* n Boolsche Variablen <math>x_i \in \{True,False\}</math> und deren Negation <math>\neg x_i (i=1..n)</math>
* Logischer Ausdruck in <math>x_i,\neg x_i</math>
** zB <math>(x_1 \vee x_2) \wedge (x_3 \vee x_4)</math> ...

Grammatik eines logischen Ausdrucks(in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <DISJ>
<DISJ> ::= <CONJ> | <DISJ> <math>\vee</math> <CONJ>
<CONJ> ::= <TERM> | <CONJ> <math>\wedge</math> <TERM>
<TERM> ::= ( <EXPR> ) | <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

ges.: Eine Belegung der <math>x_i</math>, so dass der gegebene Ausdruck "True" wird

=== Naive Lösung ===
Probiere alle Bedingungen aus <math>\to</math> Komplexität <math>\mathcal{O}(2^{n}) \!</math> 
'''Im Allgemeinen ist das der effizienteste bekannte Algorithmus'''

== '''Normalformen''' von logischen Ausdrücken ==

=== k-Konjunktionen-Normalform(k-CNF) ===

* ein "Literal" ist eine Variable <math>x_i</math> oder deren Negation
* jeweils ''k'' Literale werden mit <math>\vee</math> in einer '''Disjunktion''' verknüpft
* Disjunktionen werden mit <math>\wedge</math> in einer '''Konjunktion''' verbunden

Grammatik eines Ausdrucks in k-CNF(wieder in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <CONJ>
<CONJ> ::= <DISJ> | <CONJ> <math>\wedge</math> <DISJ>
<DISJ> ::= ( <LIT> <math>\vee</math> ... <math>\vee</math> <LIT> ) 
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Beispiele:
* 3-CNF: <math>(x_1 \vee \neg x_2 \vee x_4) \wedge (x_2 \vee x_3 \vee \neg x_4) \wedge (\neg x_1 \vee x_4 \vee \neg x_5)</math>
* 2-CNF: <math>(x_1 \vee \neg x_2) \wedge (x_3 \vee x_4)</math> ...

Satz:
* Jeder logische Ausdruck kann in polynomieller Zeit in 3-CNF umgewandelt werden
* Im Allgemeinen kann ein logischer Ausdruck nicht in 2-CNF umgeschrieben werden

=== Implikationen-Normalform(INF) ===

Konjunktionen von Implikationen:
* zB <math>(x_1 \to x_2) \wedge (x_2 \to \neg x_3) \wedge (x_4 \to x_3)</math>

Grammatik eines Ausdrucks in INF(you know the drill ;)):
<EXP> ::= <CONJ>
<CONJ> ::= <IMPL> | <CONJ> <math>\wedge</math> <IMPL>
<IMPL> ::= ( <LIT> <math>\to</math> <LIT> )
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Satz:
* jeder Ausdruck in 2-CNF kann in INF umgewandelt werden:
*: <math> (x_i \vee x_j) \Leftrightarrow (\neg x_i \to x_j) \wedge (\neg x_j \to x_i) </math> ([http://de.wikipedia.org/wiki/Implikation#Eigenschaften_und_logische_Gesetze warum?])

Außerdem kann jeder Ausdruck in INF als gerichteter Graph dargestellt werden
# Jede Variable und ihre Negation sind 1 Knoten(dh insgesamt 2 Knoten)
# Jede Implikation ist eine gerichtete Kante

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

=== postOrderTime ===

def postOrderTime(graph):
visited = [None] * len(graph)
def visit(node, count):
visited[node] = -1
for neighbor in graph[node]:
if visited[neighbor] is not None: continue
count = visit(neighbor, count)
visited[node] = count
count += 1
return count
count = 0
for node in range(len(graph)):
if visited[node] is not None: continue
count = visit(node, count)
return visited

=== transpose ===

def transpose(graph):
grapht = [[] for k in range(len(graph))]
for node in range(len(graph)):
for neighbor in graph[node]:
grapht[neighbor].append(node)
return grapht

=== strongCC ===

def strongCC(graph):
# Prinzip: Tiefensuche mit absteigender Post-Order-Time
postOrder = postOrderTime(graph)
ordered = zip(range(len(graph)), postOrder)
ordered.sort(lambda x,y: -cmp(x[1],y[1]))

grapht = transpose(graph)
anchors = [None] * len(graph)
def visit(node, anchor):
if anchors[node] is not None: return
anchors[node] = anchor
for neighbor in grapht[node]:
visit(neighbor, anchor)

for node in ordered:
visit(node[0], node[0])
return anchors

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>x_i == \neg x_i</math> ein Widerspruch ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit von INF: teste diese Eigenschaft für jede stark zusammenhängende Komponente
des Implikationengraphen

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T19:58:48Z

LDream: /* Erfüllbarkeitsproblem */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

= [http://de.wikipedia.org/wiki/Erfüllbarkeitsproblem_der_Aussagenlogik Erfüllbarkeitsproblem] =

geg.:
* n Boolsche Variablen <math>x_i \in \{True,False\}</math> und deren Negation <math>\neg x_i (i=1..n)</math>
* Logischer Ausdruck in <math>x_i,\neg x_i</math>
** zB <math>(x_1 \vee x_2) \wedge (x_3 \vee x_4)</math> ...

Grammatik eines logischen Ausdrucks(in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <DISJ>
<DISJ> ::= <CONJ> | <DISJ> <math>\vee</math> <CONJ>
<CONJ> ::= <TERM> | <CONJ> <math>\wedge</math> <TERM>
<TERM> ::= ( <EXPR> ) | <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

ges.: Eine Belegung der <math>x_i</math>, so dass der gegebene Ausdruck "True" wird

=== Naive Lösung ===
Probiere alle Bedingungen aus <math>\to</math> Komplexität <math>\mathcal{O}(2^{n}) \!</math> 
'''Im Allgemeinen ist das der effizienteste bekannte Algorithmus'''

== '''Normalformen''' von logischen Ausdrücken ==

=== k-Konjunktionen-Normalform(k-CNF) ===

* ein "Literal" ist eine Variable <math>x_i</math> oder deren Negation
* jeweils ''k'' Literale werden mit <math>\vee</math> in einer '''Disjunktion''' verknüpft
* Disjunktionen werden mit <math>\wedge</math> in einer '''Konjunktion''' verbunden

Grammatik eines Ausdrucks in k-CNF(wieder in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <CONJ>
<CONJ> ::= <DISJ> | <CONJ> <math>\wedge</math> <DISJ>
<DISJ> ::= ( <LIT> <math>\vee</math> ... <math>\vee</math> <LIT> ) 
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Beispiele:
* 3-CNF: <math>(x_1 \vee \neg x_2 \vee x_4) \wedge (x_2 \vee x_3 \vee \neg x_4) \wedge (\neg x_1 \vee x_4 \vee \neg x_5)</math>
* 2-CNF: <math>(x_1 \vee \neg x_2) \wedge (x_3 \vee x_4)</math> ...

Satz:
* Jeder logische Ausdruck kann in polynomieller Zeit in 3-CNF umgewandelt werden
* Im Allgemeinen kann ein logischer Ausdruck nicht in 2-CNF umgeschrieben werden

=== Implikationen-Normalform(INF) ===

Konjunktionen von Implikationen:
* zB <math>(x_1 \to x_2) \wedge (x_2 \to \neg x_3) \wedge (x_4 \to x_3)</math>

Grammatik eines Ausdrucks in INF(you know the drill ;)):
<EXP> ::= <CONJ>
<CONJ> ::= <IMPL> | <CONJ> <math>\wedge</math> <IMPL>
<IMPL> ::= ( <LIT> <math>\to</math> <LIT> )
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Satz:
* jeder Ausdruck in 2-CNF kann in INF umgewandelt werden:
*: <math> (x_i \vee x_j) \Leftrightarrow (\neg x_i \to x_j) \wedge (\neg x_j \to x_i) </math> ([http://de.wikipedia.org/wiki/Implikation#Eigenschaften_und_logische_Gesetze warum?])

Außerdem kann jeder Ausdruck in INF als gerichteter Graph dargestellt werden
# Jede Variable und ihre Negation sind 1 Knoten(dh insgesamt 2 Knoten)
# Jede Implikation ist eine gerichtete Kante

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

=== postOrderTime ===

def postOrderTime(graph):
visited = [None] * len(graph)
def visit(node, count):
visited[node] = -1
for neighbor in graph[node]:
if visited[neighbor] is not None: continue
count = visit(neighbor, count)
visited[node] = count
count += 1
return count
count = 0
for node in range(len(graph)):
if visited[node] is not None: continue
count = visit(node, count)
return visited

=== transpose ===

def transpose(graph):
grapht = [[] for k in range(len(graph))]
for node in range(len(graph)):
for neighbor in graph[node]:
grapht[neighbor].append(node)
return grapht

=== strongSCC ===

def strongSCC(graph):
# Prinzip: Tiefensuche mit absteigender Post-Order-Time
postOrder = postOrderTime(graph)
ordered = zip(range(len(graph)), postOrder)
ordered.sort(lambda x,y: -cmp(x[1],y[1]))

grapht = transpose(graph)
anchors = [None] * len(graph)
def visit(node, anchor):
if anchors[node] is not None: return
anchors[node] = anchor
for neighbor in grapht[node]:
visit(neighbor, anchor)

for node in ordered:
visit(node[0], node[0])
return anchors

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>x_i == \neg x_i</math> ein Widerspruch ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit von INF: teste diese Eigenschaft für jede stark zusammenhängende Komponente
des Implikationengraphen

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T19:57:54Z

LDream: /* Anwendung auf 2-SAT Problem */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

= [http://de.wikipedia.org/wiki/Erfüllbarkeitsproblem_der_Aussagenlogik Erfüllbarkeitsproblem] =

geg.:
* n Boolsche Variablen <math>x_i \in \{True,False\}</math> und deren Negation <math>\neg x_i (i=1..n)</math>
* Logischer Ausdruck in <math>x_i,\neg x_i</math>
** zB <math>(x_1 \vee x_2) \wedge (x_3 \vee x_4)</math> ...

Grammatik eines logischen Ausdrucks(in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <DISJ>
<DISJ> ::= <CONJ> | <DISJ> <math>\vee</math> <CONJ>
<CONJ> ::= <TERM> | <CONJ> <math>\wedge</math> <TERM>
<TERM> ::= ( <EXPR> ) | <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

ges.: Eine Belegung der <math>x_i</math>, so dass der gegebene Ausdruck "True" wird

=== Naive Lösung ===
Probiere alle Bedingungen aus <math>\to</math> Komplexität <math>\mathcal{O}(2^{n}) \!</math> 
'''Im Allgemeinen ist das der effizienteste bekannte Algorithmus'''

== '''Normalformen''' von logischen Ausdrücken ==

=== k-Konjunktionen-Normalform(k-CNF) ===

* ein "Literal" ist eine Variable <math>x_i</math> oder deren Negation
* jeweils ''k'' Literale werden mit <math>\vee</math> in einer '''Disjunktion''' verknüpft
* Disjunktionen werden mit <math>\wedge</math> in einer '''Konjunktion''' verbunden

Grammatik eines Ausdrucks in k-CNF(wieder in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <CONJ>
<CONJ> ::= <DISJ> | <CONJ> <math>\wedge</math> <DISJ>
<DISJ> ::= ( <LIT> <math>\vee</math> ... <math>\vee</math> <LIT> ) 
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Beispiele:
* 3-CNF: <math>(x_1 \vee \neg x_2 \vee x_4) \wedge (x_2 \vee x_3 \vee \neg x_4) \wedge (\neg x_1 \vee x_4 \vee \neg x_5)</math>
* 2-CNF: <math>(x_1 \vee \neg x_2) \wedge (x_3 \vee x_4)</math> ...

Satz:
* Jeder logische Ausdruck kann in polynomieller Zeit in 3-CNF umgewandelt werden
* Im Allgemeinen kann ein logischer Ausdruck nicht in 2-CNF umgeschrieben werden

=== Implikationen-Normalform(INF) ===

Konjunktionen von Implikationen:
* zB <math>(x_1 \to x_2) \wedge (x_2 \to \neg x_3) \wedge (x_4 \to x_3)</math>

Grammatik eines Ausdrucks in INF(you know the drill ;)):
<EXP> ::= <CONJ>
<CONJ> ::= <IMPL> | <CONJ> <math>\wedge</math> <IMPL>
<IMPL> ::= ( <LIT> <math>\to</math> <LIT> )
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Satz:
* jeder Ausdruck in 2-CNF kann in INF umgewandelt werden:
*: <math> (x_i \vee x_j) \Leftrightarrow (\neg x_i \to x_j) \wedge (\neg x_j \to x_i) </math> ([http://de.wikipedia.org/wiki/Implikation#Eigenschaften_und_logische_Gesetze warum?])

Außerdem kann jeder Ausdruck in INF als gerichteter Graph dargestellt werden
# Jede Variable und ihre Negation sind 1 Knoten(dh insgesamt 2 Knoten)
# Jede Implikation ist eine gerichtete Kante

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

== Code ==

=== postOrderTime ===

def postOrderTime(graph):
visited = [None] * len(graph)
def visit(node, count):
visited[node] = -1
for neighbor in graph[node]:
if visited[neighbor] is not None: continue
count = visit(neighbor, count)
visited[node] = count
count += 1
return count
count = 0
for node in range(len(graph)):
if visited[node] is not None: continue
count = visit(node, count)
return visited

=== transpose ===

def transpose(graph):
grapht = [[] for k in range(len(graph))]
for node in range(len(graph)):
for neighbor in graph[node]:
grapht[neighbor].append(node)
return grapht

=== strongSCC ===

def strongSCC(graph):
# Prinzip: Tiefensuche mit absteigender Post-Order-Time
postOrder = postOrderTime(graph)
ordered = zip(range(len(graph)), postOrder)
ordered.sort(lambda x,y: -cmp(x[1],y[1]))

grapht = transpose(graph)
anchors = [None] * len(graph)
def visit(node, anchor):
if anchors[node] is not None: return
anchors[node] = anchor
for neighbor in grapht[node]:
visit(neighbor, anchor)

for node in ordered:
visit(node[0], node[0])
return anchors

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>x_i == \neg x_i</math> ein Widerspruch ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit von INF: teste diese Eigenschaft für jede stark zusammenhängende Komponente
des Implikationengraphen

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T19:52:27Z

LDream: /* strongSCC */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

= [http://de.wikipedia.org/wiki/Erfüllbarkeitsproblem_der_Aussagenlogik Erfüllbarkeitsproblem] =

geg.:
* n Boolsche Variablen <math>x_i \in \{True,False\}</math> und deren Negation <math>\neg x_i (i=1..n)</math>
* Logischer Ausdruck in <math>x_i,\neg x_i</math>
** zB <math>(x_1 \vee x_2) \wedge (x_3 \vee x_4)</math> ...

Grammatik eines logischen Ausdrucks(in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <DISJ>
<DISJ> ::= <CONJ> | <DISJ> <math>\vee</math> <CONJ>
<CONJ> ::= <TERM> | <CONJ> <math>\wedge</math> <TERM>
<TERM> ::= ( <EXPR> ) | <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

ges.: Eine Belegung der <math>x_i</math>, so dass der gegebene Ausdruck "True" wird

=== Naive Lösung ===
Probiere alle Bedingungen aus <math>\to</math> Komplexität <math>\mathcal{O}(2^{n}) \!</math> 
'''Im Allgemeinen ist das der effizienteste bekannte Algorithmus'''

== '''Normalformen''' von logischen Ausdrücken ==

=== k-Konjunktionen-Normalform(k-CNF) ===

* ein "Literal" ist eine Variable <math>x_i</math> oder deren Negation
* jeweils ''k'' Literale werden mit <math>\vee</math> in einer '''Disjunktion''' verknüpft
* Disjunktionen werden mit <math>\wedge</math> in einer '''Konjunktion''' verbunden

Grammatik eines Ausdrucks in k-CNF(wieder in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <CONJ>
<CONJ> ::= <DISJ> | <CONJ> <math>\wedge</math> <DISJ>
<DISJ> ::= ( <LIT> <math>\vee</math> ... <math>\vee</math> <LIT> ) 
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Beispiele:
* 3-CNF: <math>(x_1 \vee \neg x_2 \vee x_4) \wedge (x_2 \vee x_3 \vee \neg x_4) \wedge (\neg x_1 \vee x_4 \vee \neg x_5)</math>
* 2-CNF: <math>(x_1 \vee \neg x_2) \wedge (x_3 \vee x_4)</math> ...

Satz:
* Jeder logische Ausdruck kann in polynomieller Zeit in 3-CNF umgewandelt werden
* Im Allgemeinen kann ein logischer Ausdruck nicht in 2-CNF umgeschrieben werden

=== Implikationen-Normalform(INF) ===

Konjunktionen von Implikationen:
* zB <math>(x_1 \to x_2) \wedge (x_2 \to \neg x_3) \wedge (x_4 \to x_3)</math>

Grammatik eines Ausdrucks in INF(you know the drill ;)):
<EXP> ::= <CONJ>
<CONJ> ::= <IMPL> | <CONJ> <math>\wedge</math> <IMPL>
<IMPL> ::= ( <LIT> <math>\to</math> <LIT> )
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Satz:
* jeder Ausdruck in 2-CNF kann in INF umgewandelt werden:
*: <math> (x_i \vee x_j) \Leftrightarrow (\neg x_i \to x_j) \wedge (\neg x_j \to x_i) </math> ([http://de.wikipedia.org/wiki/Implikation#Eigenschaften_und_logische_Gesetze warum?])

Außerdem kann jeder Ausdruck in INF als gerichteter Graph dargestellt werden
# Jede Variable und ihre Negation sind 1 Knoten(dh insgesamt 2 Knoten)
# Jede Implikation ist eine gerichtete Kante

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

== Code ==

=== postOrderTime ===

def postOrderTime(graph):
visited = [None] * len(graph)
def visit(node, count):
visited[node] = -1
for neighbor in graph[node]:
if visited[neighbor] is not None: continue
count = visit(neighbor, count)
visited[node] = count
count += 1
return count
count = 0
for node in range(len(graph)):
if visited[node] is not None: continue
count = visit(node, count)
return visited

=== transpose ===

def transpose(graph):
grapht = [[] for k in range(len(graph))]
for node in range(len(graph)):
for neighbor in graph[node]:
grapht[neighbor].append(node)
return grapht

=== strongSCC ===

def strongSCC(graph):
# Prinzip: Tiefensuche mit absteigender Post-Order-Time
postOrder = postOrderTime(graph)
ordered = zip(range(len(graph)), postOrder)
ordered.sort(lambda x,y: -cmp(x[1],y[1]))

grapht = transpose(graph)
anchors = [None] * len(graph)
def visit(node, anchor):
if anchors[node] is not None: return
anchors[node] = anchor
for neighbor in grapht[node]:
visit(neighbor, anchor)

for node in ordered:
visit(node[0], node[0])
return anchors

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>\rightarrow \; x_i == \neg x_i</math> unmöglich ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit: teste die Eigenschaft

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T19:51:42Z

LDream: /* Code */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

= [http://de.wikipedia.org/wiki/Erfüllbarkeitsproblem_der_Aussagenlogik Erfüllbarkeitsproblem] =

geg.:
* n Boolsche Variablen <math>x_i \in \{True,False\}</math> und deren Negation <math>\neg x_i (i=1..n)</math>
* Logischer Ausdruck in <math>x_i,\neg x_i</math>
** zB <math>(x_1 \vee x_2) \wedge (x_3 \vee x_4)</math> ...

Grammatik eines logischen Ausdrucks(in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <DISJ>
<DISJ> ::= <CONJ> | <DISJ> <math>\vee</math> <CONJ>
<CONJ> ::= <TERM> | <CONJ> <math>\wedge</math> <TERM>
<TERM> ::= ( <EXPR> ) | <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

ges.: Eine Belegung der <math>x_i</math>, so dass der gegebene Ausdruck "True" wird

=== Naive Lösung ===
Probiere alle Bedingungen aus <math>\to</math> Komplexität <math>\mathcal{O}(2^{n}) \!</math> 
'''Im Allgemeinen ist das der effizienteste bekannte Algorithmus'''

== '''Normalformen''' von logischen Ausdrücken ==

=== k-Konjunktionen-Normalform(k-CNF) ===

* ein "Literal" ist eine Variable <math>x_i</math> oder deren Negation
* jeweils ''k'' Literale werden mit <math>\vee</math> in einer '''Disjunktion''' verknüpft
* Disjunktionen werden mit <math>\wedge</math> in einer '''Konjunktion''' verbunden

Grammatik eines Ausdrucks in k-CNF(wieder in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <CONJ>
<CONJ> ::= <DISJ> | <CONJ> <math>\wedge</math> <DISJ>
<DISJ> ::= ( <LIT> <math>\vee</math> ... <math>\vee</math> <LIT> ) 
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Beispiele:
* 3-CNF: <math>(x_1 \vee \neg x_2 \vee x_4) \wedge (x_2 \vee x_3 \vee \neg x_4) \wedge (\neg x_1 \vee x_4 \vee \neg x_5)</math>
* 2-CNF: <math>(x_1 \vee \neg x_2) \wedge (x_3 \vee x_4)</math> ...

Satz:
* Jeder logische Ausdruck kann in polynomieller Zeit in 3-CNF umgewandelt werden
* Im Allgemeinen kann ein logischer Ausdruck nicht in 2-CNF umgeschrieben werden

=== Implikationen-Normalform(INF) ===

Konjunktionen von Implikationen:
* zB <math>(x_1 \to x_2) \wedge (x_2 \to \neg x_3) \wedge (x_4 \to x_3)</math>

Grammatik eines Ausdrucks in INF(you know the drill ;)):
<EXP> ::= <CONJ>
<CONJ> ::= <IMPL> | <CONJ> <math>\wedge</math> <IMPL>
<IMPL> ::= ( <LIT> <math>\to</math> <LIT> )
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Satz:
* jeder Ausdruck in 2-CNF kann in INF umgewandelt werden:
*: <math> (x_i \vee x_j) \Leftrightarrow (\neg x_i \to x_j) \wedge (\neg x_j \to x_i) </math> ([http://de.wikipedia.org/wiki/Implikation#Eigenschaften_und_logische_Gesetze warum?])

Außerdem kann jeder Ausdruck in INF als gerichteter Graph dargestellt werden
# Jede Variable und ihre Negation sind 1 Knoten(dh insgesamt 2 Knoten)
# Jede Implikation ist eine gerichtete Kante

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

== Code ==

=== postOrderTime ===

def postOrderTime(graph):
visited = [None] * len(graph)
def visit(node, count):
visited[node] = -1
for neighbor in graph[node]:
if visited[neighbor] is not None: continue
count = visit(neighbor, count)
visited[node] = count
count += 1
return count
count = 0
for node in range(len(graph)):
if visited[node] is not None: continue
count = visit(node, count)
return visited

=== transpose ===

def transpose(graph):
grapht = [[] for k in range(len(graph))]
for node in range(len(graph)):
for neighbor in graph[node]:
grapht[neighbor].append(node)
return grapht

=== strongSCC ===

def strongSCC(graph):
# Prinzip: Tiefensuche mit absteigender Post-Order-Time
postOrder = postOrderTime(graph)
ordered = zip(range(len(graph)), postOrder)
ordered.sort(lambda x,y: -cmp(x[1],y[1]))

grapht = transpose(graph)
anchors = [None] * len(graph)

def visit(node, anchor):
if anchors[node] is not None: return
anchors[node] = anchor
for neighbor in grapht[node]:
visit(neighbor, anchor)

for node in ordered:
visit(node[0], node[0])
return anchors

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>\rightarrow \; x_i == \neg x_i</math> unmöglich ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit: teste die Eigenschaft

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T19:41:50Z

LDream: /* Code */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

= [http://de.wikipedia.org/wiki/Erfüllbarkeitsproblem_der_Aussagenlogik Erfüllbarkeitsproblem] =

geg.:
* n Boolsche Variablen <math>x_i \in \{True,False\}</math> und deren Negation <math>\neg x_i (i=1..n)</math>
* Logischer Ausdruck in <math>x_i,\neg x_i</math>
** zB <math>(x_1 \vee x_2) \wedge (x_3 \vee x_4)</math> ...

Grammatik eines logischen Ausdrucks(in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <DISJ>
<DISJ> ::= <CONJ> | <DISJ> <math>\vee</math> <CONJ>
<CONJ> ::= <TERM> | <CONJ> <math>\wedge</math> <TERM>
<TERM> ::= ( <EXPR> ) | <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

ges.: Eine Belegung der <math>x_i</math>, so dass der gegebene Ausdruck "True" wird

=== Naive Lösung ===
Probiere alle Bedingungen aus <math>\to</math> Komplexität <math>\mathcal{O}(2^{n}) \!</math> 
'''Im Allgemeinen ist das der effizienteste bekannte Algorithmus'''

== '''Normalformen''' von logischen Ausdrücken ==

=== k-Konjunktionen-Normalform(k-CNF) ===

* ein "Literal" ist eine Variable <math>x_i</math> oder deren Negation
* jeweils ''k'' Literale werden mit <math>\vee</math> in einer '''Disjunktion''' verknüpft
* Disjunktionen werden mit <math>\wedge</math> in einer '''Konjunktion''' verbunden

Grammatik eines Ausdrucks in k-CNF(wieder in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <CONJ>
<CONJ> ::= <DISJ> | <CONJ> <math>\wedge</math> <DISJ>
<DISJ> ::= ( <LIT> <math>\vee</math> ... <math>\vee</math> <LIT> ) 
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Beispiele:
* 3-CNF: <math>(x_1 \vee \neg x_2 \vee x_4) \wedge (x_2 \vee x_3 \vee \neg x_4) \wedge (\neg x_1 \vee x_4 \vee \neg x_5)</math>
* 2-CNF: <math>(x_1 \vee \neg x_2) \wedge (x_3 \vee x_4)</math> ...

Satz:
* Jeder logische Ausdruck kann in polynomieller Zeit in 3-CNF umgewandelt werden
* Im Allgemeinen kann ein logischer Ausdruck nicht in 2-CNF umgeschrieben werden

=== Implikationen-Normalform(INF) ===

Konjunktionen von Implikationen:
* zB <math>(x_1 \to x_2) \wedge (x_2 \to \neg x_3) \wedge (x_4 \to x_3)</math>

Grammatik eines Ausdrucks in INF(you know the drill ;)):
<EXP> ::= <CONJ>
<CONJ> ::= <IMPL> | <CONJ> <math>\wedge</math> <IMPL>
<IMPL> ::= ( <LIT> <math>\to</math> <LIT> )
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Satz:
* jeder Ausdruck in 2-CNF kann in INF umgewandelt werden:
*: <math> (x_i \vee x_j) \Leftrightarrow (\neg x_i \to x_j) \wedge (\neg x_j \to x_i) </math> ([http://de.wikipedia.org/wiki/Implikation#Eigenschaften_und_logische_Gesetze warum?])

Außerdem kann jeder Ausdruck in INF als gerichteter Graph dargestellt werden
# Jede Variable und ihre Negation sind 1 Knoten(dh insgesamt 2 Knoten)
# Jede Implikation ist eine gerichtete Kante

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

== Code ==

=== postOrderTime ===

def postOrderTime(graph):
visited = [None] * len(graph)
def visit(node, count):
visited[node] = -1
for neighbor in graph[node]:
if visited[neighbor] is not None: continue
count = visit(neighbor, count)
visited[node] = count
count += 1
return count
count = 0
for node in range(len(graph)):
if visited[node] is not None: continue
count = visit(node, count)
return visited

=== transpose ===

def transpose(graph):
grapht = [[] for k in range(len(graph))]
for node in range(len(graph)):
for neighbor in graph[node]:
grapht[neighbor].append(node)
return grapht

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>\rightarrow \; x_i == \neg x_i</math> unmöglich ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit: teste die Eigenschaft

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T19:39:19Z

LDream: /* Stark zusammenhängende Komponenten */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

= [http://de.wikipedia.org/wiki/Erfüllbarkeitsproblem_der_Aussagenlogik Erfüllbarkeitsproblem] =

geg.:
* n Boolsche Variablen <math>x_i \in \{True,False\}</math> und deren Negation <math>\neg x_i (i=1..n)</math>
* Logischer Ausdruck in <math>x_i,\neg x_i</math>
** zB <math>(x_1 \vee x_2) \wedge (x_3 \vee x_4)</math> ...

Grammatik eines logischen Ausdrucks(in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <DISJ>
<DISJ> ::= <CONJ> | <DISJ> <math>\vee</math> <CONJ>
<CONJ> ::= <TERM> | <CONJ> <math>\wedge</math> <TERM>
<TERM> ::= ( <EXPR> ) | <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

ges.: Eine Belegung der <math>x_i</math>, so dass der gegebene Ausdruck "True" wird

=== Naive Lösung ===
Probiere alle Bedingungen aus <math>\to</math> Komplexität <math>\mathcal{O}(2^{n}) \!</math> 
'''Im Allgemeinen ist das der effizienteste bekannte Algorithmus'''

== '''Normalformen''' von logischen Ausdrücken ==

=== k-Konjunktionen-Normalform(k-CNF) ===

* ein "Literal" ist eine Variable <math>x_i</math> oder deren Negation
* jeweils ''k'' Literale werden mit <math>\vee</math> in einer '''Disjunktion''' verknüpft
* Disjunktionen werden mit <math>\wedge</math> in einer '''Konjunktion''' verbunden

Grammatik eines Ausdrucks in k-CNF(wieder in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <CONJ>
<CONJ> ::= <DISJ> | <CONJ> <math>\wedge</math> <DISJ>
<DISJ> ::= ( <LIT> <math>\vee</math> ... <math>\vee</math> <LIT> ) 
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Beispiele:
* 3-CNF: <math>(x_1 \vee \neg x_2 \vee x_4) \wedge (x_2 \vee x_3 \vee \neg x_4) \wedge (\neg x_1 \vee x_4 \vee \neg x_5)</math>
* 2-CNF: <math>(x_1 \vee \neg x_2) \wedge (x_3 \vee x_4)</math> ...

Satz:
* Jeder logische Ausdruck kann in polynomieller Zeit in 3-CNF umgewandelt werden
* Im Allgemeinen kann ein logischer Ausdruck nicht in 2-CNF umgeschrieben werden

=== Implikationen-Normalform(INF) ===

Konjunktionen von Implikationen:
* zB <math>(x_1 \to x_2) \wedge (x_2 \to \neg x_3) \wedge (x_4 \to x_3)</math>

Grammatik eines Ausdrucks in INF(you know the drill ;)):
<EXP> ::= <CONJ>
<CONJ> ::= <IMPL> | <CONJ> <math>\wedge</math> <IMPL>
<IMPL> ::= ( <LIT> <math>\to</math> <LIT> )
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Satz:
* jeder Ausdruck in 2-CNF kann in INF umgewandelt werden:
*: <math> (x_i \vee x_j) \Leftrightarrow (\neg x_i \to x_j) \wedge (\neg x_j \to x_i) </math> ([http://de.wikipedia.org/wiki/Implikation#Eigenschaften_und_logische_Gesetze warum?])

Außerdem kann jeder Ausdruck in INF als gerichteter Graph dargestellt werden
# Jede Variable und ihre Negation sind 1 Knoten(dh insgesamt 2 Knoten)
# Jede Implikation ist eine gerichtete Kante

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

== Code ==

=== postOrderTime ===

def postOrderTime(graph):
visited = [None] * len(graph)
def visit(node, count):
visited[node] = -1
for neighbor in graph[node]:
if visited[neighbor] is not None: continue
count = visit(neighbor, count)
visited[node] = count
count += 1
return count
count = 0
for node in range(len(graph)):
if visited[node] is not None: continue
count = visit(node, count)
return visited

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>\rightarrow \; x_i == \neg x_i</math> unmöglich ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit: teste die Eigenschaft

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T19:23:53Z

LDream: /* Implikationen-Normalform(INF) */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

= [http://de.wikipedia.org/wiki/Erfüllbarkeitsproblem_der_Aussagenlogik Erfüllbarkeitsproblem] =

geg.:
* n Boolsche Variablen <math>x_i \in \{True,False\}</math> und deren Negation <math>\neg x_i (i=1..n)</math>
* Logischer Ausdruck in <math>x_i,\neg x_i</math>
** zB <math>(x_1 \vee x_2) \wedge (x_3 \vee x_4)</math> ...

Grammatik eines logischen Ausdrucks(in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <DISJ>
<DISJ> ::= <CONJ> | <DISJ> <math>\vee</math> <CONJ>
<CONJ> ::= <TERM> | <CONJ> <math>\wedge</math> <TERM>
<TERM> ::= ( <EXPR> ) | <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

ges.: Eine Belegung der <math>x_i</math>, so dass der gegebene Ausdruck "True" wird

=== Naive Lösung ===
Probiere alle Bedingungen aus <math>\to</math> Komplexität <math>\mathcal{O}(2^{n}) \!</math> 
'''Im Allgemeinen ist das der effizienteste bekannte Algorithmus'''

== '''Normalformen''' von logischen Ausdrücken ==

=== k-Konjunktionen-Normalform(k-CNF) ===

* ein "Literal" ist eine Variable <math>x_i</math> oder deren Negation
* jeweils ''k'' Literale werden mit <math>\vee</math> in einer '''Disjunktion''' verknüpft
* Disjunktionen werden mit <math>\wedge</math> in einer '''Konjunktion''' verbunden

Grammatik eines Ausdrucks in k-CNF(wieder in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <CONJ>
<CONJ> ::= <DISJ> | <CONJ> <math>\wedge</math> <DISJ>
<DISJ> ::= ( <LIT> <math>\vee</math> ... <math>\vee</math> <LIT> ) 
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Beispiele:
* 3-CNF: <math>(x_1 \vee \neg x_2 \vee x_4) \wedge (x_2 \vee x_3 \vee \neg x_4) \wedge (\neg x_1 \vee x_4 \vee \neg x_5)</math>
* 2-CNF: <math>(x_1 \vee \neg x_2) \wedge (x_3 \vee x_4)</math> ...

Satz:
* Jeder logische Ausdruck kann in polynomieller Zeit in 3-CNF umgewandelt werden
* Im Allgemeinen kann ein logischer Ausdruck nicht in 2-CNF umgeschrieben werden

=== Implikationen-Normalform(INF) ===

Konjunktionen von Implikationen:
* zB <math>(x_1 \to x_2) \wedge (x_2 \to \neg x_3) \wedge (x_4 \to x_3)</math>

Grammatik eines Ausdrucks in INF(you know the drill ;)):
<EXP> ::= <CONJ>
<CONJ> ::= <IMPL> | <CONJ> <math>\wedge</math> <IMPL>
<IMPL> ::= ( <LIT> <math>\to</math> <LIT> )
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Satz:
* jeder Ausdruck in 2-CNF kann in INF umgewandelt werden:
*: <math> (x_i \vee x_j) \Leftrightarrow (\neg x_i \to x_j) \wedge (\neg x_j \to x_i) </math> ([http://de.wikipedia.org/wiki/Implikation#Eigenschaften_und_logische_Gesetze warum?])

Außerdem kann jeder Ausdruck in INF als gerichteter Graph dargestellt werden
# Jede Variable und ihre Negation sind 1 Knoten(dh insgesamt 2 Knoten)
# Jede Implikation ist eine gerichtete Kante

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>\rightarrow \; x_i == \neg x_i</math> unmöglich ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit: teste die Eigenschaft

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T19:22:45Z

LDream: /* Implikationen-Normalform(INF) */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

= [http://de.wikipedia.org/wiki/Erfüllbarkeitsproblem_der_Aussagenlogik Erfüllbarkeitsproblem] =

geg.:
* n Boolsche Variablen <math>x_i \in \{True,False\}</math> und deren Negation <math>\neg x_i (i=1..n)</math>
* Logischer Ausdruck in <math>x_i,\neg x_i</math>
** zB <math>(x_1 \vee x_2) \wedge (x_3 \vee x_4)</math> ...

Grammatik eines logischen Ausdrucks(in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <DISJ>
<DISJ> ::= <CONJ> | <DISJ> <math>\vee</math> <CONJ>
<CONJ> ::= <TERM> | <CONJ> <math>\wedge</math> <TERM>
<TERM> ::= ( <EXPR> ) | <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

ges.: Eine Belegung der <math>x_i</math>, so dass der gegebene Ausdruck "True" wird

=== Naive Lösung ===
Probiere alle Bedingungen aus <math>\to</math> Komplexität <math>\mathcal{O}(2^{n}) \!</math> 
'''Im Allgemeinen ist das der effizienteste bekannte Algorithmus'''

== '''Normalformen''' von logischen Ausdrücken ==

=== k-Konjunktionen-Normalform(k-CNF) ===

* ein "Literal" ist eine Variable <math>x_i</math> oder deren Negation
* jeweils ''k'' Literale werden mit <math>\vee</math> in einer '''Disjunktion''' verknüpft
* Disjunktionen werden mit <math>\wedge</math> in einer '''Konjunktion''' verbunden

Grammatik eines Ausdrucks in k-CNF(wieder in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <CONJ>
<CONJ> ::= <DISJ> | <CONJ> <math>\wedge</math> <DISJ>
<DISJ> ::= ( <LIT> <math>\vee</math> ... <math>\vee</math> <LIT> ) 
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Beispiele:
* 3-CNF: <math>(x_1 \vee \neg x_2 \vee x_4) \wedge (x_2 \vee x_3 \vee \neg x_4) \wedge (\neg x_1 \vee x_4 \vee \neg x_5)</math>
* 2-CNF: <math>(x_1 \vee \neg x_2) \wedge (x_3 \vee x_4)</math> ...

Satz:
* Jeder logische Ausdruck kann in polynomieller Zeit in 3-CNF umgewandelt werden
* Im Allgemeinen kann ein logischer Ausdruck nicht in 2-CNF umgeschrieben werden

=== Implikationen-Normalform(INF) ===

Konjunktionen von Implikationen:
* zB <math>(x_1 \to x_2) \wedge (x_2 \to \neg x_3) \wedge (x_4 \to x_3)</math>

Grammatik eines Ausdrucks in INF(you know the drill ;)):
<EXP> ::= <CONJ>
<CONJ> ::= <IMPL> | <CONJ> <math>\wedge</math> <IMPL>
<IMPL> ::= ( <LIT> <math>\to</math> <LIT> )
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Satz:
* jeder Ausdruck in 2-CNF kann in INF umgewandelt werden:
*: <math> (x_i \vee x_j) \Leftrightarrow (\neg x_i \to x_j) \vee (\neg x_j \to x_i) </math> ([http://de.wikipedia.org/wiki/Implikation#Eigenschaften_und_logische_Gesetze warum?])

Außerdem kann jeder Ausdruck in INF als gerichteter Graph dargestellt werden
# Jede Variable und ihre Negation sind 1 Knoten(dh insgesamt 2 Knoten)
# Jede Implikation ist eine gerichtete Kante

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>\rightarrow \; x_i == \neg x_i</math> unmöglich ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit: teste die Eigenschaft

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T19:21:32Z

LDream: /* Implikationen-Normalform(INF) */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

= [http://de.wikipedia.org/wiki/Erfüllbarkeitsproblem_der_Aussagenlogik Erfüllbarkeitsproblem] =

geg.:
* n Boolsche Variablen <math>x_i \in \{True,False\}</math> und deren Negation <math>\neg x_i (i=1..n)</math>
* Logischer Ausdruck in <math>x_i,\neg x_i</math>
** zB <math>(x_1 \vee x_2) \wedge (x_3 \vee x_4)</math> ...

Grammatik eines logischen Ausdrucks(in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <DISJ>
<DISJ> ::= <CONJ> | <DISJ> <math>\vee</math> <CONJ>
<CONJ> ::= <TERM> | <CONJ> <math>\wedge</math> <TERM>
<TERM> ::= ( <EXPR> ) | <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

ges.: Eine Belegung der <math>x_i</math>, so dass der gegebene Ausdruck "True" wird

=== Naive Lösung ===
Probiere alle Bedingungen aus <math>\to</math> Komplexität <math>\mathcal{O}(2^{n}) \!</math> 
'''Im Allgemeinen ist das der effizienteste bekannte Algorithmus'''

== '''Normalformen''' von logischen Ausdrücken ==

=== k-Konjunktionen-Normalform(k-CNF) ===

* ein "Literal" ist eine Variable <math>x_i</math> oder deren Negation
* jeweils ''k'' Literale werden mit <math>\vee</math> in einer '''Disjunktion''' verknüpft
* Disjunktionen werden mit <math>\wedge</math> in einer '''Konjunktion''' verbunden

Grammatik eines Ausdrucks in k-CNF(wieder in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <CONJ>
<CONJ> ::= <DISJ> | <CONJ> <math>\wedge</math> <DISJ>
<DISJ> ::= ( <LIT> <math>\vee</math> ... <math>\vee</math> <LIT> ) 
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Beispiele:
* 3-CNF: <math>(x_1 \vee \neg x_2 \vee x_4) \wedge (x_2 \vee x_3 \vee \neg x_4) \wedge (\neg x_1 \vee x_4 \vee \neg x_5)</math>
* 2-CNF: <math>(x_1 \vee \neg x_2) \wedge (x_3 \vee x_4)</math> ...

Satz:
* Jeder logische Ausdruck kann in polynomieller Zeit in 3-CNF umgewandelt werden
* Im Allgemeinen kann ein logischer Ausdruck nicht in 2-CNF umgeschrieben werden

=== Implikationen-Normalform(INF) ===

Konjunktionen von Implikationen:
* zB <math>(x_1 \to x_2) \wedge (x_2 \to \neg x_3) \wedge (x_4 \to x_3)</math>

Grammatik eines Ausdrucks in INF(you know the drill ;)):
<EXP> ::= <CONJ> 
<CONJ> ::= <IMPL> | <CONJ> <math>\wedge</math> <IMPL>
<IMPL> ::= ( <LIT> <math>\to</math> <LIT> )
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Satz:
* jeder Ausdruck in 2-CNF kann in INF umgewandelt werden:
*: <math> (x_i \vee x_j) \Leftrightarrow (\neg x_i \to x_j) \vee (\neg x_j \to x_i) </math> ([http://de.wikipedia.org/wiki/Implikation#Eigenschaften_und_logische_Gesetze warum?])

Außerdem kann jeder Ausdruck in INF als gerichteter Graph dargestellt werden
# Jede Variable und ihre Negation sind 1 Knoten(dh insgesamt 2 Knoten)
# Jede Implikation ist eine gerichtete Kante

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>\rightarrow \; x_i == \neg x_i</math> unmöglich ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit: teste die Eigenschaft

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T19:15:48Z

LDream: /* Erfüllbarkeitsproblem */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

= [http://de.wikipedia.org/wiki/Erfüllbarkeitsproblem_der_Aussagenlogik Erfüllbarkeitsproblem] =

geg.:
* n Boolsche Variablen <math>x_i \in \{True,False\}</math> und deren Negation <math>\neg x_i (i=1..n)</math>
* Logischer Ausdruck in <math>x_i,\neg x_i</math>
** zB <math>(x_1 \vee x_2) \wedge (x_3 \vee x_4)</math> ...

Grammatik eines logischen Ausdrucks(in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <DISJ>
<DISJ> ::= <CONJ> | <DISJ> <math>\vee</math> <CONJ>
<CONJ> ::= <TERM> | <CONJ> <math>\wedge</math> <TERM>
<TERM> ::= ( <EXPR> ) | <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

ges.: Eine Belegung der <math>x_i</math>, so dass der gegebene Ausdruck "True" wird

=== Naive Lösung ===
Probiere alle Bedingungen aus <math>\to</math> Komplexität <math>\mathcal{O}(2^{n}) \!</math> 
'''Im Allgemeinen ist das der effizienteste bekannte Algorithmus'''

== '''Normalformen''' von logischen Ausdrücken ==

=== k-Konjunktionen-Normalform(k-CNF) ===

* ein "Literal" ist eine Variable <math>x_i</math> oder deren Negation
* jeweils ''k'' Literale werden mit <math>\vee</math> in einer '''Disjunktion''' verknüpft
* Disjunktionen werden mit <math>\wedge</math> in einer '''Konjunktion''' verbunden

Grammatik eines Ausdrucks in k-CNF(wieder in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]):
<EXP> ::= <CONJ>
<CONJ> ::= <DISJ> | <CONJ> <math>\wedge</math> <DISJ>
<DISJ> ::= ( <LIT> <math>\vee</math> ... <math>\vee</math> <LIT> ) 
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Beispiele:
* 3-CNF: <math>(x_1 \vee \neg x_2 \vee x_4) \wedge (x_2 \vee x_3 \vee \neg x_4) \wedge (\neg x_1 \vee x_4 \vee \neg x_5)</math>
* 2-CNF: <math>(x_1 \vee \neg x_2) \wedge (x_3 \vee x_4)</math> ...

Satz:
* Jeder logische Ausdruck kann in polynomieller Zeit in 3-CNF umgewandelt werden
* Im Allgemeinen kann ein logischer Ausdruck nicht in 2-CNF umgeschrieben werden

=== Implikationen-Normalform(INF) ===

Konjunktionen von Implikationen:
* zB <math>(x_1 \to x_2) \wedge (x_2 \to \neg x_3) \wedge (x_4 \to x_3)</math>

Grammatik eines Ausdrucks in INF(you know the drill ;)):
<EXP> ::= <CONJ> 
<CONJ> ::= <IMPL> | <CONJ> <math>\wedge</math> <IMPL>
<IMPL> ::= ( <LIT> <math>\to</math> <LIT> )
<LIT> ::= <VAR> | <math>\neg</math><VAR>
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>

Satz:
* jeder Ausdruck in 2-CNF kann in INF umgewandelt werden:
*: <math> (x_i \wedge x_j) \Leftrightarrow (\neg x_i \to x_j) \vee (\neg x_j \to x_i) </math>

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>\rightarrow \; x_i == \neg x_i</math> unmöglich ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit: teste die Eigenschaft

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T17:57:55Z

LDream: /* Erfüllbarkeitsproblem */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

= Erfüllbarkeitsproblem =

geg.:
* n Boolsche Variablen <math>x_i \in \{True,False\}</math> und deren Negation <math>\neg x_i (i=1..n)</math>
* Logischer Ausdruck in <math>x_i,\neg x_i</math>
*: zB <math>(x_1 \vee x_2) \wedge (x_3 \vee x_4)</math> ...

<code>
Grammatik(in [http://de.wikipedia.org/wiki/Backus-Naur-Form BNF]): 
<EXP> ::= <DISJ> 
<DISJ> ::= <CONJ> | <DISJ> <math>\vee</math> <CONJ> 
<CONJ> ::= <TERM> | <CONJ> <math>\wedge</math> <TERM> 
<TERM> ::= ( <EXPR> ) | <VAR> | <math>\neg</math><VAR> 
<VAR> ::= <math>x_1</math> | ... | <math>x_n</math>
</code>

ges.: Eine Belegung der <math>x_i</math>, so dass der gegebene Ausdruck "True" wird

=== Naive Lösung ===
Probiere alle Bedingungen aus <math>\to</math> Komplexität <math>\mathcal{O}(2^{n}) \!</math> 
'''Im Allgemeinen ist das der effizienteste bekannte Algorithmus'''

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>\rightarrow \; x_i == \neg x_i</math> unmöglich ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit: teste die Eigenschaft

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T17:18:09Z

LDream: /* Erfüllbarkeitsproblem */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

= Erfüllbarkeitsproblem =

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>\rightarrow \; x_i == \neg x_i</math> unmöglich ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit: teste die Eigenschaft

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T17:17:49Z

LDream: /* Erfüllbarkeitsproblem */

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

=== Erfüllbarkeitsproblem ===

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>\rightarrow \; x_i == \neg x_i</math> unmöglich ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit: teste die Eigenschaft

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''

Graphen und Graphenalgorithmen

2008-07-08T17:17:24Z

LDream:

== Einführung zu Graphen ==

=== Motivation -- Königsberger Brückenproblem ===
Leonhard Euler [http://de.wikipedia.org/wiki/Leonhard_Euler] erfand den Graphen-Formalismus 1736, um eine scheinbar banale Frage zu beantworten: Ist es möglich, in Königsberg (siehe Abbildung) einen Spaziergang zu unternehmen, bei dem jede der 7 Brücken genau einmal überquert wird?

[[Image:Koenigsberg.jpg]]

Ein Graph abstrahiert von der Geometrie des Problems und repräsentiert nur die Topologie. Jeder Stadtteil von Königsberg ist ein Knoten des Graphen, jede Brücke eine Kante. Der zum Brückenproblem gehörende Graph sieht also so aus:

O
/| \
\| \
O---O
/| /
\| /
O

Der gesuchte Spaziergang würde existieren, wenn es maximal 2 Knoten gäbe, an denen sich eine ungerade Zahl von Kanten trifft. Die Frage muss für Königsberg also verneint werden, denn hier gibt es vier solche Knoten.

Inzwischen haben Graphen ein riesige Zahl weiterer Anwendungen gefunden. Einige Beispiele:

* Landkarten:
** Knoten: Länder
** Kanten: gemeinsame Grenzen

* Logische Schaltkreise:
** Knoten: Gatter
** Kanten: Verbindungen

* Chemie (Summenformeln):
** Knoten: chemische Elemente
** Kanten: Bindungen

* Soziologie (StudiVZ)
** Soziogramm
*** Knoten: Personen
*** Kanten: Freund von ...

=== Definitionen ===

;Ungerichteter Graph: Ein ungerichteter Graph G = ( V, E ) besteht aus
:* einer endliche Menge V von Knoten (vertices)
:* einer endlichen Menge <math>E \subset V \times V</math> von Kanten (edges)
:Die Paare (u,v) und (v,u) gelten dabei als nur ''eine'' Kante (somit gilt die Symmetriebeziehung: (u,v) ∈ E => (v,u) ∈ E ). Die Anzahl der Kanten, die sich an einem Knoten treffen, wird als ''Grad'' (engl. ''degree'') dieses Knotens bezeichnet:
:::degree(v) = |{v' ∈ V | (v,v') ∈ E}|
:(Die Syntax |{...}| bezeichnet dabei die Mächtigkeit der angegebenen Menge, also die Anzahl der Elemente in der Menge.)

Der Graph des Königsberger Brückenproblems ist ungerichtet. Bezeichnet man die Knoten entsprechend des folgenden Bildes
c
/| \
\| \
b---d
/| /
\| /
a

gilt für die Knotengrade: <tt>degree(a) == degree(c) == degree(d) == 3</tt> und <tt>degree(b) == 5</tt>. Genauer muss man bei diesem Graphen von einem ''Multigraphen'' sprechen, weil es zwischen einigen Knotenpaaren (nämlich (a, b) sowie (b, c)) mehrere Kanten ("Mehrfachkanten") gibt. Wir werden in dieser Vorlesung nicht näher auf Multigraphen eingehen.

;Gerichteter Graph: Ein Graph heißt ''gerichtet'', wenn die Kanten (u,v) und (v,u) unterschieden werden. Die Kante (u,v) ∈ E wird nun als Kante von u nach v (aber nicht umgekehrt) interpretiert. Entsprechend unterscheidet man jetzt den ''eingehenden'' und den ''ausgehenden Grad'' jedes Knotens:
:*out_degree(v) = |{v' ∈ V | (v,v') ∈ E}| 
:*in_degree(v) = |{v' ∈ V| (v',v) ∈ E}|

Das folgende Bild zeigt einen gerichteten Graphen. Hier gilt <tt>out_degree(1) == out_degree(3) == in_degree(2) == in_degree(4) == 2</tt> und
<tt>in_degree(1) == in_degree(3) == out_degree(2) == out_degree(4) == 0</tt>:

[[Image:digraph.png|gerichteter Graph]]

 

;Vollständiger Graph: Ein vollständiger Graph ist ein ungerichteter Graph, bei dem jeder Knoten mit allen anderen Knoten verbunden ist.
:::<math>E = \{ (v,w) | v \in V, w \in V, v \ne w \}</math>
:Ein vollständiger Graph mit |V| Knoten hat <math>|E| = \frac{|V|(|V|-1)}{2}</math> Kanten.

Die folgenden Abbildungen zeigen die vollständigen Graphen mit einem bis fünf Knoten (auch als K1 bis K5 bezeichnet.

{| border="0" cellspacing="0" cellpadding="0" style="margin: 1em auto 1em auto"
|-
| [[Image:k1.png|frame|k1]]
| [[Image:k2.png|frame|k2]]
| [[Image:k3.png|frame|k3]]
|-
| [[Image:k4.png|frame|k4]]
| [[Image:k5.png|frame|k5]]
|
|}

''Rätsel'' 
Auf einer Party sind Leute. Alle stoßen miteinander an. Es hat 78 mal "Pling" gemacht.
Wieviele Leute waren da? Antwort: Jede Person ist ein Knoten des Graphen, jedes Antoßen eine Kante.
Da alle miteinander angestoßen haben, handelt es sich um einen vollständigen Graphen. Mit
|V|(|V|-1)/2 = 78 folgt, dass es 13 Personen waren.

 

;Gewichteter Graph: Ein Graph heißt ''gewichtet'', wenn jeder Kante eine reelle Zahl zugeordnet ist. Bei vielen Anwendungen beschränkt man sich auch auf nichtnegative reelle Gewichte. In einem gerichteten Graphen können die Gewichte der Kanten (u,v) und (v,u) unterschiedlich sein.

Die Gewichte kodieren Eigenschaften der Kanten, die für die jeweilige Anwendung interessant sind. Bei der Berechnung des maximalen Flusses in einem Netzwerk sind die Gewichte z.B. die Durchflusskapazitäten jeder Kante, bei der Suche nach kürzesten Weges kodieren Sie den Abstand zwischen den Endknoten der Kante, bei Währungsnetzwerken (jeder Knoten ist eine Währung) geben sie die Wechselkurse an, usw..

 

;Teilgraphen: Ein Graph G' = (V',E') ist ein Teilgraph eines Graphen G, wenn gilt:
:* V' &sube; V
:* E' ⊂ E
:Er heißt ''(auf)spannender Teilgraph'', wenn gilt:
:* V' = V
:Er heißt ''induzierter Teilgraph'', wenn gilt:
:* e = (u,v) ∈ E' ⊂ E ⇔ u ∈ V' und v ∈ V'
:Den von V' induzierten Teilgraphen erhält man also, indem man aus G alle Knoten löscht, die nicht in V' sind, sowie alle Kanten (und nur diese Kanten), die einen der gelöschten Knoten als Endknoten haben.

 

;Wege, Pfade, Zyklen, Kreise, Erreichbarkeit: Sei G = (V,E) ein Graph (ungerichtet oder gerichteter) Graph. Dann gilt folgende rekursive Definition:
:* Für v ∈ V ist (v) ein Weg der Länge 0 in G
:* Falls <math>(v_0, v_1, ..., v_{n-1})</math> ein Weg ist, und eine Kante <math>(v_{n-1}, v_n)\in E</math> existiert, dann ist auch <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ein Weg, und er hat die Länge n.
: Ein Weg ist also eine nichtleere Folge von Knoten, so dass aufeinander folgende Knoten stets durch eine Kante verbunden sind. Die Länge des Weges entspricht der Anzahl der Kanten im Weg (= Anzahl der Knoten - 1).
:* Ein ''Pfad'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, bei dem alle Knoten vi verschieden sind.
:* ''Ein Zyklus'' <math>(v_0, v_1, ..., v_{n-1}, v_n)</math> ist ein Weg, der zum Ausgangspunkt zurückkehrt, wenn also v0 = vn gilt.
:* Ein ''Kreis'' ist ein Zyklus ohne Überkreuzungen. Das heisst, es gilt v0 = vn und <math>(v_0, v_1, ..., v_{n-1})</math> ist ein Pfad.
:* Ein Knoten w ∈ V ist von einem anderen Knoten v ∈ V aus ''erreichbar'' genau dann, wenn ein Weg (v, ..., w) existiert. Wir schreiben dann <math>v \rightsquigarrow w</math>.
In einem ungerichteten Graph ist die Erreichbarkeits-Relation stets symmetrisch, das heisst aus <math>v \rightsquigarrow w</math> folgt <math>w \rightsquigarrow v</math>. In einem gerichteten Graphen ist dies im allgemeinen nicht der Fall.

Bestimmte Wege haben spezielle Namen

;Eulerweg: Ein Eulerweg ist ein Weg, der alle '''Kanten''' genau einmal enthält.

Die eingangs erwähnte Frage des Königsberger Brückenproblems ist equivalent zu der Frage, ob der dazugehörige Graph einen Eulerweg besitzt (daher der Name). Ein anderes bekanntes Beispiel ist das "Haus vom Nikolaus": Wenn man diesen Graphen in üblicher Weise in einem Zug zeichnet, erhält man gerade den Eulerweg.

O
/ \
O----O
| \/ |
| /\ | "Das Haus vom Nikolaus": Alle ''Kanten'' werden nur ''einmal'' passiert
O----O

;Hamiltonweg: Ein Hamiltonweg ist ein Weg, der alle '''Knoten''' genau einmal enthält. Das "Haus vom Nikolaus" besitzt auch einen Hamiltonweg:

O
/
O----O
/
/ Alle ''Knoten'' werden nur ''einmal'' passiert
O----O

;Hamiltonkreis: Ein Hamiltonkreis ist ein Kreis, der alle '''Knoten''' genau einmal enthält. Auch ein solches Gebilde ist im Haus von Nilolaus enthalten:

O
/ \
O O
| | v0 = vn
| | vi != vj Für Alle i,j i !=j; i,j >0; i,j < n
O----O

Die folgende Skizze zeigt hingegen einen Zyklus: Der Knoten rechts unten sowie die untere Kante sind zweimal enthalten (die Kante einmal von links nach rechts und einmal von rechts nach links):

O
/ \
O O
\ |
\ | Zyklus
O====O

 

;Zusammenhang, Zusammenhangskomponenten: Ein ungerichteter Graph G heißt ''zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math>
:Ein gerichteter Graph G ist zusammenhängend, wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''oder''' <math>w \rightsquigarrow v</math>.
:Er ist ''stark zusammenhängend'', wenn für alle v,w ∈ V gilt:
:::<math>v \rightsquigarrow w</math> '''und''' <math>w \rightsquigarrow v</math>.
:Entsprechende Definitionen gelten für Teilgraphen G'. Ein Teilgraph G' heisst ''Zusammenhangskomponente'' von G, wenn er ein ''maximaler'' zusammenhängender Teilgraph ist, d.h. wenn G' zusammenhängend ist, und man keine Knoten und Kanten aus G mehr zu G' hinzufügen kann, so dass G' immer noch zusammenhängend bleibt. Entsprechend definiert man ''starke Zusammenhangskomponenten'' in einem gerichteten Graphen.

 

;Planarer Graph, ebener Graph: Ein Graph heißt ''planar'', wenn er so in einer Ebene gezeichnet werden ''kann'', dass sich die Kanten nicht schneiden (außer an den Knoten). Ein Graph heißt ''eben'', wenn er tatsächlich so gezeichnet ''ist'', dass sich die Kanten nicht schneiden. Die Einbettung in die Ebene ist im allgemeinen nicht eindeutig.

'''Beispiele:'''

Der folgende Graph ist planar und eben:

O
/|\
/ O \
/ / \ \
O O

Das "Haus vom Nikolaus" ist ebenfalls planar, wird aber üblicherweise nicht als ebener Graph gezeichnet, weil sich die Diagonalen auf der Wand überkreuzen:

O
/ \
O----O
| \/ |
| /\ |
O----O

Eine ebene Einbettung dieses Graphen wird erreicht, wenn man eine der Diagonalen ausserhalb des Hauses zeichnet. Der Graph (also die Menge der Knoten und Kanten) ändert sich dadurch nicht.

O
/ \
|--O----O
| | / |
| | / |
| O----O Das "Haus vom Nikolaus" als ebener Graph gezeichnet.
| |
|-------|

Eine alternative Einbettung erhalten wir, wenn wir die andere Diagonale außerhalb des Hauses zeichnen:

O
/ \
O----O--|
| \ | |
| \ | |
O----O | Alternative Einbettung des "Haus vom Nikolaus".
| |
|-------|

Jede Einbettung eines planaren Graphen (also jeder ebene Graph) definiert eine eindeutige Menge von ''Regionen'':

|----O @
| /@ \
| O----O
| |@ / |
| | / @|
| O----O @ entspricht jeweils einer ''Region''. Auch ausserhalb der Figur ist eine Region (die sogenannte ''unendliche'' Region).
|@ |
|-------|

Der vollständige Graph K5 ist kein planarer Graph, da sich zwangsweise Kanten schneiden, wenn man diesen Graphen in der Ebene zeichnet.

 
;Dualer Graph: Jeder ebene Graph G = (V, E) hat einen ''dualen Graphen'' D = (VD, ED), dessen Knoten und Kanten wie folgt definiert sind:
:* VD enthält einen Knoten für jede Region des Graphen G
:* Für jede Kante e ∈ E gibt es eine duale Kante eD ∈ ED, die die an e angrenzenden Regionen (genauer: die entsprechenden Knoten in D) verbindet.

DIe folgende Abbildung zeigt einen Graphen (grau) und seinen dualen Graphen (schwarz). Die Knoten des dualen Graphen sind mit Zahlen gekennzeichnet und entsprechen den Regionen des Originalgraphen. Jeder (grauen) Kante des Originalgraphen entspricht eine (schwarze) Kante des dualen Graphen.

 
[[Image:dual-graphs.png]]
 

Für duale Graphen gilt: Jede Region des dualen Graphen enthält genau einen Knoten des Originalgraphen. Deshalb ist der duale Graph des dualen Graphen wieder der Originalgraph.

=== Repräsentation von Graphen ===

Sei G = ( V, E ) gegeben und liege V in einer linearen Sortierung vor. 
:::<math>V = \{ v_1, ...., v_n \}</math>

;Adjazenzmatrix: Ein Graph kann durch eine Adjazenzmatrix repräsentiert werden, die soviele Zeilen und Spalten enthält, wie der Graph Knoten hat. Die Elemente der Adjazenzmatrix sind "1", falls eine Kante zwischen den zugehörigen Knoten existiert:
:::<math>\mathrm{\bold A} = a_{ij} =
\begin{cases}
1 & \mathrm{falls}\quad (v_i, v_j) \in E \\
0 & \mathrm{sonst}
\end{cases}
</math>
:Die Indizes der Matrix entsprechen also den Indizes der Knoten gemäß der gegebenen Sortierung. Im Falle eines ungerichteten Graphen ist die Adjazenzmatrix stets symmetrisch (d.h. es gilt <math>a_{ij}=a_{ji}</math>), bei einem gerichteten Graphen ist sie im allgemeinen unsymmetrisch.

Beispiel für einen ungerichteten Graphen:

v = { a,b,c,d } b d
| \ / |
| \/ |
| /\ |
| / \ |
a c

a b c d
-----------
(0 1 0 1) |a
A = (1 0 1 0) |b
(0 1 0 1) |c
(1 0 1 0) |d

Die Adjazenzmatrixdarstellung eignet sich besonders für dichte Graphen (d.h. wenn die Zahl der Kanten in O(|V|2) ist.

;Adjazenzlisten: In der Adjazenzlistendarstellung wird der Graph als Liste von Knoten repräsentiert, die für jeden Knoten einen Eintrag enthält. Der Eintrag für jeden Knoten ist wiederum eine Liste, die die Nachbarknoten dieses Knotens enthält:
:* graph = {adjazencyList(v) | v ∈ V}
:* adjazencyList(v) = {v' ∈ V | (v, v') ∈ E}

In Python implementieren wir Adjazenzlisten zweckmäßig als Array von Arrays:

graph = [[...],[...],...,[...]]
Adjazenzliste für Knoten => 0 1 n

Wenn wir bei dem Graphen oben die Knoten wie bei der Adjazenzmatrix indizieren (also <tt>a => 0</tt>, <tt>b => 1</tt>, <tt>c => 2</tt>, <tt>d => 3</tt>), erhalten wir die Adjazenzlistendarstellung:

graph = [[b, d], [a, c],[b, d], [a, c]]

Auf die Nachbarknoten eines durch seinen Index <tt>node</tt> gegebenen Knotens können wir also wie folgt zugreifen:

for neighbors in graph[node]:
... # do something with neighbor

Die Adjazenzlistendarstellung ist effizienter, wenn der Graph nicht dicht ist, so dass viele Einträge der Adjazenzmatrix Null wären.

;Transponierter Graph: Den ''transponierten Graphen'' GT eines gerichteten Graphen G erhält man, wenn man alle Kantenrichtungen umkehrt.

Bei ungerichteten Graphen hat die Transposition offensichtlich keinen Effekt, weil alle Kanten bereits in beiden Richtungen vorhanden sind, so dass GT = G gilt. Bei gerichteten Graphen ist die Transposition dann einfach, wenn der Graph als Adjazenzmatrix implementiert ist, weil man einfach die transponierte Adjazenzmatrix verwenden muss (beachte, dass sich die Reihenfolge der Indizes umkehrt):
:::AT = aji
Ist der Graph hingegen durch eine Adjazenzliste repräsentiert, muss etwas mehr Aufwand getrieben werden:

def transpose(graph):
gt = [[] for k in graph] # zunächst leere Adjazenzlisten von GT
for node in range(len(graph)):
for neighbor in graph[node]:
gt[neighbor].append(node) # füge die umgekehrte Kante in GT ein
return gt

== Bäume und Wälder ==

;Baum: Ein ''Baum'' ist ein zusammenhängender, kreisfreier Graph.

Beispiel: Binärer Suchbaum

;Spannbaum: Ein ''Spannbaum'' eines zusammenhängenden Graphen G ist ein zusammenhängender, kreisfreier Teilgraph von G, der alle Knoten von G enthält

Beispiel: Spannbaum für das "Haus des Nikolaus"

O
/
O O
| /
| /
O----O

Der Spannbaum eines Graphen mit |V| Knoten hat stets |V| - 1 Kanten.

;Wald: Ein ''Wald'' ist ein unzusammenhängender, kreisfreier Graph.
: Jede Zusammenhangskomponente eines Waldes ist ein Baum.

== Durchlaufen von Graphen ==

=== Tiefensuche in Graphen ===

Sei der Graph gegeben als Liste von Listen = g

def dfs (g,node,v=0):
if v == 0:
v = [0]*len(g) #visited-Liste
v[node] = 1 #besuche node
for t in g[node]: #gehe zu allen Nachbarn
if v[t] == 0: #falls diese noch nicht besucht
dfs(g,t,v) #Rekursion

[[Image:Tiefens.jpg]]

Aufruf dfs(g,1)

=>Folge 1,2,4,3,6,7,5

=== Breitensuche ===

from Queue import *
def bfs(g,startnode)
v = [0]*len(g)
q = Queue()
v = [startnode] = 1 #besuche
q.put(startnode) #in Schlange
while not q.get()
node = q.get()
for t in q[node]
if v[t] == 0:
v[t] = 1
q.put(t)

[[Image:Breitens.jpg]]

=>Folge 1,2,3,4,5,6,7

== Damenproblem ==

---------------
| | X | | |
|---|---|---|---|
| | | | X |
|---|---|---|---|
| X | | | |
|---|---|---|---|
| | | | X |
---------------

4 Damen auf einem vereinfachten Schachbrett so Positionieren, dass sich keine bedroht.

erster Durchlauf:

[[Image:Suche1.jpg]]

zweiter Durchlauf:

[[Image:Suche2.jpg]]

== Weitere Anwendungen (18.06.08) ==

def dfs(graph):
'''
Diese Tiefensuche tut so noch nichts weiter als zu traversieren
+ graph ist Array,
i-ter Eintrag enthaelt Adjazenzliste (auch Array) des i-ten Knotens,
wobei Knoten nummeriert von 0 ... v-i
'''
def visit(graph, node, visited):
'''
visited ist Array mit Flags fuer besuchte Knoten
'''
if visited[node]: return
visited[node] = True
for neighbor in graph[node]:
visit(graph, neighbor, visited)

visited = [False]*len(graph)
for node in range(len(graph)):
visit(graph, node, visited)

=== Finden von Zusammenhangskomponenten ===

Ein moeglicher Einsatz des Verfahrens ist das Finden von Zusammenhangskomponenten (connected components).

* Beispiel: ...

* Definition: CC_i = {u_k, u_l e V: es gibt einen Pfad von u_k nach u_l ("u_l ist von u_k aus erreichbar")
* fuer ungerichtete Graphen gilt zusaetzlich: es gibt einen Pfad von u_l nach u_k}

Die Relation CC_i, also die Zusammenhangskomponenten (ZK) bilden eine Aequivalenzrelation,
also kann fuer jede ZK ein Repraesentant bestimmt werden (der sog. "Anker"). Kennt jeder
Knoten seinen Anker, so ist das ZK-Problem geloest.

==== Tiefensuchen-Algorithmus ====

Unser erster Ansatz ist, den Anker mit Hilfe der Tiefensuche zu finden, wobei statt
Knotenbesuche Knotennummern fuer die schon gefundenen Anker gesetzt werden. Ein moeglicher
Algorithmus lautet damit wie folgt:

def connectedComponents(graph):
def visit(graph, node, anchors, anchor):
'''
anchor ist Anker der aktuellen ZK
'''
if anchors[node] is not None: return # Anker von <node> schon bekannt
anchors[node] = anchor
for neighbor in graph[node]
visit(graph, neighbor, anchors, anchor)

anchors = [None]*len(graph)
for node in range(len(graph)):
visit(graph, node, anchors, node) # node: Anker der naechste ZK = erster Knoten der ZK
return anchors

* Beispiel: ...

==== Union-Find-Algorithmus ====

Eine Alternative (ohne Tiefensuche) waere z.B. ein Union-Find-Algorithmus. Idee dabei ist, dass eingangs jeder Knoten eine eigene ZK bildet, wobei in einer anschliessenden Rekursion Kanten gesucht werden, die zwischen den ZK bestehen.

Initialisierung: jeder Knoten wird als 1 ZK behandelt
Rekursion: fasse ZK zusammen (Union) falls Kante zwischen ihnen existiert
Ergebnis: Array mit dem Anker jedes Knotens

def unionFindCC(graph):
def findAnchor(anchors, k):
'''
Prueft auf anchors[k]==k
'''
while anchors[k] != k:
k = anchors[k]
return k

def edges(graph):
e = []
for node in range(len(graph)):
for n in graph[node]:
if node < n:
e.append((node, n))
return e

anchors = range(len(graph)) # jeder Knoten ist sein eigener Anker
for edge in edges(graph):
# diese Schleife ordnet die Anker so, dass
# der 1. Anker immer der kleinste ist
a1, a2 = findAnchor(anchors, edge[0]), findAnchor(anchors, edge[1])
if a2 < a1: a2,a1 = a1,a2
if a1 != a2: anchors[a2] = a1
for node in range(len(graph)):
# diese Schleife raeumt mit Indirektionen auf (s. Bsp. (#))
anchors[node] = findAnchor(anchors, node)

* Beispiel (#): ...

Eine verbreitete Anwendung fuer dieses Verfahren gibt es in der Bildverarbeitung:

* Beispiel: ...

== Variationen der Tiefensuche (19.06.2008) ==

=== Wichtige Algorithmen, die in der Vorlesung nicht behandelt werden ===

* Max Flow (zur Bestimmung des maximalen Flusses durch ein Netzwerk, z.B. bei Ölpipelines)
* Matching (auch ''Paarung'' genannt): Teilmenge der Kanten eines Graphen, wobei keine zwei Kanten einen gleichen Knoten besitzen
*:Anwendungsbereiche: Zuordnung von Gruppen, z.B. Arbeitsamt (Zuordnung Arbeitssuchender - Stellenangebot), Universität (Zuordnung Studenten - Übungsgruppen)

=== Vereinfachte Lösung für den ''acyclic''-Algorithmus ===
Zum Finden von Zyklen, bzw. der Feststellung, ob ein Graph azyklisch ist, verwenden wir
wieder eine modifizierte Version der Tiefensuche: Die Knoten werden wieder nach dem System der Tiefensuche besucht, und alle besuchten Knoten in einem Array visited abgespeichert. Es gibt einen Zyklus genau dann, wenn man zu
einem früheren Knoten (außer zum direkten Vorgaenger) zurückkommt.

<code python>
def acyclic(graph):
def visit(graph, node, fromNode, visited):
if visited[node]: # Zyklus entdeckt
return False
visited[node] = True
for neighbor in graph[node]:
if neighbor == fromNode: # überspringe Nachbar, von dem du gekommen bist
continue
if not visit(graph, neighbor, node, visited):
return False # der Graph ist zyklisch
return True # kein Zyklus
visited = [False]*len(graph)
for node in range(len(graph)):
if visited[node]: # schließt aus, dass Knoten besucht wird, der schon besucht war
continue
if not visit(graph, node, None, visited):
return False
return True
</code>

'''Anmerkungen zum Code:'''

* Wenn ein Knoten bereits besucht ist, dann gehört er zur gleichen Zusammenhangskomponente - dies hat allerdings nichts mit einem Zyklus zu tun.
* Ein Graph der einmal zyklisch war wird nie wieder azyklisch.
* Der obige Algorithmus weist Ähnlichkeiten mit den bereits behandelten Algorithmen auf: '''ein guter Algorithmus zeichnet sich dadurch aus, dass mit kleinen Code-Variationen ganz andere Probleme gelöst werden können'''.

=== Kürzeste Wege (Pfade) ===

* Definition: gewichteter Graph

Jeder Kante e ist eine reelle oder natürliche Zahl we zugeordnet (wird auch als
''Kantengewicht'' bezeichnet).

z.B.
* Abstand der Anfangs- und Endknoten

* Durchflusskapazität eines Rohres (für max-Flussprobleme)

* Wechselkurse (Darstellung in einem gerichteten Graph, da jede Kante auch eine Richtung hat. Die Knoten sind die Währungen, die Kanten sind die Wechselkurse. Auf diese Weise lassen sich unterschiedliche Wechselkurse + Bankgebühren darstellen.)

* '''Definition''': Problem des kürzesten Weges

Sei P die Menge aller Wege von u nach v

Puv = {u_v}

und der Weg gegeben durch

u → x1 → x2 → ... → v

dann sind die Kosten eines Weges definiert durch

Kosten (Puv) = <math>\sum\limits_{l \in Pv}</math> we

* gesucht: Pfad u_v, so dass Kosten (u_v) minimal sind

* Lösung: Algorithmus von Dijkstra

=== Algorithmus von Dijkstra ===

==== Edsger Wybe Dijkstra ====

geb. 11. Mai 1930 in Rotterdam

ges. 06. August 2002

Dijkstra war ein niederländischer Informatiker und Wegbereiter der strukturierten Programmierung. 1972 erhielt er für seine Leistung in der Technik und Kunst der Programmiersprachen den Turing Award, der jährlich von der Association for Computing Machinery (ACM) an Personen verliehen wird, die sich besonders um die Entwicklung der Informatik verdient gemacht haben. Zu seinen Beiträgen zur Informatik gehören unter anderem der Dijkstra-Algorithmus zur Berechnung des kürzesten Weges in einem Graphen sowie eine Abhandlung über den go-to-Befehl und warum er nicht benutzt werden sollte. Der go-to-Befehl war in den 60er und 70er Jahren weit verbreitet, führte aber zu Spaghetti-Code. In seinem berühmten Paper "A Case against the GO TO Statement"[http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF], das als Brief mit dem Titel "Go-to statement considered harmful" veröffentlicht wurde, argumentiert Dijkstra, dass es umso schwieriger ist, dem Quellcode eines Programmes zu folgen, je mehr go-to-Befehle darin enthalten sind und zeigt, dass man auch ohne diesen Befehl gute Programme schreiben kann.

==== Algorithmus ====

<code python>
import heapq # heapq ist ein Modul von Python
def dijkstra(graph, start, ziel): # graph: gewichtete Adjazenzliste
heap = []
visited = [None]*len(graph)
visited[start] = start
for neighbor in graph[start]:
heapq.heappush(heap, (neighbor[1], start, neighbor[0])) # neighbor[1]:Kantengewicht,neighbor[0]:Endpunkt d. K.
while len(heap) > 0: # solange der heap nicht leer ist
w, fromNode, node = heapq.heappop(heap)
if visited[node] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
visited[node] = fromNode # baue Vorgänger-Baum
if node == ziel: # da der heap noch nicht leer ist, wird an dieser Stelle ein break benötigt
break
for neighbor in graph[node]:
if visited[neighbor[0]] is not None: # wenn der kürzeste Pfad bereits bekannt ist, überspringe ihn
continue
heapq.heappush(heap, (neighbor[1]+w, node, neighbor[0]))
bestPath = []
t = ziel
while t != visited[t]: # Array wird durchlaufen bis der Anker des Pfades gefunden ist, vgl. Union-Search
bestPath.append(t)
t=visited[t]
bestPath.append(start)
return bestPath # bestPath.reverse()
</code>

'''Anmerkungen zum Code:'''
* der graph ist eine gewichtete Adjazenzliste

{|

|-

| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | Endknoten || → || style="background:silver; color:white" | Endknoten || (Nr. der Nachbarn des Knoten 0)

|-

| || style="background:silver; color:white" | 1 || || style="background:silver; color:white" | Gewicht || || style="background:silver; color:white" | Gewicht || (Gewicht der jeweiligen Kante)

|-

| || style="background:silver; color:white" | 2 ||

|-

| || style="background:silver; color:white" | 3 ||

|}
* Eingabe z.B.:
{|
|-
| Knoten || style="background:silver; color:white" | 0 || → || style="background:silver; color:white" | (1, 0.3) || style="background:silver; color:white" | (3, 0.1) || style="background:silver; color:white" | (5, 1.2) ||
|-
| || style="background:silver; color:white" | 1 || → || style="background:silver; color:white" | || style="background:silver; color:white" | || style="background:silver; color:white" | ||
|-
| || style="background:silver; color:white" | 2 ||
|-
| || style="background:silver; color:white" | 3 ||
|-
| || style="background:silver; color:white" | 4 ||
|-
| || style="background:silver; color:white" | 5 ||
|-
| || style="background:silver; color:white" | 6 ||
|}
* heapq() verwendet den 1. Eintrag des Tupels zum sortieren des heap

==== Prinzip des Dijkstra-Algorithmus ====

* Algorithmus ist Tiefensuche mit Prioritätswarteschlange (Heap) statt eines Stapelspeichers (Stack) → vgl. Übung 8

* Die Prioritätswarteschlange speichert die kürzesten Wege, die bereits gefunden worden sind.

* Wenn man die Prioritätswarteschlange (Heap) durch eine Warteschlange (Queue) ersetzt, erhält man Breitensuche.

* Wenn man die Prioritätswarteschlange (Heap) durch einen Stapelspeicher (Stack) ersetzt, erhält man Tiefensuche.

==== Beispiel ====

[[Image:Bsp.jpg]]

* An der Stelle "neighbor[1]" wird eine Zählvariable ''count'' eingefügt, die hoch (Breitensuche) oder runter (Tiefensuche) zählt.

* Die Gewichte werden hoch- oder runtergezählt, so wie die Kanten gesehen wurden.

* Wenn man rückwärts zählt (von 0 abziehen), werden die zuletzt hinzugefügten Kanten expandiert.

* '''Algorithmus von Dijkstra funktioniert nur für positive Kantengewichte
*:<math>\forall</math> we > 0'''

* Bei negativen Kantengewichten könnte es Zyklen geben, die negative Kosten für den ganzen Zyklus haben:

/\ 1. Durchlauf: Kosten -1
1 / \ 4 2. Durchlauf: Kosten -2
/____\ etc.
2

* Verwendung bei arbitragen Geschäften (Börsengeschäfte, die die Preis-, Kurs- und Zinsunterschiede auf verschiedenen Märkten ausnutzen):
*:EURO wurden in YEN, YEN in DOLLAR gewechselt und das Geld hat sich dadurch vermehrt
* Für negative Kantengewichte verwendet man den Bellman-Ford-Allgorithmus, der allerdings langsamer ist, als der Dijkstra-Algorithmus.

==== Komplexität von Dijkstra ====

* Jeder Knoten wird höchstens 1x expandiert (Iteration über die Nachbarn des Knotens).

* Jeder Knoten kann mehrmals im Heap enthalten sein.

* Es sind aber höchstens E (Anzahl der Kanten) Heap-Einträge möglich, da jede Kante höchstens 1 Heap-Eintrag generiert (ein Knoten ist nur dann im Heap, wenn man ihn über eine Kante erreicht hat, die man vorher noch nicht besucht hatte). Deshalb können nie mehr Einträge im Heap sein, als es Kanten gibt. Die Komplexität von heappush(), heappop() ist
O(log E) = O(2 log v) = O(log v)
wenn alle Kanten einen Heap-Eintrag generiert haben.
* Die while-Schleife wird im schlimmsten Fall E mal durchlaufen, deshalb ist die Komplexität von Dijkstra O(E log v).

==== Korrektheit von Dijkstra ====

* Falls
visited[node] (Schleifen-Invariante von while) != None
ist, dann liefert Zurückverfolgen des Pfades von node nach start den kürzesten Pfad von start nach node (gilt für alle Knoten, für die das visited-Feld gesetzt ist).
* Induktionsanfang: visited[start] ist einziger not-None-Fall → Bedingung erfüllt
* Induktionsschritt: wenn visited[node] gesetzt wird, ist es ein kürzester Pfad

==== Indirekter Beweis ====

Set S = {node | visited[node] != None} (alle Knoten, von denen wir den kürzesten Pfad schon kennen)

* u ist der Knoten an der Spitze des Heaps
* fromNode <math>\in</math> S (ein Nachbar von node kommt erst dann in den Heap, wenn visited[node] vorher gesetzt wurde)
* falls u → fromNode &rarr start kein kürzester Pfad wäre, müsste u's Vorgänger in V\S sein
* sei dieser Vorgänger x <math>\notin</math> S, x <math>\not=</math> u
* sei wx das Gewicht der Kante x → u, dann sind die Kosten für start nach u gleich

Kosten(start_u) = Kosten(start_x) + wx

* Annahme des indirekten Beweises:

Kosten(start_fromNode) + wfromNode

* Behauptung des indirekten Beweises:
Es gibt einen anderen Pfad x, so dass die Kosten von start nach x geringer sind

* Da aber gilt:
fromNode <math>\in</math> S und x <math>\notin</math> S

* gilt (Induktionsvoraussetzung):
Kosten(start_fromNode) < Kosten(start_x)

* Falls Kosten(start_x) < Kosten(start_u) müsste x im Heap vor u kommen; daraus folgt, dass u nicht an der Spitze des Heaps sein kann

→ Widerspruch!

→ Die Behauptung, der Weg über x ist besser, kann nicht stimmen.

→ Korrektheit von Dijkstra ist somit bewiesen.

==== Wie kann man Dijkstra noch verbessern? ====

===== A*-Algorithmus =====

* Verbesserung von Dijkstra im typischen Fall, aber die Komplexität ist immer noch =(Elog v) im schlechtesten Fall (die Komplexität kann man nicht verbessern, aber die Laufzeit im typischen Fall).
* Schätzung für jeden Knoten für den restlichen Weg:
geschätzte Gesamtkosten: Kosten(start_node) + Restschätzung(node_ziel)
(exakte Kosten werden durch Dijkstra ermittelt)

'''Idee:'''
* Sortiere den Heap nach geschätzten Gesamtkosten.
* Satz:
Falls jede Schätzung den exakten Weg unterschätzt, werden die gleichen Pfade gefunden, wie
bei Dijkstra (also die korrekten kürzesten Pfade).
(Die Schätzung für den restlichen Weg muss man immer so einrichten, dass der tatsächliche Weg unterschätzt wird. Da keine Straße kürzer sein kann als die Luftlinie, ist die Luftlinie eine geeignete Annahme für A*.)
* Falls der falsche Pfad im Heap eher an die Spitze kommt als der richtige Pfad, findet der A*-Algorithmus den falschen Pfad.
* Wenn der Pfad zum Ziel an der Spitze des Heap ist, dann wird keine Restschätzung mehr benötigt, denn wenn der Zielknoten aus dem Heap herrauskommt, dann hat man die exakte Berechnung. Die Restschätzung ist in diesem Fall 0. Wenn die Schätzung zu klein ist, wird der exakte Weg immer größer sein und zuerst aus dem Heap herauskommen.

[[Image:Minimum_spanning_tree.png‎ |thumb|200px|right|Ein minimal aufspannender Baum verbindet alle Punkte eines Graphen bei minimaler Kantenlänge ([http://de.wikipedia.org/wiki/Spannbaum Quelle])]]
=='''Minimaler Spannbaum'''==
'''(engl.: minimum spanning tree; abgekürzt: MST)'''

:''gegeben'': gewichteter Graph, zusammenhängend 
:''gesucht'': Untermenge <math>E'\subseteq E</math>, so dass <math>\sum_{e\in E} w_e</math> minimal und G' zusammenhängend ist. 
* G'definiert dann einen Baum, denn andernfalls könnte man <math>\sum_{E'}</math>verringern (eine Kante weglassen) ohne die Zusammenhangskomponente zu verletzen. 

* Wenn der Graph nicht zusammenhängend ist, würde man den Spannbaum für jede Zusammenhangskomponente getrennt ausrechnen.
* Der MST ist ähnlich wie der Dijkstra-Algorithmus: Dort ist ein Pfad gesucht bei dem die Summe der Gewicht über den Pfad minimal ist.
* Beim MST suchen wir eine Lösung bei der die Summe der Gewichte über den ganzen Graphen minimal ist.

* Das Problem des MST ist nahe verwandt mit der Bestimmung der Zusammenhangskomponente, z.B. über den Tiefensuchbaum, wobei ein beliebiger Baum für die Zusammenhangskomponente und beim MST ein minimaler Baum gesucht ist.

;Anwendungen
* '''Wie verbindet man ''n'' Punkte mit möglichst wenigen (kurzen) Straßen (Eisenbahnen, Drähten (bei Schaltungen) usw.)?'''

[[Image:mst.png|thumb|250px|none|MST minimale Verbindung (Abb.1)]]
[[Image:Gleichseitigesdreieck.png|thumb|250px|none|MST = 2 (Länge = Kantengewicht)(Abb.2)]]

*In der Praxis: Die Festlegung, dass man nur die gegebenen Punkte verwenden darf, ist eine ziemliche starke Einschränkung.

* Wenn man sich vorstellt, es sind drei Punkte gegeben, die als gleichseitiges Dreieck angeordnet sind, dann ist der MST (siehe Abb.2, schwarz gezeichnet) und hat die Länge 2. Man kann hier die Länge als Kantengewicht verwenden.

* Wenn es erlaubt ist zusätzliche Punkte einzufügen, dann kann man in der Mitte einen neuen Punkt setzen <math>\rightarrow</math> neuer MST (siehe Abb.2, orange gezeichnet). 

* Höhe = <math>\frac{1}{2}\sqrt{3}</math>, Schwerpunkt: teilt die Höhe des Dreiecks im Verhältnis 2:1; der Abstand von obersten Punkt bis zum neu eingeführten Punkt: <math>\frac{2}{3}h = \frac{\sqrt{3}}{3}</math>, davon insgesamt 3 Stück, damit (gilt für den MST in orange eingezeichnet): MST = <math>3\left(\frac{1}{3}\right) \sqrt{3} = \sqrt{3} \approx 1,7</math><br\>

* Damit ist der MST in orange kürzer als der schwarz gezeichnete MST. <br\>
<math>\Rightarrow</math>Folgerung: MST kann kürzer werden, wenn man einen Punkt dazu nimmt.
* Umgekehrt kann der MST auch kürzer werden, wenn man einen Punkt aus dem Graphen entfernt, aber wie das Beipiel des gleichseitigen Dreiecks zeigt, ist dies nicht immer der Fall.

[[Image: bahn.png|thumb|250px|none|Bahnstrecke Verbindung (Abb.3)]]

* Methode der zusätzlichen Punkteinfügung hat man früher beim Bahnstreckenbau verwendet. Durch Einführung eines Knotenpunktes kann die Streckenlänge verkürzt werden (Dreiecksungleichung).

* '''Bestimmung von Datenclustern'''

[[Image:cluster.png|none|350px]]

* Daten (in der Abb.: Punkte) bilden Gruppen.

* In der Abbildung hat man 2 verschiedene Messungen gemacht (als x- und y-Achse aufgetragen), bspw. Größe und Gewicht von Personen. Für jede Person i wird ein Punkt an der Koordinate (Größei, Gewichti) gezeichnet (siehe Bild a). Dies bezeichnet man als ''Scatter Plot''. Wenn bestimmte Wertkombinationen häufiger auftreten als andere, bilden sich mitunter Gruppen aus, bspw. eine Gruppe für "klein und schwer" etc.

* Durch Verbinden der Punkte mittels eines MST (siehe Abbildung (b)) sieht man, dass es kurze (innerhalb der Gruppen) und lange Kanten (zwischen den Gruppen) gibt.

* Wenn man geschickt eine Schwelle einführt und alle Kanten löscht, die länger sind als die Schwelle, dann bekommt man als Zusammenhangskomponente die einzelnen Gruppen.

Zwei Algorithmen für dieses Problem
(im Vergleich zu Algorithmen für die Zusammenhangskomponente nur leicht verbesserte Algorithmen)

====Algorithmus von Prim====
[http://de.wikipedia.org/wiki/Algorithmus_von_Prim#Hashing_mit_offener_Adressierung Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]

:Idee: starte an der Wurzel (willkürlich gewählter Knoten) und füge jeweils die günstigste Kante hinzu (<math>\rightarrow</math> genau wie beim Dijsktra-Algorithmus, aber die Definitionen, welche Kante die günstigste ist, unterscheiden sich.)

import heapq
def prim(graph): #Graphdatenstruktur ist wie bei Dijsktra
heap = []
visited = [False]*len(graph)
sum = 0 #wird später das Gewicht des Spannbaums sein
r = [] #r ist die Lösung
visited[0] = True #fixed
for neighbor in graph[0]: #willkürlich 0 als Wurzel gewählt
heapq.heappush(heap, (neighbor[1], 0, neighbor[0])) #Heap wird gefüllt
while len(heap):
wn, start, ziel = heapq.heappop(heap)
if visited[ziel]: continue
visited[ziel] = True #wenn visited noch nicht besetzt
sum += wn #Addition des Gewichts der aktuellen Kante
r.append([start, ziel]) #Kante wird an die Lsg. angehängt
for neighbor in graph[ziel]:
if visited[neighbor[0]]: continue
heapq.heappush(heap, (neighbor[1], ziel, neighbor[0]))
return sum, r

====Algorithmus von Kruskal====
[http://de.wikipedia.org/wiki/Algorithmus_von_Kruskal Wikipedia (de)]
[http://en.wikipedia.org/wiki/Kruskal%27s_algorithm (en)]

Eine andere Vorgehensweise zur Bestimmung des minimalen Spannbaums besteht darin, einfach Kanten nacheinander hinzuzufügen und hierbei bei jedem Schritt die kürzeste Kante zu verwenden, die keinen Zyklus bildet. Anders ausgedrückt: Der Algorithmus beginnt mit ''N'' Bäumen; in ''N'' Schritten kombiniert er jeweils zwei Bäume (unter Verwendung der kürzesten möglichen Kante), bis nur noch ein Baum übrig bleibt.
Der Algorithmus von J.Kruskal ist seit 1956 bekannt.

* Idee: wie beim Union-Find-Algorithmus für Zusammenhangskomponenten

# Behandle jeden Knoten als Baum für sich
# Fasse zwei Bäume zu einem neuen Baum zusammen

* für MST (im Unterschied zu Union-Find): betrachte dazu die Kanten in aufsteigender Reihenfolge der Gewichte
(priority queue; ignoriere Kanten zwischen Knoten in gleichem Baum)

* Algorithmus eignet sich besser für das Clusteringproblem, da der Schwellwert von vornerein über die Kantenlänge an den Algorithmus übergeben werden kann. Man hört mit dem Vereinigen auf, wenn die Kantenlänge den Schwellwert überschreitet.
*Es kann keine kürzere Kante als der Schwellwert mehr kommen, da die Kanten vorher sortiert worden sind.

''Komplexität:'' gleich wie beim Dijkstra-Algorithmus, weil jede Kante kommt höchstens einmal in den Heap.
* Aufwand für Heap ist max. <math>E</math> Einträge, da jede Kante nur einmal im Heap sein kann, d.h. Heap hat den Aufwand: <math>O\left(E\log E\right)</math>, falls keine Mehrfachkanten vorhanden: <math>v^2 > E</math> und deshalb: log E < 2 log v.
* Daraus folgt, dass das dasselbe ist wie <math>O \left(E\log v\right)</math>

=> geeignet für Übungsaufgabe

== Problem des Handlungsreisenden ==
'''(engl.: Traveling Salesman Problem; abgekürzt: TSP)'''<br\>
[http://de.wikipedia.org/wiki/Problem_des_Handlungsreisenden Wikipedia (de)]
[http://en.wikipedia.org/wiki/Prim%27s_algorithm (en)]
[[Image:TSP_Deutschland_3.PNG|thumb|200px|right|Optimaler Reiseweg eines Handlungsreisenden([http://de.wikipedia.org/w/index.php?title=Bild:TSP_Deutschland_3.PNG&filetimestamp=20070110124506 Quelle])]]

*Eine der wohl bekanntesten Aufgabenstellungen im Bereich der Graphentheorie ist das Problem des Handlungsreisenden.
*Hierbei soll ein Handlungsreisender nacheinander ''n'' Städte besuchen und am Ende wieder an seinem Ausgangspunkt ankommen. Dabei soll jede Stadt nur einmal besucht werden und der Weg mit den minimalen Kosten gewählt werden.
*Alternativ kann auch ein Weg ermittelt werden, dessen Kosten unter einer vorgegebenen Schranke liegen.

:''gegeben'': zusammenhängender, gewichteter Graph (oft vollständiger Graph)
:''gesucht'': kürzester Weg, der alle Knoten genau einmal (falls ein solcher Pfad vorhanden) besucht (und zum Ausgangsknoten zurückkehrt)<br\>

:auch genannt: kürzester Hamiltonpfad (Pfad der alle Knoten einmal besucht):
::- durch psychologische Experimente wurde herausgefunden, dass der Menschen (in 2D) <math>\approx</math> proportionale Zeit zur Anzahl der Knoten braucht, um den Pfad zu finden, <math>O(V)</math> (linear) (<math>\lesssim 5%</math> länger als optimaler Pfad ist typisch) <br\>
:''vorgegeben'': Startknoten (kann willkürlich gewählt werden), vollständiger Graph

::::: => v-1 Möglichkeiten für den ersten Nachfolgerknoten => je v-2 Möglichkeiten für dessen Nachfolger...
:::::also <math>\frac{(v-1)!}{2}</math> mögliche Wege in einem vollständigen Graphen

*Ein naiver Ansatz zur Lösung des TSP Problems ist das erschöpfende Durchsuchen des Graphen, auch "brute force" Algorithmus ("mit roher Gewalt"), indem alle möglichen Rundreisen betrachtet werden und schließlich die mit den geringsten Kosten ausgewählt wird.
*Dieses Verfahren versagt allerdings bei größeren Graphen, aufgrund der hohen Komplexität.

'''Systematisches Erzeugen aller Permutationen'''<br\>
*Allgemeines Verfahren, wie man von einer gegebenen Menge verschiedene Schlüssel - in diesem Fall: Knotennummern - sämtliche Permutationen systematisch erzeugen kann. <br\>
*'''Trick''': erzeuge jede Permutation als Wort und betrachte dann deren lexikographische ("wie im Lexikon") Ordnung.<br\>
*Der erste unterschiedliche Buchstabe unterscheidet. Wenn die Buchstaben gleich sind, dann kommt das kürzere Wort zuerst.

''gegeben'': zwei Wörter a,b <br\>
mathematisch formuliert, wie die Wörter im Wörterbuch sortiert sind: <br\>
<math>a<br\>
:::::::<math>a[i] == b[i] i<j</math><br\>
:::::::<math>a[j] < b[j] i == j</math><br\>

oder falls <math>a[i] == b[i] \forall i < n </math>
:::<math>len(a) < len(b)</math>

# beginne mit dem kleinsten Wort => ist der Fall, wenn a aufsteigend sortiert
# definiere Funktion "next_permutation", die den Nachfolger in lexikographischer Ordnung erzeugt

Beispiel: Die folgenden Permutationen der Zahlen 1,2,3 sind lexikographisch geordnet

1 2 3 6 Permutationen, da 3! = 6
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
-----
0 1 2 Position

Die lexikographische Ordnung wird deutlicher, wenn wir statt dessen die Buchstaben a,b,c verwenden:

abc
acb
bac
bca
cab
cba

Eine Funktion, die aus einer gegebenen Permutation die in lexikographischer Ordnung nächst folgende erzeugt, kann wie folgt implementiert werden:

def next_permutation(a):
i = len(a) -1 #letztes Element; man arbeitet sich von hinten nach vorne durch
while True: # keine Endlosschleife, da i dekrementiert wird und damit irgendwann 0 wird
if i <= 0: return False # a ist letzte Permutation
i -= 1
if a[i]<a[i+1]: break
#lexikogr. Nachfolger hat größeres a[i]
j = len(a)
while True:
j -= 1
if a[i] < a[j]: break
a[i], a[j] = a[j], a[i] #swap a[i], a[j]
#sortiere aufsteigend zwischen a[i] und Ende
#zur Zeit absteigend sortiert => invertieren
i += 1
j = len(a) -1
while i < j:
a[i], a[j] = a[j], a[i]
i += 1
j-= 1
return True # eine weitere Permutation gefunden

def naiveTSP(graph):
start = 0
result = range(len(graph))+[start]
rest = range(1,len(graph))
c = pathCost(result, graph)
while next_permutation(rest):
r = [start]+rest+[start]
cc = pathCost(r, graph)
if cc < c:
c = cc
result = r
return c, result

'''Komplexität''': <math>(v-1)!</math> Schleifendurchläufe (=Anzahl der Permutationen, da die Schleife abgebrochen wird, sobald es keine weiteren Permutationen mehr gibt), also
<math>O(v!) = O(v^v)</math>

;Beispiel:
{|
|-
| | i = 0 || | ||| ||| j = 3 ||

|-
|| ↓ || || || ↓ ||

|-

| style="background:silver; color:white" | 1 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 2 || #input für next_permutation
|-
|-

|| || i = 2 || || j = 3 ||

|-
|| || ↓|| || ↓ ||
|-

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 4 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 1|| # vertauschen der beiden Elemente
|-
|-

|| || ||i = 2 || ||
|-
|| || ||j = 2 || ||

|-
|| || || ↓|| ||

|-
| style="background:silver; color:white" | 2 ||style="background:silver; color:white" | 1 ||style="background:silver; color:white"| 3 ||style="background:silver; color:white" | 4|| #absteigend sortiert
|}

;Stirling'sche Formel:
[http://de.wikipedia.org/wiki/Stirling-Formel Wikipedia (de)]
[http://en.wikipedia.org/wiki/Stirling%27s_approximation (en)]

Die Stirling-Formel ist eine mathematische Formel, mit der man für große Fakultäten Näherungswerte berechnen kann. Die Stirling-Formel findet überall dort Verwendung, wo die exakten Werte einer Fakultät nicht von Bedeutung sind. Damit lassen sich durch die Sterling Formel z.T. starke Vereinfachungen erzielen.
<math>v! \approx \sqrt{2 \pi v} \left(\frac{v}{e}\right)^v</math>
: <math>O(v!) = O\left(\sqrt{v}\left(\frac{v}{e}\right)^v\right) \approx O(v^v)</math>

== Erfüllbarkeitsproblem ==

== Stark zusammenhängende Komponenten ==

geg.: gerichteter Graph

1. Bestimme die post Order Time (mit Tiefensuche)
2. Transponieren des Graphen <math>G^T</math>
3. Bestimme ConnComp <math>G^T</math> mit bekannten CC Algorithmen, aber so, dass Knoten in absteigender post Order behandelt werden

[[Image:Curva.png|thumb|250px|none]] Beweis: 1.Bilde Komponentengraphen:
'''Knoten:''' jede SCC <math>C_i</math> ist ein Knoten
'''Kanten:''' <math>C_i \rightarrow C_j \Leftrightarrow U_k \rightarrow U_l</math> mit <math>U_k \in C_i</math> und <math>U_l \in C_j</math>

'''*Eigenschaft 1:''' der Komponentengraph ist :''azyklisch'':
<math>pot \left(C_i\right) = max_{U_k \in C_i} pot\left(U_k\right)</math>

'''*Eigenschaft 2:''' falls <math>C_i \rightsquigarrow C_j</math> dann <math>pot \left(C_i\right) > pot \left(C_j\right)</math>
(ausserdem gilt: es gibt keinen Weg <math>C_j \rightsquigarrow C_i</math> )
aber: in transponierten Graphen sind alle Kanten umgedreht

'''*Eigenschaft 3:''' falls <math>{C_j}^T \rightsquigarrow {C_i}^T</math> , dann gilt <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

Eigenschaft 2-3 <math>\Longrightarrow</math> im transponierten Graphen gibt es nie einen Pfad <math>{C_i}^T \rightsquigarrow {C_j}^T</math>

Falls <math>pot \left({C_i}^T\right) > pot \left({C_j}^T\right)</math>

<math>\Longrightarrow</math> Schritt 3 des Algorithmus kann von einem geg. Startknoten ''nur'' die Knoten derselben SCC erreichen

q.e.d.

== Anwendung auf 2-SAT Problem ==

geg.: Implikationen-Normalform, dargestellt als gerichteter Graph.

Eigenschaft: alle Variablen in derselben SCC müssen den gleichen Wert haben, weil

<math>\underbrace{x_i \rightsquigarrow x_j \stackrel{\wedge}{=} x_i \rightarrow x_j; \;\;\; x_j \rightsquigarrow x_i \stackrel{\wedge}{=} x_j \rightarrow x_i}</math>

:::::<math>\;\;\;x_i == x_j</math>

<math>\rightarrow \; x_i \; und \; \neg x_i</math> dürfen nie in derselben SCC sein, weil <math>\rightarrow \; x_i == \neg x_i</math> unmöglich ist

<math>\Longrightarrow</math> Algorithmus für Erfüllbarkeit: teste die Eigenschaft

'''Das funktioniert leider nicht für k-SAT mit <math>k>2</math>'''