Minimum Spanning Tree: MST

Slides:



Advertisements
Ähnliche Präsentationen
8. Termin Teil B: Wiederholung Begriffe Baum
Advertisements

Vortrag von Stephanie Weirauch Jens Pleger Peter Jancke Frank Wejmelka
Christian Scheideler SS 2009
Grundlagen des A*-Algorithmus und Anwendung in der Routenplanung
Berechne den optimalen (kürzesten, schnellsten) Weg
Man bestimme den „minimalen aufspannenden Baum“ des Graphen.
Single-Source Shortest Paths: SSSP
Rekursion: Rekurrenz: Algorithmen rufen sich selbst (rekursiv) auf.
Falls Algorithmen sich selbst rekursiv aufrufen, so kann ihr Laufzeitverhalten bzw. ihr Speicherplatzbedarf in der Regel durch eine Rekursionsformel (recurrence,
Eine dynamische Menge, die diese Operationen unterstützt,
Minimum Spanning Tree: MST
DNA-Array oder DNA-Chip
Prof. Dr. S. Albers Prof.Dr.Th Ottmann
Vorlesung Informatik 2 Algorithmen und Datenstrukturen (26-Graphenalgorithmen: Wiederholung und Übung) Prof. Th. Ottmann.
Datenstrukturen, Algorithmen und Programmierung 2 (DAP2)
Datenstrukturen, Algorithmen und Programmierung 2 (DAP2)
Graphen Ein Graph ist eine Kollektion von Knoten und Kanten. Knoten sind einfache Objekte. Sie haben Namen und können Träger von Werten, Eigenschaften.
ADS Vorlesung Prof. Dr. W. Conen, FH Gelsenkirchen
Kapitel 6: Klassifizierung von Sortiertechniken
7. Natürliche Binärbäume
R. Der - Vorlesung Algorithmen und Datenstrukturen (Magister)
Algorithmen und Komplexität Teil 1: Grundlegende Algorithmen
Algorithmentheorie 04 –Hashing
WS Algorithmentheorie 13 - Kürzeste (billigste) Wege Prof. Dr. Th. Ottmann.
WS Algorithmentheorie 05 - Treaps Prof. Dr. Th. Ottmann.
Vorlesung Informatik 2 Algorithmen und Datenstrukturen (23 – Sortieren vorsortierter Daten) Prof. Th. Ottmann.
Vorlesung Informatik 2 Algorithmen und Datenstrukturen Halbzeit: Was haben wir bisher gelernt? Prof. Th. Ottmann.
WS Prof. Dr. Th. Ottmann Algorithmentheorie 09 - Suche in Texten Suffix –Tree –Konstruktion Ukkonen Algorithmus.
Vorlesung Informatik 2 Algorithmen und Datenstrukturen (27 – Kürzeste Wege) Prof. Th. Ottmann.
1 Vorlesung Informatik 2 Algorithmen und Datenstrukturen (21 – Kürzeste Wege) T. Lauer.
1 Vorlesung Informatik 2 Algorithmen und Datenstrukturen (17 – Fibonacci-Heaps – Analyse) Tobias Lauer.
Algorithmentheorie 12 – Spannende Bäume minimalen Gewichts
Union-Find-Strukturen
WS Algorithmentheorie 15 – Fibonacci-Heaps Tobias Lauer.
Seminar parallele Programmierung SS 2003
Beweissysteme Hartmut Klauck Universität Frankfurt WS 06/
Effiziente Algorithmen
Effiziente Algorithmen
Effiziente Algorithmen
Effiziente Algorithmen
Black Box Algorithmen Hartmut Klauck Universität Frankfurt SS
Diskrete Mathematik II
Effiziente Algorithmen Hartmut Klauck Universität Frankfurt SS
Effiziente Algorithmen
Effiziente Algorithmen
Black Box Algorithmen Hartmut Klauck Universität Frankfurt SS
Effiziente Algorithmen Hartmut Klauck Universität Frankfurt SS
Effiziente Algorithmen
Black Box Algorithmen Hartmut Klauck Universität Frankfurt SS
Effiziente Algorithmen Hartmut Klauck Universität Frankfurt SS
Black Box Algorithmen Hartmut Klauck Universität Frankfurt SS
Effiziente Algorithmen Hartmut Klauck Universität Frankfurt SS
Effiziente Algorithmen Hartmut Klauck Universität Frankfurt SS
Effiziente Algorithmen
Effiziente Algorithmen
Effiziente Algorithmen Hartmut Klauck Universität Frankfurt SS
Hartmut Klauck Universität Frankfurt SS
Information und Kommunikation
Information und Kommunikation Hartmut Klauck Universität Frankfurt SS
Kapitel 8: Graphalgorithmen 8. 1 Grundlagen 8
Kapitel 8: Graphalgorithmen 8. 1 Grundlagen 8
Das Traveling Salesman Problem (TSP)
Analyse der Laufzeit von Algorithmen
Minimal spannende Bäume
Institut für Kartographie und Geoinformation Prof. Dr. Lutz Plümer Diskrete Mathematik II Vorlesung Datenstrukturen für den Algorithmus von.
Der A*-Algorithmus.
Gliederung der Vorlesung
Binärbäume.
Programmiersprachen II Graph_Algorithmen Gewichtete Graphen - Minimum Spanning Tree und shortest path aus Implementierungssicht Prof. Dr. Reiner Güttler.
Christian Scheideler WS 2008
 Präsentation transkript:

Minimum Spanning Tree: MST 1.5 1.0 0.75 2.0 2.5 Gegeben eine Menge von Spezies V (Knoten) und evolutionäre Distanzen w(v,u) (Kantengewichte) für jedes Paar v, u von Spezies. Eine Kante e zwischen zwei Spezies u,v erhält als Gewicht e.weight = w(v,u) Man bestimme den „minimalen aufspannenden Baum“ des Graphen.

Definition [15]: Sei G = (V,E) ein (ungerichteter) Graph, wobei jede Kante (u,v) von E ein Gewicht w(u,v) zugeordnet wird. 1.5 1.0 0.75 2.0 2.5 Eine azyklischer Teilgraph T von G, der alle Knoten V von G verbindet, heißt ein aufspannender Baum. Das Gewicht von T ist die Summe der Kantengewichte. Ein aufspannender Baum T von G mit minimalem Gewicht heißt ein minimaler aufspannender Baum von G (Minimum Spanning Tree). Gegeben eine Menge von Spezies V (Knoten) und evolutionäre Distanzen w(v,u) (Kantengewichte) für jedes Paar v, u von Spezies. Eine Kante e zwischen zwei Spezies u,v erhält als Gewicht e.weight = w(v,u) Man bestimme den „minimalen aufspannenden Baum“ des Graphen.

Die Algorithmen zur Berechnung eines MST verwenden die sogenannte Greedy-Strategie (Greedy Approach) (greedy = gierig, gefräßig, habgierig). In jedem Schritt des Algorithmus hat man die Wahl zwischen mehreren Kanten. Die Greedy-Strategie wählt die Kante, die in diesem Moment die (scheinbar) beste Wahl darstellt. In vielen Anwendungen liefern Greedy-Strategien nur suboptimale Resultate und nicht die (globale) optimale Lösung. Es existieren jedoch Greedy-Algorithmen, die die optimale Lösung des MST-Problem berechnen. MST-Problem: Gegeben ein ungerichteter Graph G = (V,E) und eine Gewichtsfunktion w Man berechne einen minimalen aufspannenden Baum (MST) von G. Wir werden zunächst einen generischen Algorithmus diskutieren, der die folgende Iterations-Invariante aufrechterhält: Wir berechnen eine Kantenmenge A für die gilt: Vor und nach jeder Iteration ist A eine Teilmenge der Kanten eines MST.

In jedem Schritt fügen wir eine Kante (u,v) zu A hinzu, so dass A  {(u,v)} auch diese Invariante erfüllt, d.h., eine Teilmenge der Kanten eines MSTs ist. Wir nennen eine solche Kante eine sichere Kante. Generic-MST(G,w): (1) A =  (2) Solange die Kanten in A keinen aufspannenden Baum bilden: (3) Suche eine sichere Kante (u,v) für A. (4) A = A  {(u,v)} . (5) Gib A aus (return A;). Initialisierung: Für die leere Menge ist die Invariante erfüllt. Solange-Schleife (while): Es werden nur sichere Kanten hinzugefügt. Programmende: Alle Kanten gehören zu einem MST und alle Kanten zusammen bilden einen aufspannenden Baum => MST berechnet! Wie findet man sichere Kanten?

Definition [16]: Ein Cut (S, V-S) eines ungerichteten Graphen G=(V,E) ist eine Partition von V in zwei disjunkte Teilmengen S und V-S. Eine Kante (u,v) kreuzt den Cut (S,V-S), wenn ein Endpunkt in S und der andere in V-S ist. Ein Cut (S, V-S) respektiert eine Kantenmenge A, wenn keine Kante aus A den Cut kreuzt. Eine leichte Kante eines Cuts ist eine Kante, die den Cut kreuzt und minimales Gewicht besitzt. a b c d i e h g f 4 8 11 7 9 10 14 2 1 6 a b d e

Der folgende Satz liefert eine Regel zur Identifizierung von sicheren Kanten. Sei G=(V,E) ein zusammenhängender, ungerichteter Graph G=(V,E) mit Gewichts- funktion w: E->R. Sei A eine Kantenmenge, die Teilmenge eines minimalen auf- spannenden Baumes von G ist. Sei (S, V-S) ein Cut der A respektiert und sei (u,v) eine leichte Kante, die (S,V-S) kreuzt. Dann ist (u,v) eine sichere Kante für A. Beweis: Sei T ein MST, der A enthält. Wir nehmen an, dass T nicht (u,v) enthält. Wir zeigen nun, dass es einen MST T‘ gibt, der sowohl A als auch (u,v) enthält. Wir betrachten den Pfad von u nach v im MST T. u x y v Auf diesem Pfad muss es mindestens eine Kante (x,y) geben, die den Cut (S, V-S) kreuzt. Die Kante ist nicht in A, da A den Cut respektiert. Entfernt man (x,y) aus dem MST T, so zerfällt dieser in zwei Teilbäume. Addiert man die Kante (u,v), so erhält man einen neuen aufspannenden Baum T‘:

Wir zeigen nun, dass T‘ ein MST ist: Da (u,v) eine leichte Kante des Cuts (S,V-S) ist und (x,y) auch den Cut kreuzt, gilt: w((u,v))  w((x,y)) Hieraus folgt: w(T‘) = w(T) – w((x,y)) + w((u,v)) w(T‘)  w(T) Da T ein MST ist, muss folglich auch T‘ ein MST sein. Es bleibt zu zeigen, dass (u,v) eine sichere Kante für A ist. Da A  T, ist A  T‘. Also ist auch A  {(u,v)}  T‘. Da T‘ ein MST von G ist, ist folglich (u,v) eine sichere Kante für A.

Kruskals Algorithmus zur Berechnung eines MST: Der Algorithmus verwaltet eine Menge von Bäumen, die durch Hinzunahme weiterer sicherer Kanten solange ausgebaut werden, bis ein einziger minimaler aufspannender Baum berechnet wurde. Die Knoten eines jeden Teilbaums bilden eine Menge. Zu Beginn des Algorithmus ist jeder Knoten ein Baum (eine Menge). Die Kantenmenge wird vor Ausführung der eigentlichen Iteration nach aufsteigen- dem Kantengewicht sortiert. Die Kanten werden in dieser Reihenfolge abgearbeitet, beginnend mit der Kante mit kleinstem Gewicht. Werden zwei Teilbäume durch Hinzufügen einer (sicheren) Kante miteinander ver- bunden, so werden die entsprechenden Mengen miteinander zu einer neuen Menge (einem neuen Baum) verschmolzen und die Kante wird in A aufgenommen. Verbindet die aktuelle Kante zwei Knoten des gleichen Teilbaums (der gleichen Menge), so wird die Kante nicht zu A hinzugefügt. a b c d i e h g f 4 8 11 7 9 10 14 2 1 6 h a h c h h

MST-KRUSKAL(G,w): (1) A =  (2) Für jeden Knoten vV: Bilde_Menge(v) (3) Sortiere alle Kanten von E in aufsteigender Reihenfolge bezüglich der Gewichte. (4) Für jede Kante (u,v)  E (in aufsteigender Reihenfolge): (5) Falls Menge(u)  Menge(v): (6) A = A  {(u,v)} (7) Vereinige Menge(u) mit Menge(v) (8) Gib A zurück. a b c d i e h g f 4 8 11 7 9 10 14 2 1 6

Korrektheit: Berechnet MST-KRUSKAL wirklich einen MST von G? (2) Für jeden Knoten vV: (5) Falls Menge(u)  Menge(v): (3) Sortiere alle Kanten von E in aufsteigender Reihenfolge bezüglich der Gewichte. (4) Für jede Kante (u,v)  E (in aufsteigender Reihenfolge): (6) A = A  {(u,v)} Bilde_Menge(v) (7) Vereinige Menge(u) mit Menge(v) (8) Gib A zurück. Satz [11]: Sei G=(V,E) ein zusammenhängender, ungerichteter Graph G=(V,E) mit Gewichts- funktion w: E->R. Sei A eine Kantenmenge, die Teilmenge eines minimalen auf- spannenden Baumes von G ist. Sei (S, V-S) ein Cut der A respektiert und sei (u,v) eine leichte Kante, die (S,V-S) kreuzt. Dann ist (u,v) eine sichere Kante für A. Da der Cut (Menge(u), V - Menge(u)) A respektiert und (u,v) eine leichte Kante ist, die (Menge(u), V - Menge(u)) kreuzt (falls Menge(u)  Menge(v)) , ist (u,v) eine sichere Kante für A.

Laufzeit MST-KRUSKAL O(1) (1) A =  (2) Für jeden Knoten vV: (5) Falls Menge(u)  Menge(v): (3) Sortiere alle Kanten von E .... (4) Für jede Kante (u,v)  E (in aufsteigender Reihenfolge): (6) A = A  {(u,v)} Bilde_Menge(v) (7) Vereinige Menge(u) mit Menge(v) (8) Gib A zurück. O(n) O(m log(m)) O(m) O(m*Gleichheitstest) O((n-1)*1) O((n-1) *Vereinige) O(1) Als Laufzeit für einen Graphen mit n Knoten und m Kanten erhält man folglich: O( m log(m) + m * Gleichheitstest + n * Vereinige) Mittels effizienter Datenstrukturen für die Mengenoperationen, die wir später kennen lernen werden, kann man die Gleichheitstests und die Vereinige- Operationen in Zeit O((n))  O(log(n)) durchführen. Hieraus folgt: O( m log(m) + n log(n))

Da log(m)  log(n2) = 2 log(n)  O(log(n)) ist, folgt weiter O( m log n + n log n) Da der Graph nur dann einen aufspannenden Baum besitzt, wenn die Zahl der Kanten m größer gleich n-1 ist, können wir die obige Laufzeit noch vereinfachen: O( m log n) Satz [12]: Der Algorithmus von Kruskal zur Berechnung des MSTs eines Graphen G=(V,E) mit n Knoten und m  n Kanten hat Laufzeit O(m log n).

Prim‘s Algorithmus zur Berechnung eines MST: Bei Prim‘s Algorithmus bilden die Kanten in der Menge A immer einen Baum. Zu diesem Baum werden solange sichere Kanten hinzugefügt, bis man einen (minimalen) aufspannenden Baum hat. Um die sicheren Kanten zu finden, wenden wir wiederum Satz [11] an: Satz [11]: Sei G=(V,E) ein zusammenhängender, ungerichteter Graph G=(V,E) mit Gewichts- funktion w: E->R. Sei A eine Kantenmenge, die Teilmenge eines minimalen auf- spannenden Baumes von G ist. Sei (S, V-S) ein Cut der A respektiert und sei (u,v) eine leichte Kante, die (S,V-S) kreuzt. Dann ist (u,v) eine sichere Kante für A. Als Cut wählt Prim‘s Algorithmus (Q, V – Q), wobei Q die Menge der Knoten in der Kantenmenge A (im Baum A) sind. Eine sichere Kante (u,v) ist daher eine Kante mit minimalen Gewicht, die einen Knoten u von Q mit einem Knoten v von V-Q verbindet. Wir benötigen daher eine effiziente Datenstruktur zur Bestimmung des Knotens vV-Q, der den minimalen Abstand (Kante mit minimalem Gewicht) zu einem Knoten u  Q besitzt.

Prim‘s Algorithmus zur Berechnung eines MST: Für jeden Knoten v = V[i], der noch nicht zu dem Baum A gehört, speichert die Variable V[i].weight das Gewicht der Kante, die v mit dem aktuellen Baum A verbindet und minimales Gewicht besitzt. Ist noch keine solche Kante bekannt, so setzt man V[i].weight = INFINITY; Ist (u,v) die Kante mit minimalem Gewicht und ist u der j-te Knoten V[j] und v der i-te Knoten V[i], so merkt man sich die minimale Kante zu v wie folgt: V[i].parent = j; Ist noch keine Kante bekannt, so setzt man V[i].parent = -1. Der Algorithmus MST_PRIM hat neben dem Graphen und der Gewichts- funktion als dritten Parameter die Nummer r eines Knoten. Von diesem Knoten aus soll der MST aufgebaut werden.

MST_PRIM(G,w,r): (1) Für jeden Knoten v  V: V[i].weight = INFINITY und V[i].parent = -1 (2) V[r].weight = 0 und V[r].parent = -1 (3) Füge alle Knoten v  V in eine Liste L (Min-Heap) ein (4) Solange L nicht leer ist: (5) Bestimme den Knoten i mit minimalem V[i].weight und entferne ihn aus L (6) Falls V[i].parent  -1 , addiere (V[i].parent, V[i]) zur Kantenmenge A (7) Für jeden Nachbarknoten j von i: (8) Falls (j  L) und (w(V[i],V[j]) < V[j].weight), (9) setze V[j].parent = i und V[j].weight = w(V[i],V[j]) 1 2 3 4 5 6 7 8 9 |-1 4 8 11 7 9 10 14 2 1 6 4|1 4|1 7|3 2|3 9|4 2|7 4|6 8|2 0|-1 7|8 8|1 8|1 1|8 1|8

MST_PRIM(G,w,r): (1) Für jeden Knoten v  V: V[i].weight = INFINITY und V[i].parent = -1 (2) V[r].weight = 0 und V[r].parent = -1 (3) Füge alle Knoten v  V in eine Liste L (Min Heap) ein (4) Solange L nicht leer ist: (5) Bestimme den Knoten i mit minimalem V[i].weight ... (8) Falls (j  L) und (w(V[i],V[j]) < V[j].weight), (9) setze V[j].parent = i und V[j].weight = w(V[i],V[j]) (6) Falls V[i].parent  -1 , addiere (V[i].parent, V[i]) zur Kantenmenge A (7) Für jeden Nachbarknoten j von i: O(n) O(1) O(n * Einfügen) O(n) O(n * Minimum) O(n*1) O(m) O(m * Element?) O(m * 1) Als Gesamtlaufzeit erhält man also: O(n * Zeit_für_Einfügen + n * Zeit_für_Minimumsbestimmung + + m * Zeit_für _Elementtest) Verwendet man als Datenstruktur einen Min-Heap, so erhält man als Laufzeit: O(n log(n) + m log(n)) = O( m log(n))

Satz [12]: Der Algorithmus MST_PRIM berechnet den MST eines Graphen G=(V,E) mit n Knoten und m Kanten (falls man einen Min-Heap) verwendet in Zeit O(m log(n)). Verwendet man als Datenstruktur einen sogenannten Fibonacci-Heap, so ist die amortisierte Laufzeit O(m + n log(n)). Bemerkung: Fibonacci-Heaps erlauben die Minimumsberechnung in einer n-elementigen Menge in amortisierter Zeit O(log(n)). Die anderen Operationen im Algorithmus MST_PRIM können in amortisierter Zeit O(1) durchgeführt werden.