Algorithmen 2. Kapitel: Approximationsalgorithmen. Thomas Worsch. Fakultät für Informatik Karlsruher Institut für Technologie

Transkript

1 Algorithmen 2 Algorithmen 2 Kapitel: Approximationsalgorithmen Thomas Worsch Fakultät für Informatik Karlsruher Institut für Technologie Wintersemester 2017/ / 40

2 Einleitung Überblick Einleitung NP-harte Probleme Job Scheduling Allgemeines TSP nur schwer a-approximierbar Metrisches TSP ist leicht approximierbar knapsack 2 / 40

3 Einleitung Suchprobleme für jede Probleminstanz I M I gibt es Menge M S (I) möglicher Lösungen S M S (I) Zielfunktion f : I M I M S (I) R + Minimierungsproblem: für jedes I M I existiere f (I) = min{f (S) S M S (I)} gegeben: I gesucht: S mit f (S) = f (I) Maximierungspoblem: analog 3 / 40

4 Einleitung Approximation bei Suchproblemen Lösungen S mit f (S) = f (I) sind oft schwer zu finden z. B. NP-schwer Auswege: naiv: alle möglichen Lösungen betrachten oft zu aufwändig ad-hoc Heuristiken Qualität der Antwort eventuell unklar Approximationsalgorithmus A f (A(I)) «möglichst nahe an» f (I) Optimierungsaufgabe gerne polynomielle Laufzeit mit Garantie für Lösungsgüte 4 / 40

5 Einleitung Approximation bei «Zählproblemen» für jede Probleminstanz I M I gibt es Menge M S (I) möglicher Lösungen S M S (I) gesucht: Algorithmus A mit A(I) «möglichst nahe an» MS (I), der die Anzahl der Lösungen annähert Beispiel: bestimme die Anzahl perfekter Matchings eines bipartiten Graphen nicht in dieser Vorlesung 5 / 40

6 Einleitung NP-harte Probleme Turing-Reduzierbarkeit Das kam in «Theoretische Grundlagen der Informatik» vor: Suchproblem Π NP-schwer oder NP-hart, falls ein NP-vollständiges Entscheidungsproblem L existiert mit L p T Π. das heißt: es gibt Orakel-Turingmaschine für L mit Orakel für Π, jede Befragung des Orakels braucht 1 Schritt die polynomielle Laufzeit hat, Turing-Reduktion in Polynomialzeit das heißt: wenn Π in Polynomialzeit lösbar, dann auch L 6 / 40

7 Job Scheduling Überblick Einleitung Job Scheduling Allgemeines TSP nur schwer a-approximierbar Metrisches TSP ist leicht approximierbar knapsack 7 / 40

8 Job Scheduling Job Scheduling: Aufgabenstellung Problem: Job Shop Scheduling oder Makespan Scheduling Maschinen M 1,..., M m Jobs J 1,..., J n Job Jj benötigt Zeit t j 0 Lösung S : {1,..., n} {1,... m} Last von Maschine i: L i = S(j)=i t j Zielfunktion: minimiere Makespan L max = max i L i Wann ist die letzte Maschine fertig? einfacher Fall identische Maschinen unabhängige Jobs Problem ist NP-hart 8 / 40

9 Job Scheduling naheliegender Algorithmus: listscheduling 9 / 40

10 Job Scheduling naheliegender Algorithmus: listscheduling 1 listscheduling(n, m, t 1...n ) 2 each L i 0 load of machine i, 1 i m 3 each S j 0 machine for job j, 1 j n 4 for each j in range(1, n) 5 do pick k from {i L i is currently minimal } 6 S j k 7 L k L k + t j 8 return S im folgenden kurz LS statt listscheduling 9 / 40

11 Job Scheduling Eigenschaften des Algorithmus (1) Lemma Es sei T = j t j. Für jede Lösung S des Algorithmus gilt: Wenn J l ein Job ist, der zuletzt fertig wird, dann ist L max T m + m 1 m t l Beweis t = L max t l Startzeitpunkt von J l 10 / 40

12 Job Scheduling Eigenschaften des Algorithmus (1) Lemma Es sei T = j t j. Für jede Lösung S des Algorithmus gilt: Wenn J l ein Job ist, der zuletzt fertig wird, dann ist Beweis t = L max t l L max T m + m 1 m t l Startzeitpunkt von J l bis hierhin alle beschäftigt, mit Jobs J l, also mt T t l, also L max = t + t l T m t l m + t l 10 / 40

13 Job Scheduling Approximationsfaktor Approximationsalgorithmus A für Minimierungsproblem mit Zielfunktion f erzielt Approximationsfaktor ρ, falls für alle Probleminstanzen I M i gilt: f (A(I)) f (I) ρ ρ = 1: A liefert stets eine optimale Lösung 11 / 40

14 Job Scheduling Eigenschaften des Algorithmus (2) Satz LS erzielt Aproximationsfaktor ρ 2 1 m. Beweis stets: f (I) T/m und für jedes j: f (I) t j sei I beliebig: f (LS(I)) f (I) T/m f (I) + m 1 m T/m T/m + m 1 m t l f (I) t l = 2 1 t l m 12 / 40

15 Job Scheduling Eigenschaften des Algorithmus (3) Lemma LS erzielt Aproximationsfaktor ρ 2 1 m. Beweis 13 / 40

16 Job Scheduling Eigenschaften des Algorithmus (3) Lemma LS erzielt Aproximationsfaktor ρ 2 1 m. Beweis Probleminstanzen bei denen f (LS(I)) = 2m 1 und f (I) = m: m(m 1) Jobs mit t1 = = t n 1 = 1 letzter Job mit tn = m LS: alle m Maschinen bis t = m 1 nur Minijobs, dann der große L max = m 1 + m = 2m 1 optimal: eine Maschine nur den großen Job, m 1 machen je m Minijobs L max = m 13 / 40

17 Allgemeines TSP nur schwer a-approximierbar Überblick Einleitung Job Scheduling Allgemeines TSP nur schwer a-approximierbar Metrisches TSP ist leicht approximierbar knapsack 14 / 40

18 Allgemeines TSP nur schwer a-approximierbar Erinnerung: TSP-Suchproblem Probleminstanz vollständiger Graph G = (V, E = V V) und Längenfunktion c : E Z+ für Permutation π von V: f (π) = n 1 i=1 c(π(i), π(i + 1)) + c(π(n), π(1)) f (G, c) = min π f (π) gesucht: Permutation π mit minimalem f (π) = f (G, c) 15 / 40

19 Allgemeines TSP nur schwer a-approximierbar TSP-a-Approximations-Suchproblem gegeben: a 1 Probleminstanz vollständiger Graph G = (V, E = V V) und Längenfunktion c : E Z+ für Permutation π von V: f (π) = n 1 i=1 c(π(i), π(i + 1)) + c(π(n), π(1)) gesucht: Permutation π mit f (π) a f (G, c) kurz a-approxtsp 16 / 40

20 Allgemeines TSP nur schwer a-approximierbar Erinnerung: Hamiltonkreis (Entscheidungsproblem) Probleminstanz: Graph G = (V, E) Frage: Gibt es einen Hamiltonkreis in G? i. e. Permutation π so, dass (π(1), π(2), π(n), π(1)) Kreis hamiltoniancircuit ist NP-vollständig 17 / 40

21 Allgemeines TSP nur schwer a-approximierbar Schwere Approximierbarkeit des TSP Satz Für jede Konstante a 1 ist das TSP-a-Approximations-Suchproblem NP-hart. Beweisidee 18 / 40

22 Allgemeines TSP nur schwer a-approximierbar Schwere Approximierbarkeit des TSP Satz Für jede Konstante a 1 ist das TSP-a-Approximations-Suchproblem NP-hart. Beweisidee zeige: wenn a-approxtsp in Polynomialzeit lösbar, dann auch hamiltoniancircuit 18 / 40

23 Allgemeines TSP nur schwer a-approximierbar Schwere Approximierbarkeit des TSP: Konstruktion gegeben: G = (V, E) mit n = V definiere: G = (V, V V) und Längenfunktion c 19 / 40

24 Allgemeines TSP nur schwer a-approximierbar Schwere Approximierbarkeit des TSP: Konstruktion gegeben: G = (V, E) mit n = V definiere: G = (V, V V) und Längenfunktion c mit { 1, falls (u, v) E c(u, v) = an + 1, sonst sei aatsp Algorithmus für a-approxtsp Suchproblem 19 / 40

25 Allgemeines TSP nur schwer a-approximierbar Schwere Approximierbarkeit des TSP: Konstruktion gegeben: G = (V, E) mit n = V definiere: G = (V, V V) und Längenfunktion c mit { 1, falls (u, v) E c(u, v) = an + 1, sonst sei aatsp Algorithmus für a-approxtsp Suchproblem wenn G Hamiltonkreis hat, dann hat G Kreis der Länge n 19 / 40

26 Allgemeines TSP nur schwer a-approximierbar Schwere Approximierbarkeit des TSP: Konstruktion gegeben: G = (V, E) mit n = V definiere: G = (V, V V) und Längenfunktion c mit { 1, falls (u, v) E c(u, v) = an + 1, sonst sei aatsp Algorithmus für a-approxtsp Suchproblem wenn G Hamiltonkreis hat, dann hat G Kreis der Länge n aatsp(g, c) liefert Lösung an 19 / 40

27 Allgemeines TSP nur schwer a-approximierbar Schwere Approximierbarkeit des TSP: Konstruktion gegeben: G = (V, E) mit n = V definiere: G = (V, V V) und Längenfunktion c mit { 1, falls (u, v) E c(u, v) = an + 1, sonst sei aatsp Algorithmus für a-approxtsp Suchproblem wenn G Hamiltonkreis hat, dann hat G Kreis der Länge n aatsp(g, c) liefert Lösung an wenn G keinen Hamiltonkreis hat, dann hat jeder Kreis von G Länge an n 1 > an 19 / 40

28 Allgemeines TSP nur schwer a-approximierbar Schwere Approximierbarkeit des TSP: Konstruktion gegeben: G = (V, E) mit n = V definiere: G = (V, V V) und Längenfunktion c mit { 1, falls (u, v) E c(u, v) = an + 1, sonst sei aatsp Algorithmus für a-approxtsp Suchproblem wenn G Hamiltonkreis hat, dann hat G Kreis der Länge n aatsp(g, c) liefert Lösung an wenn G keinen Hamiltonkreis hat, dann hat jeder Kreis von G Länge an n 1 > an aatsp(g, c) liefert Lösung > an 19 / 40

29 Metrisches TSP ist leicht approximierbar Überblick Einleitung Job Scheduling Allgemeines TSP nur schwer a-approximierbar Metrisches TSP ist leicht approximierbar knapsack 20 / 40

30 Metrisches TSP ist leicht approximierbar metrictsp wie bei TSP, aber zusätzlich wird verlangt, dass c der Dreiecksungleichung genügt: für alle x, y, z V: c(x, y) + c(y, z) c(x, z) metrische «Vervollständigung» mv(g, c) von (G, c): mv(g, c) = (G, c ) mit c (x, y) = Länge kürzester Wege von x nach y «Vervollständigung» hier irreführendes Wort woher kommt das wohl? Konstruktion eben: Dreiecksungleichung im allgemeinen verletzt 21 / 40

31 Metrisches TSP ist leicht approximierbar Satz Für Instanzen des metrictsp Suchproblems kann man in Polynomialzeit eine 2-Approximation berechnen. Beweisidee 1 metrictspapprox(g, c) 2 T MST(G, c) w(t) f (G, c) 3 T T with every edge doubled w(t ) 2f (G, c) 4 T eulertour(t ) w(t ) 2f (G, c) 5 S remove duplicate nodes from T w(s) 2f (G, c) 6 return S 22 / 40

32 knapsack Überblick Einleitung Job Scheduling Allgemeines TSP nur schwer a-approximierbar Metrisches TSP ist leicht approximierbar knapsack Algorithmen mit pseudopolynomieller Laufzeit knapsack Suchproblem Ein FPTAS für Knapsack 23 / 40

33 knapsack Algorithmen mit pseudopolynomieller Laufzeit Pseudopolynomielle Laufzeit Wovon hängt die Laufzeit eines Algorithmus ab? Laufzeit t(i) eines Algorithmus für eine Eingabe I abhängig von Größe n(i) der Repräsentation von I üblich: n(i) ist Anzahl n 2 (I) der Bits um I binär zu codieren Codierung von k N+ braucht Θ(log 2 k) Bits polynomielle Laufzeit t(n): exisitert Polynom p(n) für alle I gilt: t(i) p(n 2 (I)) alternativ: n(i) ist Anzahl n 1 (I) der Bits um I unär zu codieren Codierung von k N+ braucht k Bits pseudopolynomielle Laufzeit t(n): exisitert Polynom p(n) für alle I gilt: t(i) p(n 1 (I)) 24 / 40

34 knapsack Algorithmen mit pseudopolynomieller Laufzeit Zwei kleine Warnungen Algorithmus mit pseudopolynomieller Laufzeit: tatsächliche Form der Eingabe? pseudopolynomielle Laufzeit nicht verwechseln mit quasipolynomieller Laufzeit: für eine Konstante c > 0 Beispiel: c = 2 n log n t(n) = 2 O((log n)c ) 25 / 40

35 knapsack knapsack Suchproblem knapsack Suchproblem Probleminstanzen endliche Menge M = {1,..., n} von Gegenständen Maximalgröße W N + «Rucksackgröße» Größen w i N + o. B. d. A. jedes w i W Profite p i N + Lösungen Teilmenge M M mit w(m ) = i M w i W gesucht Teilmengen mit möglichst großem Profit Zielfunktion f (M ) = p(m ) = i M p i Maximierungsproblem o. B. d. A. f (I) max p i 26 / 40

36 knapsack knapsack Suchproblem knapsack: Codierungen der Eingabe Teil T von I u 2 (T) u 1 (T) {1,..., n} log n n W log W W w 1,..., w n n log W nw p 1,..., p n n log ˆP nˆp insgesamt Θ(n log W + n log ˆP) Θ(nW + nˆp) wobei ˆP = i p i 27 / 40

37 knapsack knapsack Suchproblem Schwere des knapsack Suchproblems NP-schwer bei «normaler» Messung der Eingabegröße also Polynomialzeit-Algorithmen unbekannt aber: pseudopolynomielle Laufzeit erreichbar solche Probleme heißen schwach NP-schwer 28 / 40

38 knapsack knapsack Suchproblem knapsack: pseudopolynomielle Laufzeit mit dynamischer Programmierung es sei C(i, P) = min{w(m ) M {1,..., i} p(m ) P} falls eine solche Teilmenge M existiert, und sonst. Beobachtung: C(1, P) = { w 1,, sonst falls p 1 P C(i + 1, P) = min( C(i, P), w i+1 + C(i, P p i+1 ) ) 29 / 40

39 knapsack knapsack Suchproblem knapsack: pseudopolynomielle Laufzeit 1 dynprogknapsack(n, W, w 1,..., w n, p 1,..., p n ) 2 for P 1 to ˆP do 3 C(1, P)... 4 for i 1 to n 1 do 5 for P 1 to ˆP do 6 C(i + 1, P) min( C(i, P), w i+1 + C(i, P p i+1 ) 7 return max{p C(n, P) W } Erweiterung speichere in C(i, P) auch, welche der Objekte 1,..., i benutzt Lösung: sogar konkrete Teilmenge/Bitvektor x Skalarprodukt p x ist maximaler Profit 30 / 40

40 knapsack Ein FPTAS für Knapsack Polynomielle Approximationsschemata Polynomial Time Approximation Scheme (PTAS) es sei Π ein { } Minimierungs- Maximierungs- Problem es sei A Algorithmus mit Paaren (I, ε) als Eingaben, wobei ε > 0 reell und I Π I ist A polynomielles Approximationsschema (engl. PTAS), wenn für jedes ε > 0 ein Polynom p(n) so existiert, dass für jede Instanz I gilt f (A(I, ε)) ( ) 1 + ε f (I) 1 ε und Laufzeit t(i, ε) p(n 2 (I)) 31 / 40

41 knapsack Ein FPTAS für Knapsack Voll polynomielle Approximationsschemata Fully Polynomial Time Approximation Scheme (FPTAS) { } Minimierungs- es sei Π ein Problem Maximierungs- es sei A mit Paaren (I, ε) als Eingaben, wobei ε > 0 reell und I M I ist A voll polynomielles Approximationsschema (engl. PTAS), wenn ein Polynom p(n, x) so existiert, dass für jede Instanz I und jedes ε > 0 gilt f (A(I, ε)) ( ) 1 + ε f (I) 1 ε und Laufzeit t(i, ε) p(n 2 (I), 1/ε) 32 / 40

42 knapsack Ein FPTAS für Knapsack PTAS versus FPTAS jedes FPTAS ist ein PTAS ( n ε )5 + n 2 + ε 42 aber nicht umgekehrt: PTAS- aber nicht FPTAS-Laufzeiten z. B. n + 2 1/ε n 1/ε 2 log n log ε 33 / 40

43 knapsack Ein FPTAS für Knapsack Von pseudopolynomieller zu polynomieller Laufzeit n 2 (I) Θ(n log W + n log ˆP) pseudopolynomielle Laufzeit Θ(nˆP) 34 / 40

44 knapsack Ein FPTAS für Knapsack Von pseudopolynomieller zu polynomieller Laufzeit n 2 (I) Θ(n log W + n log ˆP) pseudopolynomielle Laufzeit Θ(nˆP) polynomielle Laufzeit, wenn die Profite kleine Werte sind, z. B. für konstantes k, ˆP O(n) 2 k z. B. jedes 0 < pi < 2 k 34 / 40

45 knapsack Ein FPTAS für Knapsack FPTAS für knapsack Schreibweise p = p 1,..., p n, etc. 1 epsapproxknapsack(ε, n, W, w, p) 2 P max i p i 3 K εp/n 4 each p i p i/k 5 x dynprogknapsack(n, W, w, p ) 6 return x 35 / 40

46 knapsack Ein FPTAS für Knapsack FPTAS für knapsack Schreibweisen x optimale Lösung für ursprüngliches p x optimale Lösung für p dann p x = p i = maximaler Profit des Originalproblems i,xi =1 Frage: Wie gut ist p x im Vergleich zu p x? 36 / 40

47 knapsack Ein FPTAS für Knapsack epsapproxknapsack ist FPTAS Satz epsapproxknapsack ist ein voll polynomielles Approximationsschema für knapsack. Lemma Mit den Bezeichnungen wie bisher p x (1 ε)p x 37 / 40

48 knapsack Ein FPTAS für Knapsack epsapproxknapsack ist FPTAS: Approximation K = εp/n und p i = p i/k, also Kp i p i p x Kp x Kp x weil x optimal für p pi = K K i x ( pi ) K K 1 = p i K i x i x i x p x nk = p x εp p x εp x = (1 ε)p x weil Optimum max p i = P 38 / 40

49 knapsack Ein FPTAS für Knapsack epsapproxknapsack ist FPTAS: Polynomialzeit Lemma Die Laufzeit von epsapproxknapsack ist in O(n 3 1 ε ). dynamischen Programmierung für p -Problem dominiert: Laufzeit n ˆP es ist (mit P = max i p i ) n ˆP = n i p i n2 max i p i = n2 P K = n 2 Pn εp n 3 1 ε 39 / 40

50 knapsack Ein FPTAS für Knapsack Varianten von Approximation: zwei Beispiele bestes bekanntes FPTAS linear in n in der Praxis erreicht man «fast Linearzeit» 40 / 40