Algorithmen und Komplexität Teil 1: Grundlegende Algorithmen

Friedhelm Meyer auf der Heide 1

HEINZ NIXDORF INSTITUTEUniversity of Paderborn

Algorithms and Complexity

Algorithmen und KomplexitätTeil 1: Grundlegende Algorithmen

WS 08/09

Friedhelm Meyer auf der Heide

Vorlesung 10, 17.11.08




Flüsse in Netzwerken



Algorithms and ComplexityVergrößernde Wege

Restkapazität ist 4



Algorithms and ComplexityDer Basisalgorithmus von Ford/Fulkerson

Satz: Der Algorithmus von Ford/Fulkerson berechnet einen maximalen Fluss.




Analyse des Basisalgorithmus von Ford/Fulkerson

Ein Schnitt in N ist ein disjunkte Zerlegung von V in Mengen S und T mit s 2 S, t2 T.

Die Kapazität des Schnittes ist

Die Kapazität eines minimalem Schnittes ist

Der Flusswert eines Schnittes ist

Mit fmax bezeichnem wir den Wert eines maximalen Flusses.




Korrektheit des Algorithmus von F.F., und dasMax Flow-Min Cut Theorem

Lemma: In jedem Netzwerk N gilt: Der Wert eines jeden Flusses ist kleiner oder gleich der Kapazität eines jeden Schnittes. Insbesondere: fmax · cmin .

Lemma: Sei f der von F.F. berechnete Fluss. Dann gibt es einen Schnitt (S,T) in N mit val(f) = C(S,T).

Daraus folgt:

Satz: Der Algorithmus von Ford/Fulkerson berechnet einen maximalen Fluss.

Satz: (Max Flow-Min Cut Theorem; Satz von Ford/Fulkerson)

In jedem Netzwerk gilt fmax = cmin.Der Wert eines maximalen Flusses ist gleich

der Kapazität eines minimalen Schnittes.



Algorithms and ComplexityLaufzeit des Basisalgorithmus von F.F.

Wir gehen von Kapazitäten aus N aus.

Laufzeit ist exponentiell in Eingabegröße!



Algorithms and ComplexityEffiziente Algorithmen für maximale Flüsse

Der Basisalgorithmus von Ford/Fulkerson:

Modifikation von Edmonds/Karp:

Benutze immer einen kürzesten vergrößernden Weg.

Satz: Der Algorithmus von Edmonds/Karp liefert nach höchstens |E| |V|/2 Flussvergrößerungen, also in Zeit O(|E|2 |V|) (= O(|V|5)) einen maximalen Fluss.

Damit ist das Flussproblem in polynomieller Zeit lösbar!!



Algorithms and ComplexityDer Algorithmus von Dinic

Idee: berechne “einen vergrößernden Fluss entlang aller kürzester Wege”.



Algorithms and ComplexityRestnetzwerke

Sei N ein Netzwerk, f ein Fluss in N. Das Restnetwerk Nf zu (N, f) hat Knotenmenge V und Kantenmenge Ef mit:

(v,w) 2 Ef , (v,w) 2 E und f(v,w) < c(v,w) (Vorwärtskante)

oder (w,v) 2 E und f(v,w) > 0 (Rückwärtskante)

Kapazitäten: Vorwärtskante (v,w) : cf(v,w)= c(v,w)-f(v,w) ( >0)

Rückwärtskante (w,v) : cf(w,v) = f(v,w) (>0)

N mit Fluss f Nf



Algorithms and ComplexityRestnetzwerke

N mit Fluss f Nf

Lemma: Sei f’ ein Fluss in Nf. Dann ist f” ein Fluss in N, mit

f”(v,w) = f(v,w) + f’(v,w) – f’(w,v) ; val(f”) = val(f) + val(f’).

N mit Fluss f” Nf”

Fluss f’



Algorithms and ComplexityAlgo von Ford/Fulkerson - Umformulierung

Ein Pfadfluss f’ in einem Restnetzwerk Nf ist durch einen gerichteten s-t-Weg W mit Restkapazität r>0 in Nf definiert. f’(u,v)=r für (u,v) 2 W, f’(u,v)=0 sonst.

Eingabe: Netzwerk N.

f :´ 0; berechne Nf;While es gibt Pfadfluss f’ in Nf Do Berechne f” mit f”(v,w) = f(v,w) + f’(v,w) – f’(w,v);Berechne Nf” aus Nf ;f:=f” Od

Ausgabe: f

Variante Edmonds/Karp: Benutze Pfadfluss entlang eines kürzesten s-t-Weges in Nf.



Algorithms and ComplexitySchichtennetzwerke

Beobachtung: Edmonds/Karp benötigt nur Kanten in Nf , die zu kürzesten s-t-Wegen in Nf gehören.

Sei d(v) der Abstand (Länge eines kürzesten Wegs) von s nach v in Nf.

Das Schichtennetzwerk SNf = (V’, E’) zu Nf ist wie folgt definiert:

Sei V0 = {s} und für i = 1,2,…, d : Vi = {v 2 V | d(v)=i},mit d:= max{i| Vi }.

Sei Ei = Ef Å (Vi-1 x Vi), i= 1,…, d. dann ist V’= [ Vi , E’ = [ Ei.

V0 V1 V2 V3



Algorithms and ComplexitySchichtennetzwerke

Beobachtung: Edmonds/Karp benötigt nur Kanten in Nf , die zu kürzesten s-t-Wegen in Nf gehören.

Sei d(v) der Abstand (Länge eines kürzesten Wegs) von s nach v in Nf.

Das Schichtennetzwerk SNf = (V’, E’) zu Nf ist wie folgt definiert:

Sei V0 = {s} und für i = 1,2,…, d : Vi = {v 2 V | d(v)=i},mit d:= max{i| Vi }.

Sei Ei = Ef Å (Vi-1 x Vi), i= 1,…, d. dann ist V’= [ Vi , E’ = [ Ei.

Beobachtung

(i) Alle s-t-Wege in SNf haben Länge d, sie sind genau die kürzesten Wege in Nf.

(ii) Aus N und f kann SNf in Zeit (|V|+|E|) berechnet werden (Breitensuche).

(iii) Falls t Vd ist, ist f ein maximaler Fluss.



Algorithms and ComplexitySperrflüsse und der Algorithmus von Dinic

Ein Fluss f’ in SNf ist ein Sperrfluss, falls jeder (gerichtete) s-t-Weg in SNf eine saturierte Kante enthält. (e ist saturiert falls cf(e) = f’(e) ist.)

Achtung: Ein Sperrfluss in SNf ist nicht notwendig ein maximaler Fluss in SNf.

Beispiel:1

1

1

1

1

11



Algorithms and ComplexitySperrflüsse und der Algorithmus von Dinic

Ein Fluss f’ in SNf ist ein Sperrfluss, falls jeder (gerichtete) s-t-Weg in SNf eine saturierte Kante enthält. (e ist saturiert falls cf(e) = f’(e) ist.)

Achtung: Ein Sperrfluss in SNf ist nicht notwendig ein maximaler Fluss in SNf.

Algorithmus von DinicEingabe: Netzwerk N

f´ 0, berechne SNf;While “t ist Knoten von SNf” doBerechne Sperrfluss f’ in SNf;Berechne f* mit f*(v,w) = f(v,w) + f’(v,w) – f’(w,v);Berechne SNf* ;f:=f* Od

Ausgabe: f



Algorithms and ComplexityDer Algorithmus von Dinic

Eingabe: Netzwerk N

f´ 0, berechne SNf;While “t ist Knoten von SNf” doBerechne Sperrfluss f’ in SNf;Berechne f* mit f*(v,w) = f(v,w) + f’(v,w) – f’(w,v);Berechne SNf* ;f:=f* Od

Ausgabe: f

Lemma: Der Algo benötigt höchstens |V|-1 Durchläufen der While-Schleife.

Lemma: Die Berechnung eines Sperrflusses geht in Zeit O(|V||E|). (auch O(|V|2) ist möglich.).

Also:Satz: Der Algorithmus von Dinic berechnet in Zeit O(|V|2 |E|)

(bzw. sogar O(|V|3) einen maximalen Fluss.

• Wieviele Durchläufe der While –Schleife gibt es?

• Wie lange dauert die Berechnung eines Sperrflusses?



Algorithms and ComplexityDie Zahl der Durchläufe der While-Schleife

Lemma: Der Algo benötigt höchstens |V|-1 Durchläufen der While-Schleife.

Bew: Beh: Sei k die Länge der kürzesten s-t-Wege in Nf. Dann sind in Nf* alle s-

t-Wege länger als k.

Daraus folgt offensichtlich das Lemma.

Bew der Beh: Sei W ein s-t-Weg in Nf* .• Falls W nur Kanten aus Nf enthält, ist er länger als k, da von jedem Weg der Länge k in Nf eine Kante durch f’ saturiert wurde, also

nicht in Nf* liegt.• Sei ansonsten (v,w) die erste Kante in W, die nicht in Nf ist. Dann ist (w,v) auf einem kürzesten Weg in Nf. Seien V0,…, Vk die Schichten von

SNf. (v,w) sei die (i+1)-te Kante von W. Dann durchläuft W hintereinander die Schichten V0, V1, …,Vi, Vi-1, und danach

wird nie eine Kante von Vj nach Vj+s mit s¸ 2 genutzt. (Denn solche Kanten existieren nicht.) Somit hat W Länge mindestens k+2.



Algorithms and ComplexityBerechnung von Sperrflüssen

Lemma: Die Berechnung eines Sperrflusses geht in Zeit O(|V||E|).

Algorithmus:N* := SNf; f’ ´ 0 ;Solange es in N* einen (gerichteten) s-t-Weg W gibt doAddiere den Pfadfluss des Weges W mit Restkapazität r>0 zu f’;N* := N* \ “durch W saturierte Kanten” odAusgabe f’

Korrektheit: Falls es in N* keinen (gerichteten) s-t-Weg W gibt, ist f’ ein Sperrfluss.

Laufzeit: O(V) pro Schleifendurchlauf; es gibt höchstens |E| Schleifendurchläufe, da in jedem mindestens eine Kante aus N* entfernt wird.



Algorithms and ComplexityAnwendung: Bipartites Matching

Eingabe: bipartiter Graph G=(V1 [ V2,E)

Ausgabe: ein maximales Matching, d.h. ein Matching mit maximaler Kantenzahl

Kapazitäten 1 1 1

Maximaler Fluss = Maximales Matching




Perfekte Matchings und der Satz von Frobenius/Hall

Sei G=(V1 [ V2,E) bipartiter Graph mit |V1|=|V2| . Ein perfektes Matching in G ist ein Matching der Größe |V1|.

Satz von Frobenius/Hall, Heiratssatz:

G enthält ein perfektes Matching

, Für jedes Aµ V1 gilt : |(A)| ¸ |A| (d.h.:A hat mindestens |A| Nachbarn in V2. )

Folgt aus dem Max-Flow Min-Cut Theorem. (Übung)




Übersicht über Max-Flow Algorithmen (n=|V|, e=|E|, U=max{c(e), e2E)




Friedhelm Meyer auf der HeideHeinz Nixdorf Institute& Computer Science DepartmentUniversity of PaderbornFürstenallee 1133102 Paderborn, Germany

Tel.: +49 (0) 52 51/60 64 80Fax: +49 (0) 52 51/62 64 82E-Mail: [email protected]://www.upb.de/cs/ag-madh

Thank you for your attention!Thank you for your attention!

Algorithmen und Komplexität Teil 1: Grundlegende Algorithmen

Documents

Transcript of Algorithmen und Komplexität Teil 1: Grundlegende Algorithmen