Einführung in Approximationsalgorithmen

Einführung in Approximationsalgorithmen Skript zur Vorlesung Effiziente Algorithmen von Berthold Vöcking, RWTH Aachen 30. Juli 2008 Hilfreiche Literatur Vazirani: Approximation Algorithms, Springer Verlag, 2001. Jansen, Margraf: Approximative Algorithmen und Nichtapproximierbarkeit, de Gruyter, 2008. Wanka: Approximationsalgorithmen Eine Einführung, Teubner Verlag 2006. 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. Garey, Johnson: Computers and Intractability, Freeman and Company, 1979. 1

Inhaltsverzeichnis 1 Einleitung 3 1.1 Konstante Approximationsfaktoren................... 3 1.2 Eine 2-Approximation für das Vertex-Cover-Problem......... 3 1.3 Approximationsfaktor als Funktion................... 4 1.4 Eine logarithmische Approximation für das Set-Cover-Problem.... 5 2 Optimierungsprobleme auf Graphen und Metriken 8 2.1 Approximierbarkeit von TSP...................... 8 2.2 Christofides Algorithmus für Metrisches TSP............. 8 2.3 Approximation des Steinerbaumproblems............... 11 3 Makespan-Scheduling auf identischen Maschinen 13 3.1 Analyse von zwei einfachen Heuristiken................ 13 3.2 Ein polynomielles Approximationsschema............... 16 4 Makespan-Scheduling auf allgemeinen Maschinen 21 2

1 Einleitung 1.1 Konstante Approximationsfaktoren Ein Approximationsalgorithmus für ein Optimierungsproblem berechnet eine zulässige Lösung, die den optimalen Zielfunktionswert nur annähernd erreicht. Die Güte der Lösung wird typischerweise durch einen Approximationsfaktor beschrieben. Sei A ein Approximationsalgorithmus für ein Optimierungsproblem Π. Sei I die Menge der möglichen Eingabeinstanzen für Π. Für I I bezeichne w A (I) den Wert, der von A für die Instanz I berechneten Lösung, und opt(i) den optimalen Lösungswert. Der Approximationsfaktor von Algorithmus A auf einer Eingabeinstanz I I ist definiert durch r A (I) = w A(I) opt(i). Ein Algorithmus für ein Minimierungsproblem garantiert einen (konstanten) Approximationsfaktor α 1, falls gilt I I : r A (I) α. Ein Algorithmus für ein Maximierungsproblem garantiert einen (konstanten) Approximationsfaktor α 1, falls gilt I I : r A (I) α. 1.2 Eine 2-Approximation für das Vertex-Cover-Problem Sei G = (V, E) ein Graph. Eine Teilmenge der Knoten U V wird als Vertex-Cover (Knotenüberdeckung) bezeichnet, falls jede Kante aus E inzident zu einem Knoten aus U ist. Problem 1.1 (Vertex Cover) Gegeben sei ein Graph G = (V, E). Gesucht ist ein Vertex-Cover kleinster Kardinalität. Das Vertex-Cover-Problem ist NP-hart und kann somit nicht in polynomieller Zeit optimal gelöst werden; es sei denn P=NP. Der folgende Algorithmus berechnet jedoch in Zeit O( E ) eine 2-Approximation. 3

Algorithmus Approx-Vertex-Cover Berechne ein inklusions-maximales Matching M E. Gib V (M), die Menge aller Endpunkte der Kanten in M, aus. Frage am Rande: Wie berechnet man ein inklusions-maximales Matching? Satz 1.2 Algorithmus Approx-Vertex-Cover berechnet eine 2-Approximation des optimalen Vertex Covers. Beweis: Korrektheit: Zu zeigen ist, V (M) deckt alle Kanten ab. Widerspruchsbeweis: Sei e eine nicht abgedeckte Kante. Dann ist e E \ M und M {e} ein Matching. Also ist M nicht inklusions-maximal. Ein Widerspruch! Approximationsfaktor: Sei opt die Kardinalität eines Vertex-Covers kleinster Kardinalität. Es gilt opt M, weil jedes Vertex-Cover mindestens einen Endpunkt jeder Kante in M abdecken muß. Somit gilt V (M) = 2 M 2 opt. 1.3 Approximationsfaktor als Funktion Im Allgemeinen wird der Approximationsfaktor als Funktion R : N R in einem geeigneten Parameter n N beschrieben. Beispielsweise könnte n die Anzahl der Knoten eines Eingabegraphen bezeichnen. Für n N bezeichne I n die Menge der Eingaben mit Parameter n. Ein Algorithmus für ein Minimierungsproblem garantiert einen Approximationsfaktor R(n), z.b. R(n) = 2 oder R(n) = ln n, falls gilt n N : I I n : r α (I) R(n). Ein Algorithmus für ein Maximierungsproblem garantiert einen Approximationsfaktor R(n), z.b. R(n) = 1 1 oder R(n) =, falls gilt 2 ln n n N : I I n : r α (I) R(n). 4

1.4 Eine logarithmische Approximation für das Set-Cover-Problem Problem 1.3 (Set Cover) Gegeben sei eine Grundmenge X mit n Elementen, m Teilmengen S 1,...,S m der Grundmenge X mit i {1,...,m} S i = X, und für jede Teilmenge i {1,..., m} ein Kostenwert c i N. Gesucht ist eine Auswahl der Teilmengen A {1,...,m} mit minimalen Kosten cost(a) = i A c i unter der Nebenbedingung i A S i = X. In Worten: Alle Elemente der Grundmenge sollen zu möglichst geringen Kosten abgedeckt werden. Anwendungsbeispiel. Sei X eine Menge von Fähigkeiten. Es gebe m Personen, von denen jede über einige der Fähigkeiten in X verfügt. Person i verfüge über die Fähigkeiten S i X und verlange die Bezahlung c i. Wir möchten ein möglichst günstiges Arbeitsteam A {1,...,m} zusammenstellen, so dass alle Fähigkeiten aus X abgedeckt sind. Auch das Set-Cover-Problem ist NP-hart, da es eine Verallgemeinerung des Vertex- Cover-Problems ist. Warum? Ein Graph, in dem Kanten nicht nur aus zwei Knoten bestehen, sondern aus Teilmengen von beliebig vielen Knoten heißt Hypergraph. Diese Teilmengen der Knoten heißen Hyperkanten. Beim Vertex-Cover-Problem für einen Hypergraphen H = (V, E) muss eine Knotenmenge U V minimaler Kardinalität gewählt werden, so dass jede der Hyperkanten zu mindestens einem Knoten in U inzident ist. Beim gewichteten Vertex-Cover-Problem haben die Knoten Gewichte und die Summe der Gewichte in U soll minimiert werden. Das gewichtete Vertex-Cover-Problem für Hypergraphen ist auch unter dem Namen Hitting-Set-Problem bekannt. Das Set-Cover-Problem entspricht dem Hitting-Set-Problem, wenn man die Mengen S 1,...,S m mit den Knoten des Hypergraphen identifiziert und die Grundmenge X mit den Kanten, wobei ein Knoten S i genau dann in einer Kante x X enthalten ist, wenn gilt x S i. 5

Algorithmus Greedy-Set-Cover Startend mit A =, solange A nicht alle Elemente aus X abdeckt sind, füge jeweils denjenigen Mengeindex i {1,..., m} zu A hinzu, der die niedrigsten relativen Kosten r(i A) hat, wobei r(i A) = c i S i \ j A S j. Wie gut ist diese Heuristik? Zum Zwecke der Analyse verteilen wir die Kosten des Algorithmus auf die Elemente der Grundmenge: Die Kosten, die ein zu A hinzugefügter Index i verursacht, werden gleichmäßig auf diejenigen Elemente aus S i verteilt, die bisher noch nicht abgedeckt waren. Jedes dieser Elemente erhält somit einen Kostenanteil in Höhe von c i S i \ j A S j = r(i A). Sei nun x k X das k-te Element, das durch den Algorithmus abgedeckt wird, wobei wir in derselben Iteration abgedeckte Elemente beliebig anordnen. Bezeichne c(x k ) die dem Element x k zugeteilten Kosten. Lemma 1.4 Für k {1,...,n} gilt c(x k ) opt/(n k + 1), wobei opt die Kosten eines optimalen Set-Covers bezeichnet. Beweis: Bezeichne i {1,..., m} den Index derjenigen Menge durch deren Hinzunahme Algorithmus Greedy-Set-Cover das Element x k erstmalig abdeckt. Betrachte die Auswahl A unmittelbar vor der Hinzunahme der Menge S i. Wir leiten eine untere Schranke für opt her: Jeder Mengenindex j {1,...,m} \ A hat relative Kosten von mindestens r(i A), da i der Index mit den geringsten relativen Kosten ist. Sei X ist die Menge der nicht durch A abgedeckten Elemente, d.h. X = X \ j A S j. Für keines der Elemente aus X gibt es somit eine Teilmenge, die es mit relativen Kosten kleiner als r(i A) abdecken kann. Die Summe der relativen Kosten, die zur Abdeckung der n k + 1 Elemente aus X benötigt wird, ist somit mindestens (n k + 1) r(i A). Jede Auswahl an Teilmengen die X abdeckt hat somit Kosten in mindestens dieser Höhe. Es folgt opt (n k+1) r(i A) = (n k+1) c(x k ) und somit c(x k ) opt/(n k+1). 6

... 1+ ε 1/n 1/(n 1) 1/(n 2) 1/3 1/2 1 Abbildung 1: Beispiel einer Set-Cover-Instanz. Wie lautet die optimale Lösung für dieses Set-Cover-Instanz. Was sind die Kosten des Greedy-Algorithmus? Die k-te Harmonische Zahl ist definiert durch H k = k i=1 ln(n + 1) H n ln n + 1. 1. Es gilt i Satz 1.5 Algorithmus Greedy-Set-Cover hat einen Approximationsfaktor von höchstens H n. Beweis: Die Summe der Kosten über alle Elemente ergibt die Gesamtkosten des Algorithmus. Lemma 1.4 zeigt, diese Kosten sind höchstens n i=1 opt n i + 1 = n i=1 opt i = opt H n. Es gibt eine Set-Cover-Instanz, für die die Greedy-Heuristik den Faktor (1 ɛ)h(n) für beliebig kleines ɛ > 0 erreicht, siehe Abbildung 1. Also war unsere Analyse exakt. Dieselbe untere Schranke lässt sich sogar für den Spezialfall nachweisen, in dem alle Mengen dieselben Kosten haben. Feige hat 1995 gezeigt, dass es keinen Polynomialzeit-Algorithmus mit Approximationsfaktor (1 ɛ)h(n) gibt, es sei denn NP = TIME(n O(log log n) ). Auch dieses Ergebnis gilt sogar dann, wenn alle Mengen dieselben Kosten haben. Unter den üblichen komplexitätstheoretischen Annahmen bedeutet dies, dass der einfache Greedy- Algorithmus den bestmöglichen Approximationsfaktor für Set-Cover liefert. Ein wirklich erstaunliches Ergebnis. 7

2 Optimierungsprobleme auf Graphen und Metriken 2.1 Approximierbarkeit von TSP Es stellt sich die Frage, ob jedes NP-harte Problem in polynomieller Zeit bis auf einen relativ kleinen Faktor approximiert werden kann? Die Antwort ist Nein. Beispielsweise kann das folgende Problem nicht sinnvoll approximiert werden. Problem 2.1 (Traveling Salesperson Problem - TSP) Gegeben sei ein vollständiger Graph G = (V, E) mit Kantenlängen aus N. Gesucht ist ein Hamilton-Kreis (auch TSP-Tour genannt) minimaler Länge. Satz 2.2 Sei α(n) eine beliebige polynomialzeit-berechenbare Funktion. Unter der Annahme P NP gilt, TSP hat keinen Polynomialzeit-Algorithmus mit Approximationsfaktor α(n), wobei n die Anzahl der Knoten im Graphen ist. Der Beweis für diesen Satzes wird in der Vorlesung Berechenbarkeit und Komplexität präsentiert. Die Beweisidee ist einfach: Mit Hilfe eines polynomiellen α(n)-approximationsalgorithmus kann man das NP-harte Hamiltonkreisproblem in polynomieller Zeit lösen. Daraus würde P=NP folgen. Beachte, der Satz schließt selbst eine 2 n -Approximation aus, da die Funktion 2 n in polynomieller Zeit berechnet werden kann. (Wie?) 2.2 Christofides Algorithmus für Metrisches TSP Die Nichtapproximierbarkeit von TSP basiert darauf, dass die TSP-Tour jeden Knoten nur einmal besuchen darf. Das ist keine besonders praktische Annahme, insbesondere dann nicht, wenn die direkte Verbindung von einem Knoten u zu einem Knoten v länger ist als der Weg von u zu v über einen oder mehrere Zwischenknoten. Zu jedem Graphen mit nicht-negativen Kantenlängen können wir eine Distanzmatrix angeben, die jeweils die Länge der kürzesten Verbindungen zwischen den Knoten beschreibt. Eine solche Distanzmatrix ist eine Metrik. Definition 2.3 (Metrik) Eine Metrik entspricht einem vollständigen ungerichteten Graphen mit nicht-negativen Kantenlängen, die die Dreiecksungleichung erfüllen, d.h. für jeweils drei Knoten u, v, w ist die Länge der Kante {u, v} nicht länger als die Summe der Längen der Kanten {u, w} und {w, v}. 8

Problem 2.4 (metrisches TSP) Gegeben sei eine Metrik G = (V, E) mit n Knoten und Kantenlängen aus N. Gesucht ist eine TSP-Tour minimaler Länge. Das metrische TSP ist ebenfalls NP-hart aber es gibt effiziente Algorithmen mit einem konstanten Approximationsfaktor für dieses Problem. Als Warm-Up starten wir mit einer 2-Approximation. Algorithmus Metric-TSP-via-MST 1 Finde einen MST T von G; 2 Verdopple die Kanten von T und erhalte einen Euler-Graphen T ; 3 Berechne eine Euler-Tour auf T ; 4 Bereinige die Euler-Tour um wiederholt vorkommende Knoten. MST steht für Minimum Spanning Tree (minimaler Spannbaum). Ein MST kann in polynomiell beschränkter Zeit mit einem Greedy-Algorithmus berechnet werden (Wie?). Ein Euler-Graph ist ein Graph, in dem jeder Knoten einen geraden Grad hat. Eine Euler-Tour durch einen Graphen ist ein Kreis, der jede Kante genau einmal enthält. Eine Euler-Tour existiert genau dann, wenn der Graph ein Euler-Graph ist. Auch eine Euler-Tour kann in polynomiell beschränkter Zeit berechnet werden (Wie?). Man kann die Euler-Tour um wiederholt vorkommende Knoten bereinigen, indem man an einem beliebigen Knoten startet, der Euler-Tour folgt und die Knoten in der Reihenfolge ihres ersten Auftretens ausgibt. Satz 2.5 Algorithmus Metric-TSP-via-MST berechnet eine 2-Approximation für das metrische TSP. Beweis: Aus einer TSP-Tour können wir einen Spannbaum erzeugen, indem wir eine Kante löschen. Also ist ein minimaler Spannbaum nicht teurer als die Länge einer minimalen TSP-Tour. Die Länge der berechneten Euler-Tour entspricht den doppelten Kosten des minimalen Spannbaums, ist also höchstens zweimal so lang wie die minimale TSP- Tour. Das Überspringen von mehrfach besuchten Knoten in Schritt 3 macht wegen der Dreiecksungleichung die Tour nicht teurer. 9

Der folgende Algorithmus ist ein echter Klassiker unter den Approximationsalgorithmen und wurde von Christofides im Jahr 1976 vorgestellt. Der Algorithmus von Christofides 1 Berechne einen MST T von G; 2 V := {v V v hat ungeraden Grad in T }; 3 Finde ein min-cost Matching M auf V ; 4 Finde eine Euler-Tour auf den Kanten aus T und M; 5 Bereinige die Euler-Tour um wiederholt vorkommende Knoten. Ein min-cost Matching auf V ist eine Kantenmenge M E, die jeden Knoten aus V genau einmal abdeckt und dabei die kleinstmöglichen Kosten hat, d.h. die Summe der Kantenlängen in M ist so klein wie möglich. Als Matchingkanten sind nicht nur die Baumkanten von T, sondern alle Kanten aus E zwischen den Knoten in V erlaubt. Beachte, jedes Knotenpaar in V ist durch eine Kante aus E miteinander verbunden, weil G eine Metrik und somit ein vollständiger Graph ist. Die Laufzeit des Algorithmus wird durch die Berechnung dieses Matchings dominiert. Das Matching kann in Zeit O(n 3 ) berechnet werden. Die Existenz eines perfekten Matchings ist gesichert, weil die Knoten in V vollständig miteinander verbunden sind und V eine gerade Anzahl von Knoten enthält. Letztere Eigenschaft folgt aus dem folgenden Lemma. Lemma 2.6 Gegeben sei ein beliebiger Graph H = (V, E). Sei V V die Teilmenge der Knoten, die einen ungeraden Grad haben. Dann ist V eine gerade Zahl. Beweis: Zum Zwecke des Widerspruchs nehmen wir an, dass V ungerade ist. Jede Kante in E ist inzident zu zwei Knoten, hat also zwei Endpunkte. Bezeichne q die Anzahl dieser Kantenendpunkte. Einerseits ist q = 2 E, und somit ist q eine gerade Zahl. Andererseits entspricht q der Summe der Knotengrade aller Knoten in V. Da wir annehmen, dass V ungerade ist, ist auch die Summe der Knotengrade in V ungerade. Somit ist auch die Summe der Knotengrade aller Knoten, also q, eine ungerade Zahl. Ein Widerspruch. Es folgt, V ist eine gerade Zahl. 10

Für eine Menge von Kanten X E (z.b. beschrieben in Form eines Matchings oder einer TSP-Tour) bezeichne cost(x) die Kosten von X, also die Summe der Kantenlängen in X. Bezeichne opt die minimalen Kosten einer TSP-Tour. Lemma 2.7 Es gilt cost(m) 1 2 opt. Beweis: Sei τ eine optimale TSP-Tour, also cost(τ) = opt. Aus τ erhalten wir einen Kreis τ, der die Knoten in V verbindet, wenn wir alle nicht in V enthaltenen Knoten streichen. Wegen der Dreiecksungleichung gilt cost(τ ) cost(τ). τ ist die Summe von zwei perfekten Matchings, die jeweils aus jeder zweiten Kante auf dem Kreis τ gebildet werden. Das günstigere der beiden Matchings hat höchstens die Kosten 1 2 cost(τ ) 1 2 cost(τ) = 1 2 opt. Also hat das günstigste perfekte Matching auf V höchstens die Kosten 1 2 opt. Satz 2.8 Der Algorithmus von Christofides berechnet eine 3 -Approximation für das 2 metrische TSP. Beweis: Die in Schritt 4 berechnete Euler-Tour hat die Kosten cost(t) + cost(m) opt + 1 2 opt = 3 2 opt. In Schritt 5 erhöhen sich die Kosten aufgrund der Dreiecksungleichung nicht. 2.3 Approximation des Steinerbaumproblems Problem 2.9 (Steinerbaum) Gegeben sei ein Graph G = (V, E) mit Kantenlängen bzw. Kosten c : E N und eine Knotenmenge T V. Die Knoten in T heißen Terminals. Gesucht ist ein Steinernetzwerk, das alle Terminals mit möglichst geringen Kosten verbindet, d.h. ein zusammenhängender Teilgraph G = (V, E ) von G mit T V, der die Summe der Kosten e E c(e) minimiert. 11

Das kostenminimale Steinernetzwerk ist natürlich ein Baum. Man spricht deshalb vom Steinerbaum- statt vom Steinernetzwerkproblem. Im Spezialfall T = V entspricht das Steinerbaumproblem dem Problem des Minimalen Spannbaums (MST) und ist somit in polynomieller Zeit lösbar. Im Allgemeinen ist das Steinerbaumproblem allerdings NP-hart. Algorithmus Approx-Steiner 1 Berechne die Distanzmatrix M für alle Paare von Terminals bzgl. von G. 2 Berechne einen MST für die Metrik G M (T) auf der Kontenmenge T mit Distanzen aus M. 3 Für jede Kante {u, v} in diesem MST bestimme einen kürzesten Weg von u nach v in G. 4 Gib den Graphen G mit allen Kanten und Knoten auf diesen Wegen aus. Der Algorithmus Approx-Steiner berechnet einen Teilgraphen G = (V, E ) von G, der alle Terminals miteinander verbindet. Wir behaupten die Kosten von G sind höchsten zweimal so groß wie die des optimalen Steinerbaums. G kann allerdings Kreise enthalten. Wenn man wirklich einen Steinerbaum möchte, kann man auf G nochmals einen MST-Algorithmus anwenden, und man erhält einen Steinerbaum dessen Kosten nicht größer als die Kosten von G sind. Satz 2.10 Algorithmus Approx-Steiner berechnet eine 2-Approximation für das Steinerbaumproblem. Beweis: Die Kosten des Graphen G sind nicht größer als die Kosten des MST für G M (T). Es gilt somit cost(g ) cost(mst(g M (T))). Wie wir schon bei der Analyse des TSP-Problems gesehen haben, gilt ferner cost(mst(g M (T))) cost(tsp(g M (T))), wobei TSP(G M (T)) eine TSP-Tour (also einen kürzesten Hamiltonkreis) in G M (T) bezeichnet. Eine T -Tour sei eine Rundreise in G, die alle Knoten aus T besucht. Eine kürzeste T - Tour in G benutzt nur kürzeste Wege zwischen den Terminals, entspricht somit einer TSP-Tour in G M (T) und hat die Länge cost(tsp(g M (T))). Man kann eine T -Tour erzeugen, indem man einen Steinerbaum umrundet, also jede Kante aus diesem Baum zweimal entlangläuft. Somit gilt cost(tsp(g M (T))) 2 opt, wobei opt die Kosten eines minimalen Steinerbaums bezeichnet. Der Satz folgt nun durch Zusammenfügen dieser drei Ungleichungen. 12

3 Makespan-Scheduling auf identischen Maschinen Wir untersuchen ein fundamentales Problem aus der Schedulingtheorie. Problem 3.1 (Makespan Scheduling auf identischen Maschinen) Gegeben sei eine Menge von Jobs [n] = {1,..., n} mit Größen p 1,..., p n N und eine natürliche Zahl m. Gesucht ist eine Zuteilung 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 Zuteilung wird als Schedule (Ablaufplan) bezeichnet. Zu 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 Minimierung des Makespans offensichtlich keine Rolle, deshalb gehen wir nicht weiter auf sie ein. 3.1 Analyse von zwei einfachen Heuristiken 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(m 1) + 1. Jobs 1 bis m(m 1) haben Größe 1. Job m(m 1) + 1 habe Größe m. Die LL-Heuristik erreicht den Makespan 2m 1. Der optimale Makespan ist m. 13

Damit ist der Approximationsfaktor bestenfalls (2m 1)/m = 2 1/m. Der folgende Satz zeigt, dass dieses Beispiel tatsächlich den schlimmsten Fall beschreibt. Satz 3.2 LL garantiert eine (2 1/m)-Approximation. Beweis: Es gelten die folgenden zwei trivialen unteren Schranken für ein optimales Schedule: (1) opt 1 p i (2) opt max m (p i). i [n] i [n] Wir gehen davon aus, jede Maschine arbeitet ihre Jobs nacheinander in der Reihenfolge ihrer Zuweisung 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. Zum Zeitpunkt als Job i Maschine j zugewiesen wurde, hatte diese Maschine die geringste Last. Die Last von Maschine j zu diesem Zeitpunkt war also höchstens 1 m i<i p i. Damit ist die Last von Maschine j höchstens ( ) ( ) 1 1 ( p i + p i = p i + 1 1 ) p i m m m i<i i i ( (1) & (2) opt + 1 1 ) opt. m 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. Satz 3.3 LPT garantiert eine 4 3 -Approximation. Beweis: Zum Zwecke des Widerspruchs nehmen wir an, es gibt eine Eingabeinstanz, für die LPT einen Makespan von τ > 4 3 opt 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. 14

n...... m+1 1 2 3......... m 1 m Abbildung 2: Optimaler Schedule, falls jeder Maschine nur zwei Jobs zugeordnet werden. Sei i der Index desjenigen Jobs, der als letztes fertig wird. Es gilt i = n, sonst wäre ja p 1,..., p i, i < n, eine kürzere Eingabesequenz mit τ > 4 opt, aber wir haben 3 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. Zum Zeitpunkt der Zuweisung von Job n hat diese Maschine höchstens Last 1 n 1 m i=1 p i opt. Damit τ > 4 opt gilt, muss 3 also gelten p n > 1 opt. Aus p 3 n > 1 opt und p 3 1 p 2 p n folgt nun, dass jeder Job größer als 1 opt ist. 3 Falls jeder Job größer als 1 opt, so kann ein optimaler Schedule nicht mehr als zwei 3 Jobs an eine Maschine zuweisen. Insbesondere gilt n 2m. Wenn jedoch nicht mehr als zwei Jobs pro Maschine zugewiesen werden dürfen, so ist es optimal Job i für i m auf Maschine i zu platzieren, und Job i für i > m auf Maschine m i + 1 zu platzieren, wie in Abbildung 2 dargestellt. Dies Aussage gilt offensichtlich für n m und folgt für jedes n {m + 1,...,2m} per Induktion von n 1 nach n. Dieser optimale Schedule entspricht nun aber genau dem LPT-Schedule. Dies ist jedoch ein Widerspruch zu unserer Annahme, dass LPT für die betrachtete Instanz einen Makespan von mehr als 4 opt erzielt. Somit folgt der Satz. 3 Wir haben jetzt einen Algorithmus mit Approximationsfaktor 2 und einen mit Approximationsfaktor 4 für das Makespan-Scheduling-Problem gesehen. Es gibt tatsächlich 3 noch einige ausgefuchstere Heuristiken, die auf der einen Seite etwas bessere Approximationsfaktoren garantieren, aber auf der anderen Seite auch eine längere, obgleich ebenfalls polynomiell beschränkte Laufzeit benötigen. Dies führt zu der Frage: Wie gut kann man das Makespan-Scheduling-Problem in polynomieller Zeit approximieren? Gibt es eine untere Schranke für den bestmöglichen Approximationsfaktor, den 15

man in polynomieller Zeit erreichen kann? Die Antwort ist Nein. Wir werden zeigen, dass es keine derartige untere Schranke geben kann, da das Problem beliebig gut in polynomieller Zeit approximiert werden kann. 3.2 Ein polynomielles Approximationsschema Wir sagen ein Optimierungsproblem Π hat ein polynomielles Approximationsschema, ein sogenanntes PTAS (Polynomial Time Approximation Scheme), falls für jede Konstante ɛ > 0 eine (1 + ɛ)- bzw. (1 ɛ)-approximation in polynomieller Zeit berechnet werden kann. Es gibt noch eine bessere, strengere Form eines Approximationsschemas: Π hat ein voll polynomielles Approximationsschema, ein sogenanntes FPTAS (Fully Polynomial Time Approximation Scheme), falls die Laufzeit für eine (1 ± ɛ)-approximation nicht nur polynomiell in der Eingabelänge beschränkt ist, sondern auch polynomiell in 1 ɛ. Das Problem des Makespan-Scheduling ist stark NP-hart, d.h. es ist selbst dann NPhart, wenn man die Eingabezahlen unär kodiert. Daraus folgt (vgl. Vorlesung Berechenbarkeit und Komplexität), dass das Problem kein FPTAS haben kann; es sei denn P=NP. Wir zeigen, dass das Problem jedoch ein PTAS hat. Bei der Beschreibung des PTAS setzen wir zunächst voraus, dass wir ein Orakel haben, das uns den optimalen Makespan verrät, so dass wir nur eine Zuordnung der Jobs finden müssen, die diesen Makespan bis auf einen Faktor 1 + ɛ erreicht. Um eine geeignete Realisierung des Orakels kümmern wir uns anschließend. 16

PTAS für Makespan-Scheduling 1. Ein Orakel verrät uns den Wert des optimalen Makespans, den wir Z nennen. 2. Wir weisen zunächst die großen Jobs zu, d.h. die Jobs {i [n] p i > ɛz}. a) Wir skalieren und runden die Größen dieser Jobs d.h. wir setzen p pi i =. ɛ 2 Z b) Wir berechnen einen Schedule bzgl. der Jobgrößen p i mit Makespan höchstens Z = (1 + ɛ) 1ɛ. 2 3. Jetzt weisen wir die kleinen Jobs zu, d.h. die Jobs {i [n] p i ɛz}. Wir verteilen diese Jobs mittels der LL-Heuristik auf das durch die großen Jobs entstandene Lastgebirge. Das Skalieren und Runden der Jobgrößen in Schritt 2a) läßt sich am Besten durch ein Beispiel illustrieren. Sei Z = 1000 und ɛ = 10%. Die großen Jobs haben dann mindestens Größe ɛz = 100. Wir gehen schrittweise vor: skalieren zunächst ohne zu runden, d.h. wir setzen p i = p i ɛ 2 Z = p i 10. Nach dem Runden setzen wir dann p i = p i. Aus p i = 101 ergibt sich also beispielsweise p i = 10.1 und p i = 11. Der relative Rundungsfehler in diesem Beispiel ist somit p i p i p i Dies gilt auch im Allgemeinen. = 11 10.1 10.1 10% = ɛ. Lemma 3.4 Der relative Rundungsfehler (p i p i)/p i ist höchstens ɛ. Beweis: Es folgt Für jeden großen Job i [n] gilt p i > ɛz und somit p i ɛz/(ɛ 2 Z) = 1/ɛ. p i p i p i 1 1/ɛ = ɛ. Das Aufrunden der skalierten Größen der großen Jobs verzehrt diese Größen also höchstens um den Faktor 1 + ɛ. 17

Bezüglich der eigentlichen Jobgrößen p i gibt es einen Schedule mit Makespan höchstens Z. Für die skalierten (ungerundeten) Jobgrößen p i gibt es also einen Schedule mit Makespan Z ɛ 2 Z = 1 ɛ 2. Durch die Rundung erhöht sich dieser Wert maximal um den Faktor 1 + ɛ. Also gibt es für die großen Jobs bezüglich der skalierten und gerundeten Jobgrößen p i einen Schedule mit Makespan höchstens (1 + ɛ) 1 ɛ 2. Wegen des Aufrundens der Jobgrößen ist der Makespan ganzzahlig. Also kann er tatsächlich höchstens den Wert (1 + ɛ) 1ɛ 2 = Z annehmen. Somit existiert der in Schritt 2b) beschriebene Schedule. Wie aber können wir diesen Schedule effizient berechnen? Bevor wir diese Frage klären, analysieren wir zunächst den Approximationsfaktor. Lemma 3.5 Der skizzierte Algorithmus berechnet eine (1 + ɛ)-approximation für den minimalen Makespan. Beweis: Zunächst nehmen wir an, es gibt nur große Jobs. Für diese Jobs berechnet der Algorithmus einen Schedule mit Makespan Z bezüglich der skalierten und gerundeten Jobgrößen. Bezüglich der eigentlichen Jobgrößen kann der Makespan höchstens um den Skalierungsfaktor ɛ 2 Z größer sein. Damit ist der Makespan für die großen Jobs höchstens Z (ɛ 2 Z) = (1 + ɛ) 1ɛ (ɛ 2 Z) (1 + ɛ)z. 2 Dies ist eine (1 + ɛ)-approximation des optimalen Schedules. Nun untersuchen wir den Einfluss der kleinen Jobs auf den Makespan. Falls die Zuteilung der kleinen Jobs den Makespan nicht erhöhen sollte, so ist der Schedule eine (1 + ɛ)-approximation aufgrund obiger Überlegungen für die großen Jobs. Nehmen wir also nun an, dass die Zuteilung der kleinen Jobs den Makespan erhöht. Sei L der Makespan nach der Platzierung der kleinen Jobs und sei i derjenige kleine Job, dessen Platzierung den Makespan auf L erhöht hat. Dann haben aufgrund der LL-Heuristik alle Maschinen nach der Platzierung der kleinen Jobs mindestens Last L p i. Der optimale Makespan ist somit mindestens L p i, d.h. es gilt Z L p i. Folglich gilt L Z + p i (1 + ɛ)z. Jetzt erläutern wir, wie wir die großen Jobs in Schritt 2b) platzieren. Zur Vereinfachung der Notation nehmen wir an, dass wir n große Jobs haben. In Schritt 2b) müssen wir die folgende Variante des sogenannten Bin-Packing-Problems lösen. 18

Problem 3.6 (Bin Packing mit eingeschränkten Gewichten) Gegeben sei eine Menge von Objekten [n] = {1,..., n} mit Gewichten w 1,..., w n [k] = {1,..., k}, k 1, sowie zwei natürliche Zahlen m 1 und b k. Gesucht ist eine Verteilung der Objekte auf m Kisten (Bins), die jeweils ein Gewicht von höchstens b tragen können. Die Objekte des Bin-Packing-Problems repräsentieren dabei die großen Jobs des Schedulingproblems. Die Gewichte entsprechen den Jobgrößen p 1,...,p n, und die Gewichtsschranke b entspricht der oberen Schranke für den Makespan Z. Eine geeignete Abschätzung für k werden wir später bestimmen. Die Lösung für das Bin-Packing-Problem spezifiziert eine Einteilung in m Teilmengen mit Gewicht höchstens b aus der sich dann ein Schedule für die großen Jobs bezüglich der Jobgrößen p 1,...,p n mit Makespan höchstens Z ergibt. Lemma 3.7 Das Bin-Packing-Problem mit eingeschränkten Gewichten kann in Zeit O((n + 1) k (b + 1) k /k!) gelöst werden. Beweis: Sei f(n 1, n 2,...,n k ) die minimale Anzahl von Kisten mit Gewichtsschranke b, in die wir eine Menge von Objekten bestehend aus n i vielen Objekten mit Gewicht i [k] packen können. Wir zeigen wie man die Funktion f durch dynamische Programmierung in einer Tabelle berechnen kann. Diese Tabelle wird dann so ergänzt, dass man nicht nur den Wert der Funktion f, sondern auch die zugehörige Bepackung ablesen kann. Die Funktion f erfüllt 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 ), wobei Q = {(q 1,...,q k ) f(q 1, q 2,...,q k ) = 1}, d.h. Q beschreibt alle Gewichtskombinationen, die in eine Kiste passen. Wir berechnen die Lösung dieser Gleichung für alle k-tupel aus {0,..., n} k in einer k-dimensionalen Tabelle der Größe (n + 1) k. Falls f(n 1, n 2,...,n k ) den Wert mindestens m hat, so existiert eine zulässige Platzierung der Objekte in die m Kisten, und diese Platzierung kann aus der Tabelle extrahiert werden, indem man für jeden Tabelleneintrag a einen Zeiger auf denjenigen Eintrag b angibt aus dem a durch hinzufügen eines weiteren Objektes hervorgegangen ist. Laufzeitanalyse: Es müssen (n + 1) k Tabelleneinträge berechnet werden. Die Berechnung eines Tabelleneintrages kostet Zeit O( Q ). Beachte, (q 1,...,q k ) Q impliziert q i {0,..., b/i } für jedes i [k], da nicht mehr als b/i Objekte der 19

Größe i in dieselbe Kiste passen. Es folgt Q (b + 1) k /k!. Damit ist die Laufzeit O((n + 1) k (b + 1) k /k!). Was sind die Werte von b und k bezogen auf unser Schedulingproblem? Die maximale Größe eines Jobs vor der Skalierung ist durch Z beschränkt, weil es ja einen Schedule mit Makespan Z gibt. Nach der Skalierung und Rundung ist die maximale Größe also höchstens Z/(ɛ 2 Z) = 1 ɛ 2. Also können wir k = 1 ɛ 2 = O(1) und b = Z = (1 + ɛ) 1ɛ 2 = O(1) setzen. Damit ist die Laufzeit von Schritt 2 beschränkt durch O ( (n + 1) k (b + 1) k /k! ) ( ) = O n 1/ɛ2. Zum Schluss müssen wir noch erklären, wie das Orakel in Schritt 1, das den Wert Z liefert, realisiert werden kann. Zunächst einmal beobachten wir, dass Z nicht unbedingt dem optimalen Makespan opt entsprechen muss, sondern lediglich die folgenden beiden Bedingungen erfüllen sollte: i) Einerseits muss Z so gewählt sein, dass das Bin-Packing-Problem in Schritt 2b eine zulässige Lösung hat. Diese Bedingung ist für jedes Z opt erfüllt. Es kann aber auch Werte Z < opt geben, die diese Bedingung erfüllen. ii) Andererseits sollte Z nicht größer als opt sein, da nur unter dieser Voraussetzung der Approximationsfaktor 1 + ɛ garantiert werden kann. Der optimale Makespan erfüllt beide Bedingungen, ist aber NP-hart zu berechnen. Wir zeigen jetzt wie man dennoch in polynomieller Zeit mittels Binärsuche einen Wert für Z ermitteln kann, der beide Bedingungen erfüllt. Wir modifizieren dazu unseren auf Seite 17 beschriebenen Algorithmus derart, dass wir für ein beliebiges vorgegebenes Z, die Antwort erhalten ob Bedingung i) erfüllt ist, also ob Schritt 2b erfolgreich durchgeführt werden konnte, oder aber ob Schritt 2b gescheitert ist. Diese Information benutzen wir, um mittels Binärsuche nach einem Wert Z zu suchen, so dass Z Bedingung i) erfüllt, aber Z 1 Bedingung i) nicht erfüllt. Im Wertebereich {1,..., S} mit S = i p i existiert ein derartiges Z. Eine Binärsuche auf diesem Wertebereich, die die Antworten unseres Algorithmus als Wegweiser benutzt, findet somit ein solches Z in O(log S) vielen Aufrufen des Algorithmus. 20

Sei N die Länge der Eingabe in Bits. Dann gilt log S N. Die Anzahl der Aufrufe unseres Algorithmus in der Binärsuche ist somit durch O(N) beschränkt. Jeder Aufruf hat eine Laufzeit von O(n 1/ɛ2 ). Die Laufzeit des Algorithmus ist somit O(Nn 1/ɛ2 ). Für konstantes ɛ > 0 ist die Laufzeit also polynomiell in der Eingabelänge. Es ergibt sich der folgende Satz. Satz 3.8 Es gibt ein PTAS für das Makespan-Scheduling-Problem auf identischen Maschinen. Wegen des dramatischen Einflusses von ɛ auf die Laufzeit kann dieses PTAS nicht als praktisch angesehen werden. Wenn wir beispielsweise mit der LPT-Heuristik konkurrieren wollen, so müssen wir ɛ = 1 setzen und erhalten eine Laufzeitschranke von 3 O(Nn 9 ). Das PTAS ist somit zwar nicht praktikabel, aber dennoch ist der obige Satz signifikant, weil er zeigt, dass es keine untere Schranke für den besten in polynomieller Zeit erreichbaren Approximationsfaktor geben kann. 4 Makespan-Scheduling auf allgemeinen Maschinen Es gibt verschiedene Varianten des Makespan-Scheduling-Problems. Scheduling auf identischen Maschinen (identical machines): Job i [n] hat Laufzeit p i auf jeder Maschine. Scheduling auf Maschinen mit Geschwindigkeiten s 1,...,s m (uniformly related machines): Job i [n] hat Laufzeit p i s j auf Maschine j [m]. Scheduling auf allgemeinen Maschinen (unrelated machines): Die Eingabe besteht aus einer Matrix (p ij ) i [n],j [m]. Dabei bezeichnet p ij die Laufzeit von Job i [n] auf Maschine j [m]. Die ersten beiden Probleme haben ein PTAS. Das Approximationsschema für das erste Problem haben wir vorgestellt. Das Schema für das zweite Problem ist ähnlich. Für das dritte Problem, Makespan-Scheduling auf allgemeinen Maschinen, ist kein PTAS bekannt. Der beste bekannte Algorithmus hat den Approximationsfaktor 2. Diesen Algorithmus von Lenstra, Shmoys und Tardos (1990) werden wir uns im Folgenden näher anschauen. 21

Wir verwenden Indika- ILP-Formulierung des allgemeinen Schedulingproblems. torvariablen x ij {0, 1}, i [n], j [m] sowie eine Variable t, die dem Makespan entspricht. Die Zielfunktion lautet minimiere t Die Nebenbedingungen sind i [n] : x ij 1 j [m] : j [m] x ij p ij t i [n] i [n], j [m] x ij {0, 1} Wir können dieses ILP relaxieren, indem wir die Ganzzahligkeit aufgeben. Das so erhaltene LP kann in polynomiell beschränkter Zeit gelöst werden. Anschließend könnte man versuchen aus der LP-Lösung eine ganzzahlige Lösung abzuleiten, die annähernd denselben Makespan liefert. Das folgende Beispiel zeigt jedoch, dass diese Idee so nicht aufgehen kann. Beispiel. Wir nehmen an, es gibt nur einen Job und dieser Job hat Laufzeit 1 auf jeder Maschine. Dann hat die optimale ILP-Lösung den Wert 1. Die optimale Lösung des durch Relaxierung entstandenen LPs hingegen hat den Wert 1. Damit ist der Faktor m zwischen ILP- und LP-Optimum, das sogenannte Integrality-Gap, gleich m. Ein derartig großes Integrality-Gap bedeutet, dass man aus der Lösung für das LP wohl keine gute Lösung für das ILP ableiten kann. Um ein kleines Integrality-Gap zu erzwingen, entwickeln wir eine alternative ILP-Formulierung. Wir nehmen an, ein Orakel verrät uns den optimalen Makespan T. Das Orakel können wir, wie schon im Fall der identischen Maschinen gesehen, durch eine Binärsuche in polynomiell beschränkter Laufzeit simulieren. Wenn der Makespan bekannt ist, haben wir die folgende Zusatzinformation, die wir in unser ILP einfliessen lassen: Ein Job i kann nur dann auf einer Maschine j platziert werden, falls gilt p ij < T, denn sonst würde die Laufzeit dieses einzelnen Jobs bereits den vorgegebenen Makespan überschreiten. 22

Alternative ILP-Formulierung. ILP(T ) folgendermaßen. Definiere Wir definieren das gannzzahlige lineare Programm S T = {(i, j) [n] [m] p ij T }. ILP(T ) hat die Variablen x ij nur für Paare (i, j) S T. Eine Zuteilung von Job i auf Maschine j für (i, j) S T ist damit, wie erwünscht, nicht möglich. Der Lösungsraum von ILP(T ) wird beschrieben durch die Nebenbedingungen: i [n] : x ij 1 j:(i,j) S T j [m] : x ij p ij T i:(i,j) S T (i, j) S T x ij 0 Wir spezifizieren keine Zielfunktion. Es ist ausreichend eine beliebige zulässige Lösung zu berechnen, weil jede zulässige Lösung den Makespan (höchstens) T hat. Überblick über den Algorithmus. Wir beschreiben jetzt einen Algorithmus der zunächst eine nicht-ganzzahlige Lösung für ILP(T ) berechnet und dann daraus eine ganzzahlige Lösung ableitet, die höchstens den Makespan 2T hat. Der Algorithmus verwendet die folgenden zwei Schritte. Relaxierungsschritt: Wir lassen die Ganzzahligkeitsbedingung fallen und erhalten aus ILP(T ) das lineare Programm LP(T ). Wir berechnen eine zulässige Basislösung für LP(T ). Rundungsschritt: Aus der Basislösung für LP(T ) konstruieren wir durch geeignete Auf- oder Abrundung der nicht-ganzzahligen Variablen eine zulässige ganzzahlige Lösung mit Approximationsfaktor 2. Der Relaxierungsschritt kann mit der Ellipsoidmethode in polynomiell beschränkter Laufzeit durchgeführt werden. Im Folgenden beschreiben wir den Rundungsschritt genauer. In die Analyse dieses Schrittes gehen Eigenschaften von Basislösungen ein. Lemma 4.1 In einer Basislösung für LP(T ) haben höchstens n + m der Variablen einen positiven Wert (d.h. nicht den Wert 0). Beweis: 23

Die Anzahl der Variablen in LP(T ) bezeichnen wir mit D und die Anzahl der Nebenbedingungen mit C. Es gilt D = S T nm und C = D + n + m. In einer Basislösung sind mindestens D der Nebenbedingungen exakt (also mit Gleichheit) erfüllt, d.h. es gibt höchstens C D = n+m viele Nebenbedingungen, die nicht exakt erfüllt sind. Somit sind auch höchstens n + m der Nichtnegativitätsbedingungen (also der Bedingungen x ij 0) nicht exakt erfüllt. Es folgt, dass höchstens n + m Variablen nicht den Wert 0 haben. Der Allokationsgraph. Zu einer Basislösung x von LP(T ) definieren den Allokationsgraphen G = ([n] [m], E). G ist ein bipartiter Graph, dessen Knoten den Jobs und Maschinen entsprechen. Job i [n] ist mit Maschine j [m] genau dann durch eine Kante verbunden, wenn x ij > 0. Ein Pseudobaum mit Knotenmenge V ist ein zusammenhängender Graph mit höchstens V Kanten. Jeder Spannbaum enthält V 1 Kanten. Ein Pseudobaum ist also entweder ein Spannbaum oder ein Spannbaum mit Zusatzkante, d.h. ein Graph, der höchstens einen Kreis enthält. Ein Graph ist ein Pseudowald, wenn jede Zusammenhangskomponente jeweils einem Pseudobaum entspricht. Lemma 4.2 Falls G zusammenhängend ist, so ist G ein Pseudobaum. Beweis: G ist ein zusammenhängender Graph mit n + m Knoten. Aus Lemma 4.1 folgt, G hat höchstens n + m Kanten. Damit ist G ein Pseudobaum. Lemma 4.3 Der Allokationsgraph G ist ein Pseudowald. Beweis: Betrachte eine beliebige Zusammenhangskomponente G = (V, E ). Die Knotenmenge V besteht aus Teilmengen der Jobs und Maschinen, d.h. V = J M mit J [n] und M [m]. Wir müssen zeigen, dass G ein Pseudobaum ist. Das Tupel (J, M ) definiert ein eingeschränktes Schedulingproblem, bei dem die Jobs aus J auf die Maschinen in M verteilt werden sollen. Sei LP (T ) die Relaxierung 24

zum Schedulingproblem (J, M ) mit vorgegebenem Makespan T. Wenn wir die Basislösung x für LP(T ) auf die Variablen x ij mit i J und j M einschränken, dann erhalten wir eine Basislösung x für LP (T ). Damit ist G also ein zusammenhängender Allokationsgraph zur Basislösung x von LP (T ). Jetzt folgt aus Lemma 4.2, dass G ein Pseudobaum ist. Da diese Eigenschaft für jede Zusammenhangskomponente von G gilt, ist G somit ein Pseudowald. LP-Rundung mit Hilfe des Allokationsgraphen: Als Nächstes zeigen wir, wie man aus dem Allokationsgraphen G eine ganzzahlige Lösung für ILP(T ) mit Makespan höchstens 2T erzeugt. Ungeteilte Jobs: Falls die Basislösung x für einen Job i [n] eine ganzahlige Zuteilung berechnet hat, d.h. es gibt eine Maschine j [n] mit x ij = 1, so wird diese Zuteilung direkt übernommen. Wir entfernen die entsprechenden Jobknoten und die inzidente Kante aus dem Graphen G und erhalten dadurch einen Allokationsgraphen, den wir H nennen. Geteilte Jobs: Wir berechnen ein einseitig perfektes Matching M für H, d.h eine Teilmenge der Kanten, so dass jeder Jobknoten zu genau einer Kante in M inzident ist und jeder Maschinenknoten zu höchstens einer Kante. M ordnet jedem geteilten Job i also genau eine Maschine j zu, und wir setzen x ij = 1 und x ij = 0 für j j. Beachte, jede Maschine erhält bei diesem Rundungsschritt höchstens einen zusätzlichen Job. Abbildung 3 erläutert die Konstruktion des Matchings M anhand eines Beispiels. Wir müssen noch die Existenz des einseitig perfekten Matchings M auf H nachweisen und zeigen, wie dieses Matching effizient berechnet werden kann. Wir beobachten, dass der Graph H ein bipartiter Pseudowald ist, in dem alle Blätter Maschinenknoten sind, weil alle Jobknoten mit Grad 1 durch Streichung der ungeteilten Jobs entfernt wurden. Diese Eigenschaft werden wir ausnutzen. Lemma 4.4 Der Allokationsgraph H hat ein einseitig perfektes Matching, und dieses Matching kann in polynomiell beschränkter Laufzeit berechnet werden. Beweis: Wir beschreiben einen einfachen Algorithmus, der das Matching berechnet. Wir nutzen aus, dass alle Blätter im Pseudowald H Maschinenknoten sind. Zunächst entfernen wir alle isolierten Maschinenknoten, d.h. alle Zusammenhangskomponenten, die nur aus einem Maschinenknoten bestehen. Den folgenden Schritt wenden wir solange an, bis kein Blatt mehr verfügbar ist. 25

Abbildung 3: Darstellung des einseitig perfekten Matchings M (= rote, gestrichelte Kanten) für den Allokationsgraph H. Jeder Jobknoten (rot, viereckig) wird genau einem Maschinenknoten (blau, rund) zugeordnet. Jedem Maschinenknoten wird höchstens ein Jobknoten zugeordnet. Wähle ein beliebiges Blatt j [m], und füge die inzidente Kante {j, i} (i [n]) zu M hinzu. Dann entferne die Knoten j und i mit allen inzidenten Kanten aus H und lösche die dadurch möglicherweise neu entstandenen isolierten Maschinenknoten. Da der Graph H ein bipartiter Pseudowald ist, verbleiben nach dem iterierten Entfernen aller Blätter nur ein paar Kreise gerader Länge. Von diesen Kreisen nehmen wir jede zweite Kante zum Matching M hinzu. Auf diese Art wird jeder Jobknoten durch genau eine Kante aus M abgedeckt, und wir haben ein einseitig perfektes Matching konstruiert. Satz 4.5 Das Makespan-Scheduling-Problem für allgemeine Maschinen hat einen Polynomialzeitalgorithmus mit Approximationsfaktor 2. Beweis: Wir müssen nur noch den Approximationsfaktor nachweisen. Auf jeder Maschine verursachen die durch die Basislösung ungeteilt zugewiesenen Jobs eine Last von höchstens T. Beim Runden der geteilten Jobs wird jeder Maschine maximal ein Job zugeordnet, weil wir ein Matching verwenden. Eine Matchingkante {i, j} existiert nur dann, wenn in der Basislösung x ij > 0 gilt. Notwendige Bedingung dafür ist, dass (i, j) S T ist. Aus (i, j) S T folgt p ij T. Deshalb erzeugt die Zuteilung entlang der Matchingkanten einen Lastzuwachs von höchstens T je Maschine. 26

Somit ist der berechnete Makespan höchstens zweimal so groß wie der optimale Makespan T. 27