Approximationsalgorithmen

Makespan-Scheduling Kapitel 4: Approximationsalgorithmen (dritter Teil) (weitere Beispiele und Illustrationen an der Tafel) Hilfreiche Literatur: Vazarani: Approximation Algorithms, Springer Verlag, 2001. Hochbaum: Approximation Algorithms for NP-Hard Problems, Thomson Publishing, 1996. Ausiello, Crescenzi, Gambosi, Kann, Marchetti-Spaccamela, Protasi: Complexity and Approximation: Combinatorial Optimization Problems and Their Approximability Properties, Springer Verlag, 1999. 1 Wir untersuchen ein fundamentales Problem aus der Schedulingtheorie. MAKESPAN SCHEDULING: Gegeben sei eine Menge von Jobs [n] = {1,..., n} mit Laufzeiten p 1,..., p n N und eine natürliche ahl m. Gesucht ist eine uteilung f : [n] [m] der n Jobs auf m identische Maschinen, so dass der Makespan, also max minimiert wird. p i j [m] i [n]:f(i)=j Diese uteilung wird als Schedule (Ablaufplan) bezeichnet. u einem Schedule gehört normalerweise auch eine Beschreibung, in welcher Reihenfolge die Jobs auf den einzelnen Maschinen abgearbeitet werden. Diese Reihenfolge spielt jedoch bei der Makespan-Minimierung offensichtlich keine Rolle. 2

Algorithmus Least-Loaded (LL): Für i = 1 bis n, weise Job i derjenigen Maschine zu, die bisher die geringste Last hat. Wie gut ist diese Heuristik? ein Beispiel: Sei n = m 2 + 1. Jobs 1 bis m 2 haben Laufzeit 1. Job m 2 + 1 hat Laufzeit m. Die LL-Heuristik erreicht den Makespan 2m. Der optimale Makespan ist m + 1. Damit ist der Approximationsfaktor bestenfalls 2. Der folgende Satz zeigt, dass dieses Beispiel tatsächlich den schlimmsten Fall beschreibt. Satz 1 LL garantiert eine 2-Approximation. Beweis: Es gelten die folgenden zwei trivialen unteren Schranke für ein optimales Schedule: opt max max(p 1 i), p i i [n] m. i [n] Wir gehen davon aus, jede Maschine arbeitet ihre Jobs nacheinander in der Reihenfolge ihrer uweisung ab. Sei i der Index desjenigen Jobs, der als letztes fertig wird. Sei j = f(i ), d.h. Maschine j wird als letztes fertig und bestimmt damit den Makespan. um eitpunkt als Job i Maschine j zugewiesen wurde, hatte diese Maschine die geringste Last. Die Last von Maschine j zu diesem eitpunkt war also höchsten 1 m i<i p i. Damit ist die Laufzeit von Maschine j höchstens ( ) 1 p i + p i 2opt. m i <i 3 4

Satz 2 LPT garantiert eine 4 3 -Approximation. Beweis: Algorithmus Longest-Processing-Time (LPT): 1. Sortiere die Jobs, so dass p 1 p 2 p n ; 2. Für i = 1 bis n, weise Job i derjenigen Maschine zu, die bisher die geringste Last hat. Graham hat 1969 gezeigt, dass LPT einen Approximationsfaktor von höchstens 4 3 hat. Auch diese Schranke ist scharf. um wecke des Widerspruchs nehmen an, es gibt eine Eingabeinstanz für die LPT einen Makespan von τ > 4 3opt auf m Maschinen erzeugt. Sei p 1, p 2,..., p n eine Eingabeinstanz minimaler Länge mit τ > 4 3 opt. Es gelte p 1 p 2 p n. Sei i der Index desjenigen Jobs, der als letztes fertig wird. Es gilt i = n, sonst waere ja p 1,..., p i, i < n, eine kürzere Eingabesequenz mit τ > 4 3opt, aber wir haben angenommen p 1, p 2,..., p n ist die kürzeste Eingabe mit dieser Eigenschaft. Job n wird auf der am wenigsten belasteten Maschine platziert. um eitpunkt der uweisung von Job n hat diese Maschine höchstens Last 1 n 1 m i=1 p i opt. Damit τ > 4 3 opt gilt, muss also gelten p n > 1 3 opt. Aus p n > 1 3 opt folgt, jeder Job ist größer als 1 3opt, weil p 1 p 2 p n. 5 6

Falls jeder Job größer als 1 3opt, so kann ein optimaler Schedule nicht mehr als zwei Jobs an eine Maschine zuweisen. Jeder Schedule mit höchstens zwei Jobs pro Maschine kann in den folgenden schematisch dargestellten Schedule überführt werden, ohne den Makespan zu erhöhen (vgl. Übung). n...... m+1 Das Makespan-Scheduling-Problem ist stark NP-vollständig. Es gibt also kein FPAS für dieses Problem. Trotzdem werden wir zeigen, dass das Problem in Polynomialzeit beliebig gut approximiert werden kann. Wir sagen, ein Optimierungsproblem Π hat ein PAS (polynomial approximation scheme), falls für jede Konstante ɛ > 0 eine (1 ± ɛ)-approximation in polynomieller eit berechnet werden kann. Der Unterschied zum FPAS ist, dass ɛ hierbei als konstant angesehen wird. 1 2 3......... m 1 m Dieser Schedule entspricht jedoch genau dem LPT- Schedule. Also berechnet LPT einen optimalen Schedule. Dies ist ein Widerspruch zu unserer Annahme τ > 4 3 opt. Somit folgt τ 4 3opt, und der Approximationsfaktor ist höchstens 4 3. Wir werden zeigen, dass das Makespan-Scheduling-Problem ein PAS mit Laufzeit ungefähr n 1/ɛ2 hat. Für ein FPAS wäre eine derartige Laufzeitschranke nicht zulässig, weil sie nicht polynomiell in 1 ɛ ist. Für kleines ɛ ist die obige Laufzeitschranke offensichtlich nicht praktikabel. Wir wollen uns trotzdem einmal ansehen, wie ein derartiges Approximationsschema aussieht. Dieses PAS ist aber eher unter komplexitätstheoretischen als unter praktischen Gesichtspunkten interessant. 7 8

Ein PAS für MAKESPAN-SCHEDULING: 1. Ein Orakel verrät uns den Wert des optimalen Makespans, den wir nennen. 2. Wir kümmern uns zunächst um die großen Jobs, d.h. um die Jobs {i [n] p i > ɛ}. a) Wir skalieren und runden die Laufzeiten der großen Jobs d.h. wir setzen p pi i = ɛ 2. b) Wir berechnen einen Schedule für die aufgerundeten Laufzeiten mit Makespan höchstens = (1 + ɛ) ɛ 2. 3. Jetzt kümmern wir uns um die kleinen Jobs, d.h. um die Jobs {i [n] p i ɛ}. Wir verteilen diese Jobs mittels der LL-Heuristik auf das durch die großen Jobs entstandene Gebirge. 9 Bemerkung zu Schritt 2: Das Skalieren in Schritt 2a) läßt sich am Besten durch ein Beispiel illustrieren. Sei = 1000 und ɛ = 1 10. Dann setzen wir p pi pi i = ɛ 2 =. 10 Aus p i = 222 wird also p i = 23. Beachte, das Aufrunden von 22,2 auf 23 verzehrt den Wert höchstens um den Faktor 1 + ɛ, weil wir nur die Laufzeiten von großen Jobs mit Laufzeit p p i ɛ bzw. skalierter Laufzeit i ɛ 2 1 ɛ aufgerunden. Ohne die Skalierung und das Runden gibt es ein Schedule mit Makespan. Nach der Skalierung (ohne das Runden) gibt es also ein Schedule mit Makespan /(ɛ 2 ). Wenn jeder Job einen Rundungsfehler von höchstens 1 + ɛ hat, erhöht sich dieser Wert maximal um den Faktor 1 + ɛ. Also gilt nach dem Runden einen Schedule mit Makespan höchstens = (1 + ɛ) ɛ 2 Das Abrunden können wir uns erlauben, weil der Makespan ja weiterhin ganzzahlig ist. Somit existiert der in Schritt 2b) beschriebene Schedule. Wie aber können wir diesen Schedule berechnen? Bevor wir diese Frage klären, kümmern wir uns zunächst um den Approximationsfaktor. 10.

Lemma 3 Der skizzierte Algorithmus berechnet eine (1 + ɛ)- Approximation für den minimalen Makespan. Beweis: unächst nehmen wir an es gibt nur große Jobs. Dann berechnet der Algorithmus einen Schedule mit Makespan höchstens (ɛ 2 ) = (1 + ɛ) ɛ 2 (ɛ 2 ) (1 + ɛ), also eine (1 + ɛ)-approximation. Die kleinen Jobs behandeln wir in einer Fallunterscheidung. Fall 1: Die LL-Heuristik erhöht den Makespan nicht. Dann erhalten wir eine (1 + ɛ)-approximation aufgrund obiger Überlegungen für die großen Jobs. Fall 2: Die LL-Heuristik erhöht den Makespan. In diesem Fall garantiert die Heuristik, dass der Lastunterschied zwischen der am stärksten und der am schwächsten belasteten Maschine nicht größer als der größte der kleinen Jobs ist. Damit ist der Lastunterschied zwischen unterschiedlichen Maschinen höchstens ɛ, und auch in diesem Fall ist eine (1 + ɛ)-approximation sichergestellt. Laufzeitanalyse von Schritt 2: ur Vereinfachung der Notation nehmen wir an, dass wir n große Jobs haben. In Schritt 2 müssen wir eine Variante des folgenden Problems lösen. BIN PACKING: Gegeben sei eine Menge von n Objekten mit Gewichten w 1,..., w n [k] = {1,..., k} und eine ahl b N. Wir möchten diese Objekte in eine möglichst kleine Anzahl von Kisten packen, wobei jede Kiste eine Gewichtsbeschränkung der Höhe b hat. Die Objekte des Bin-Packing-Problems repräsentieren dabei die großen Jobs des Schedulingproblems. Die Gewichte entsprechen den Laufzeiten, und die Gewichtsschranke b entspricht der oberen Schranke für den Makespan. Die optimale Lösung für das Bin-Packing-Problem spezifiziert eine Verteilung der Objekte auf höchstens m Kisten, aus der wir den gesuchten Schedule direkt ablesen können. 11 12

Lemma 4 Das Bin-Packing-Problem kann in eit O((bn) k ) gelöst werden. Beweis: Wir verwenden dynamische Programmierung und lösen dabei die folgenden Teilprobleme Sei f(n 1, n 2,..., n k ) die minimale Anzahl von Kisten in die wir eine Menge von Objekten bestehend aus n i (i [k]) vielen Objekten mit Gewicht i packen können. Sei Q = {(q 1,..., q k ) f(q 1, q 2,..., q k ) = 1, d.h. Q beschreibt alle Gewichtskombinationen, die in eine Kiste passen. Es gilt Q b k, weil gilt q i b für jedes i [k]. Es gilt die folgende Rekursionsgleichung: f(n 1, n 2,..., n k ) = 1 + min q Q f(n 1 q 1, n 2 q 2,..., n k q k ). Wir berechnen die Lösung dieser Gleichung für alle k-tupel aus [n] k in einer Tabelle der Größe n k. Die optimale Lösung kann leicht aus dieser Tabelle rekonstruiert werden. Die Berechnung eines Tabelleneintrages kostet eit Q b k. Damit ist die Laufzeit O(b k n k ). Das Bin-Packing-Problem kann also in eit O((bn) k ) gelöst werden. Diese Laufzeitschranke ist nur dann polynomiell, falls b nicht zu groß und k konstant ist. Was sind die Werte von b und k bezogen auf unser Schedulingproblem? Die maximale Laufzeit eines Jobs vor der Skalierung ist durch beschränkt, weil es ja einen Schedule mit Makespan gibt. Nach der Skalierung und Rundung ist die maximale Laufzeit also höchstens /(ɛ 2 ) = 1 ɛ. 2 Also können wir annehmen 1 k = ɛ 2 = O(1). O.B.d.A. gilt ɛ < 1. Daraus folgt b = = (1 + ɛ) ɛ 2 2 ɛ 2 = O(1). Für konstantes ɛ können wir somit die Laufzeit von Schritt 2 durch O((bn) k ) = O(n 1/ɛ2 ) abschätzen. 13 14

um Schluss müssen wir uns noch um das Orakel in Schritt 1 kümmern. Wir beobachten falls opt, so ist der Algorithmus erfolgreich, d.h. er findet einen Schedule mit Makespan höchstens (1 + ɛ); falls < opt, so ist der Algorithmus typischerweise nicht erfolgreich. Wir suchen einen Wert für opt, für den der Algorithmus erfolgreich ist. Diese Suche führen wir wir in Form einer Binärsuche durch. Der Wert S = i p i ist eine obere Schranke für den Makespan. Wir können also einen geeigneten Wert für durch eine Binärsuche auf den ahlen {1,..., S} mit O(log S) vielen Aufrufen unseres Algorithmus finden. Sei N die Länge der Eingabe in Bits. Dann gilt log S N. Die Laufzeit des Algorithmus ist somit O(Nn 1/ɛ2 ). Für konstantes ɛ > 0 ist die Laufzeit also polynomiell in der Eingabelänge. Wir erhalten den folgenden Satz. Satz 5 MAKESPAN-SCHEDULING hat ein PTAS. (Tipp: Setze dieses PTAS niemals in der Praxis ein.) 15