Einfacher Algorithmus für topologisches Sortieren 1: 2: 3: 4: 5: 6: 7: 8: 9: {(1) Initialisierung} i := 0 W := V {W – die Menge der noch nicht bearbeiteten Knoten} {(2) Rekursionsschritt} while ein Knoten x ∈ W ohne Vorgänger in W existiert do i := i + 1; ord(x) = i; W := W − {x} end while 1 Algorithmus für Topologisches Sortieren Eingabe: Gerichteter Graph G = (V, E) mit n Knoten und k Kanten Ausgabe: Topologische Sortierung ord : V → {1, . . . , n} von G, falls G azyklisch ist 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: {(1) Initialisierung} i := 0 {i – die letzte Zahl, die ord benutzt hat} U := ∅ {U - die Menge aller Knoten v mit IN [v] = 0} IN [1] := 0, . . . , IN [n] := 0 for alle Knoten v in V do for alle Knoten w mit einer Kante (v, w) in E do IN [w] := IN [w] + 1 end for end for for alle Knoten v in V do if IN [v] = 0 then U := U ∪ {v} end if end for {(2) Rekursionsschritt} while U einen Knoten v enthält do U := U − v i := i + 1 ord(v) := i for alle Knoten w mit (v, w) ∈ E do IN [w] := IN [w] − 1 if IN [w] = 0 then U := U ∪ {w} end if end for end while {(3) Ausgabe} Falls n = i, ist ord eine topologische Sortierung von G. Falls n > i, ist die Ausgabe ein Code dafür, dass G nicht azyklisch ist. 2 Algorithmus für 2-Färbung Eingabe: Ungerichteter Graph G = (V, E) Ausgabe: Eine 2-Färbung V = ROT ∪ BLAU , falls es eine gibt. 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: {1. Initialisierung} ROT := ∅ BLAU := ∅ F := ∅ {Menge der zuletzt gefärbten Knoten} {2. Rekursionsschritt} while V 6= ∅ do wähle v aus V V := V − {v} ROT := ROT ∪ {v} F := F ∪ {v} while F 6= ∅ do wähle w in F for alle Knoten u ∈ V mit (u, w) ∈ E do if w ∈ ROT then BLAU := BLAU ∪ {u} else ROT := ROT ∪ {u} end if F := F ∪ {u} V := V − {u} end for F := F − {w} end while end while {3. Ausgabe} Falls ROT oder BLAU eine Kante aus E enthalten, ist die Ausgabe ein Code dafür, dass G keine 2-Färbung hat. Falls weder ROT noch BLAU eine Kante enthält, ist dies die gesuchte 2-Färbung. 3 Algorithmus für gerichteter Weg Eingabe: Ein gerichteter Graph G = (V, E) und zwei Knoten v und w Augabe: JA, falls ein gerichteter Weg von v nach w führt, ansonsten NEIN 1: {Initialisierung:} 2: M := {v} 3: {Rekursionsschritt:} 4: while eine Kante (x, y) mit x ∈ M und y ∈ / M existiert do 5: M := M ∪ {y} 6: E := E − {(x, y)} 7: end while 8: {Ausgabe:} 9: JA, falls w ∈ M , NEIN falls w 6∈ M . 4 Algorithmus für Starke Komponenten Eingabe: gerichteter Graph G Aufgabe: Starke Kompontenen berechnen 1: K1 := ∅, . . . , Kn := ∅ 2: i := 0 {Komponenten initialisieren} 3: while V 6= ∅ do 4: i := i + 1 5: Wähle v ∈ V 6: for alle Knoten w ∈ V do 7: if es existieren gerichtete Wege v → · · · → w und w → · · · → v then 8: Ki := Ki ∪ { w } 9: V := V \ { w } 10: end if 11: end for 12: end while 5 Simulation einer 2-Band-TM durch eine 4-Spur-TM Gegeben: 2-Band TM M = (Q, Σ, δ, q0 , qf ) Konstruiere: 4-Spur TM M̄ mit • Zusatzspeicher (s1 , s2 , x) • Bandalphabet Γ = Σ̄ × { ⇑, # } × Σ̄ × { ⇑, # } \ { (#, #, #, #) } Simulation: 1. Anfang: ··· ··· ··· ··· # # # # v1 ⇑ # ⇑ v1 # # # ··· ··· ··· ··· vn # # # # # # # ··· ··· ··· ··· 2. Berechnungsschritte: 1: while true do 2: Lese Spur 1 nach s1 3: Gehe zu ⇑ auf Spur 4 (abhängig von x = ` oder x = r) 4: Lese Spur 3 nach s2 5: Berechne Folgezustand aufgrund aktuellem Zustand q von M und (s1 , s2 ) im Speicher 6: Kopfmarker gemäß Verhalten von M auf Spuren 2 & 4 anpassen 7: Falls M hält (bzw. akzeptiert), halten (bzw. akzeptieren) 8: Kopf von M̄ zu ⇑ auf Spur 2 bewegen 9: end while 6 Maximales Matching Grundbegriffe. Es sei G = (S, T, E) ein gegebener bipartiter Graph und M ⊆ E ein Matching von G: • e heißt freie Kante falls e 6∈ M und unfrei falls e ∈ M ; • x ∈ S ∪ T heißt freier Knoten, falls x kein Endknoten einer Kante von M ist; • ein Weg (oder Pfad) p in G heißt erweiternd falls seine Endknoten frei und seine Kanten abwechselnd frei und unfrei sind. Satz 1. Falls ein Matching M einen erweiternden Weg W hat, gibt es ein größeres Matching M 0 , das aus M dadurch ensteht, dass die freien und unfreien Kanten von W ausgetauscht werden. Satz 2. Jedes Matching, für das es keinen erweiternden Weg gibt, ist maximal. Algorithmus (angelehnt an Ford-Fulkerson-Methode für Maxflow) 1: {Initialisierung} 2: Setze K := ∅ 3: Forme aus dem gegebenen bipartiten Graphen G = (S, T, E) den um zwei Knoten erweiterten Graphen G0 = GK ; 4: {Matching Maximieren} 5: while Weg p von s nach t existiert in GK do 6: K := K ∪ { (x, y) | (x, y) ∈ E und (x, y) ∈ p } − { (x, y) | (x, y) ∈ E und (y, x) ∈ p }; 7: GK aktualisieren: die Richtung aller Kanten aus p umdrehen 8: end while 9: gib die Kantenmenge K ∩ E aus 7 Min Vertex Cover Eingabe: Ungerichteter Graph G = (V, E) Aufgabe: finde kleinste Menge D mit D ∩ e 6= ∅ für alle e ∈ E. Bemerkung: das zugrunde liegende E-Problem VC ist NP-vollständig. Approximationsalgorithmus 1: 2: 3: 4: 5: 6: 7: D := ∅ V := die Menge aller Knoten von G E := die Menge aller Kanten von G while E eine Kante (x, y) enthält do D := D ∪ {x, y} E := E − {v : v eine Kante mit Endknoten x oder y} end while 8 SIT(k) (Scheduling of Independent Tasks) Eingabe: Zahlen t1 , . . . , tn . Aufgabe: eine Funktion S : {1, . . . , n} → {1, . . . , k}, für die die Zahl T = max{ X ti , . . . , S(i)=1 X ti } S(i)=k minimal ist. Approximationsalgorithmus für SIT(k) 1: {Tm = die Zeit, die Maschine m bisher gearbeitet hat} 2: sortiere die gegebenen Zeiten, so dass t1 ≥ t2 ≥ · · · ≥ tn 3: for m = 1 to k do 4: Tm := 0 5: end for 6: for i = 1 to n do 7: m := ein Index mit Tm = min{T1 , . . . , Tk } 8: S(i) := m 9: Tm := Tm + ti 10: end for 9 Algorithmus für SIT(2) Idee: für S = t1 + · · · tn berechne die Mengen B(i) = { b ≤ S | b Summe einer Teilmenge von { t1 , . . . , ti }} 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: {Summe aller ti berechnen} S := t1 + t2 + · · · tn ; {Optimalwert berechnen} B(0) := { 0 }; for i = 1, . . . , n do B(i) := B(i − 1); for j = ti , ti + 1, . . . , S do if j − ti ∈ B(i) then B(i) := B(i) ∪ { j }; end if end for end for T := minimales b ∈ B(n) mit b ≥ S2 ; {Schedule berechnen} b := T ; for i = 1, . . . , n do if b − ti ∈ B(n) then S(i) := 1; b := b − ti ; else S(i) := 2; end if end for 10