Skript: Exakte Exponentialzeit

Algorithmik für schwere Probleme
Departement Informatik
Prof. Dr. Juraj Hromkovič
Dr. Hans-Joachim Böckenhauer
Dr. Richard Královič
http://www.ita.inf.ethz.ch/alscpr17
Skript: Exakte Exponentialzeit-Algorithmen
Zürich, 2. Mai 2017
Motivation. Wenn eine exakte Lösung benötigt wird und kein parametrisierter Algorithmus bekannt ist (oder der Parameter in der Eingabe gross ist), versuche einen Algorithmus
zu finden, der zwar exponentielle Laufzeit hat, aber schneller ist als die vollständige Suche.
n
Beispiel 1. Ein Algorithmus mit Laufzeit 2 2 ≈ 1.41n kann doppelt so grosse Eingaben
bewältigen wie ein Algorithmus mit Laufzeit 2n .
Ziel. Einige Entwurfsmethoden für „schnelle“ Exponentialzeit-Algorithmen kennenlernen.
Definition 1 (O ∗ -Notation). Seien f, g : N → R+ . Dann gilt f (n) ∈ O∗ g(n) , falls
ein Polynom p : N → R+ existiert, so dass f (n) ∈ O g(n) · p(n) ist.
Anschaulich: Ignoriere polynomielle Faktoren in der asymptotischen Abschätzung. Dies ist
bei exponentiellen Funktionen sinnvoll, weil
αn · p(n) ∈ O (α + ε)n
für jedes α ≥ 1 und jedes ε > 0 gilt.
Die Basis der Exponentialfunktion wird in unseren Abschätzungen ohnehin meist eine
gerundete reelle Zahl sein.
1. Methode: Branching-Algorithmen
Idee. Reduziere ein Problem der Grösse n auf mehrere kleinere Teilprobleme.
Bemerkung. Dies ist auch eine generelle Entwurfsmethode für polynomielle Algorithmen.
Mergesort reduziert zum Beispiel ein Problem der Grösse n auf zwei Teilprobleme der
Grösse n2 .
Hier ist eine typische Reduktion aber eher von n auf n − d für eine kleine Konstante d.
1
Beispiel 2 (Branching-Algorithmus für Max-IS).
Definition 2. Das Maximum-Independent-Set-Problem (Max-IS) ist das Optimierungsproblem, in einem gegebenen ungerichteten Graphen G = (V, E) eine unabhängige Menge
X ⊆ V maximaler Grösse zu finden (d. h. {u, v} ∈
/ E für alle u, v ∈ X).
Beobachtung. Trivialer Algorithmus, der in Zeit O∗ (2n ) läuft: Alle Teilmengen von V
ausprobieren.
Definition 3. Sei G = (V, E) ein Graph, v ∈ V . Die abgeschlossene Nachbarschaft von v
in G ist definiert als
n
o
N [v] = x ∈ V | {x, v} ∈ E ∪ {v} .
Beobachtung. Sei G = (V, E) ein Graph, X ein (inklusions-)maximales IS in G (d. h.
ein IS in G, zu dem kein Knoten mehr hinzugefügt werden kann). Dann gibt es für jeden
Knoten v ∈ V in N [v] einen Knoten y, so dass X ∩ N [y] = {y}.
Beweis. Wir machen eine einfache Fallunterscheidung.
• Falls v ∈ X ist, dann kann keiner der Nachbarn y von v in X sein nach der Definition
des IS. Damit folgt die Behauptung für y = v.
/ X ist, dann muss ein Nachbar y von v in X sein, sonst wäre X nicht
• Falls v ∈
maximal (X ∪ {v} wäre dann auch im IS). Nach Definition des IS ist dann keiner
der Nachbarn von y in X.
=⇒ Diese Beobachtung liefert uns einen rekursiven Algorithmus, um die Kardinalität
des maximalen IS zu berechnen:
Algorithmus Branch-IS(G)
Eingabe: Ungerichteter Graph G = (V, E).
• if V = ∅, then return 0.
• Wähle einen Knoten v mit minimalem Grad in G.
n
o
• return 1 + max Branch-IS(G − N [y]) | y ∈ N [v] .
Theorem
1. Der Algorithmus Branch-IS löst das Max-IS auf Graphen mit n Knoten in
n
∗
Zeit O 3 3 ⊆ O∗ (1.4423n ).
Beweis. Wir beweisen die Korrektheit und Laufzeitschranke einzeln.
1. Korrektheit: Folgt sofort aus der Beobachtung oben, da ein maximales IS maximaler
Grösse ein Maximum-IS ist.
2
2. Laufzeit: Sei G der Graph (in irgendeinem der Teilprobleme), v der ausgewählte Knoten
mit minimalem Grad. Seien v1 , . . . , vk die Nachbarn von v in G mit k = deg(v). Sei
|V (G)| = n.
Das Auswählen eines Knotens v mit minimalem Grad ist offensichtlich in polynomieller Zeit durchführbar. Durch das rekursive Aufrufen von Branch-IS entsteht ein
Verzweigungsbaum T , dessen Grösse (Anzahl der Knoten) wir mit T (n) bezeichnen.
=⇒ Die Gesamtlaufzeit ist in O(n2 ) · T (n).
Nun schätzen wir T (n) ab durch
deg(v)
X
T (n) ≤ 1 + T (n − deg(v) − 1) +
T (n − deg(vi ) − 1)
i=1
≤ 1 + (deg(v) + 1) · T (n − deg(v) − 1) .
Die zweite Ungleichung gilt, weil deg(v) ≤ deg(vi ) und offenbar T (l) ≤ T (l + 1) ist.
Weiter gilt T (0) = 1.
Dies gibt uns aber noch nicht unmittelbar eine Rekurrenzgleichung für die Gesamtlaufzeit des Algorithmus, weil der Knotengrad des ausgewählten Knotens in jedem
rekursiven Aufruf des Algorithmus unterschiedlich sein kann. Deshalb schätzen wir
zunächst deg(v) ab durch den schlechtestmöglichen Knotengrad, der auftreten kann:
Sei D ⊆ N die Menge aller minimalen Knotengrade, die in irgendeiner der Teilinstanzen vorkommen. Sei s∗ mit s∗ − 1 ∈ D derjenige Wert für t, der die Funktion
t · T (n − t) + 1 maximiert. Damit ergibt sich dann die Rekurrenzgleichung
T (n) ≤ 1 + s∗ · T (n − s∗ ) .
Weil die Funktion T aber auch von der Knotenanzahl n des Graphen abhängt,
und diese Knotenanzahl auch in jedem rekursiven Aufruf kleiner wird, müssen wir
zusätzlich noch zeigen, dass der schlechtestmögliche Wert s∗ nicht von n abhängt.
Dafür zeigen wir folgende Aussage.
Sei s∗ mit s∗ − 1 ∈ D derjenige Wert für t, der die Funktion t · T (n − t) + 1
maximiert. Dann maximiert s∗ auch die Funktion ts∗ T (n − s∗ − t) + s∗ + 1
(die sich durch einmaliges rekursives Einsetzen von T in sich selbst ergibt).
Um diese Hilfsaussage zu zeigen, nehmen wir an, dass T (n) = an für ein a mit
1 ≤ a ≤ 2. Damit gilt dann
⇐⇒
⇐⇒
⇐⇒
⇐⇒
⇐⇒
ts∗ T (n − s∗ − t) + s∗ + 1 ≤ (s∗ )2 T (n − 2s∗ ) + s∗ + 1
ts∗ T (n − s∗ − t) ≤ (s∗ )2 T (n − 2s∗ )
ts∗ an−s
∗ −t
≤ (s∗ )2 an−2s
∗
∗
tan−t ≤ s∗ an−s
tT (n − t) ≤ s∗ T (n − s∗ )
tT (n − t) + 1 ≤ s∗ T (n − s∗ ) + 1
3
Damit können wir in der Rekurrenz also überall die auftretenden Knotengrade
abschätzen durch denselben schlechtestmöglichen Wert und erhalten die Rekurrenz
T (n) ≤ 1 + s · T (n − s)
≤ 1 + s · (1 + s · T (n − 2s))
= 1 + s + s2 · T (n − 2s)
≤ 1 + s + s2 · (1 + s · T (n − 3s))
= 1 + s + s2 + s3 · T (n − 3s)
≤ ...
n
≤ 1 + s + s2 + . . . + s s
n
n
1 − s s +1
=
∈ O∗ (s s )
1−s
1
Die Funktion f (s) = s s erreicht bei s > 0 ihr Maximum für s = e und für ganzzahlige
Werte bei s = 3.
n
=⇒ T (n) ∈ O∗ (3 3 ) ⊆ O∗ (1.4423n ).
=⇒ Die Gesamtlaufzeit ist in O∗ (1.4423n ).
Beispiel 3 (Branching-Algorithmus für 3Sat).
Definition 4. Sei Φ eine Formel in 3-KNF über der Variablenmenge X. Seien x ∈ X und
α ∈ {0, 1}. Φ[x = α] ist die Formel in 3-KNF, die aus Φ entsteht, wenn man den Wert
x = α in Φ einsetzt und die Formel vereinfacht.
Beobachtung. Φ[x = α] lässt sich aus Φ in linearer Zeit berechnen: Falls α = 1 ist,
streiche alle Klauseln aus Φ, die x enthalten und streiche alle Vorkommen von x (hierdurch
können leere Klauseln entstehen).
Falls α = 0, verfahre umgekehrt.
Beobachtung. Φ[x = α] ist genau dann erfüllbar, wenn es eine Belegung β für X gibt,
die Φ erfüllt und die partielle Belegung α erweitert (d. h. β(x) = α).
Trivialer Branching-Algorithmus für 3Sat. Führe die Berechnung für die Eingabe Φ
zurück auf Φ[x = 0] und Φ[x = 1] für eine Variable x.
=⇒ Laufzeit auf einer Formel mit n Variablen:
T (n) = 2 · T (n − 1) + O(n) =⇒ T (n) = O∗ (2n ) .
Ziel. Verbesserung des Branchings.
4
Algorithmus Branch-3SAT(Φ) (Monien und Speckenmeyer)
Eingabe: Formel Φ in 3-KNF über der Variablenmenge X = {x1 , . . . , xn }.
• Sei L := X ∪ {x | x ∈ X} die Menge aller Literale in Φ.
• if Φ = ∅, then return JA.
• Sei F eine Klausel in Φ minimaler Länge.
• if F = ∅, then return NEIN.
• if F = (l) für ein l ∈ L, then
Rufe Branch-3SAT(Φ[l = 1]) auf und übernimm das Ergebnis.
• if F = (x ∨ y) für x, y ∈ L, then
Rufe Branch-3SAT(Φ[x = 1]) und Branch-3SAT(Φ[x = 0, y = 1]) auf und gib JA
aus, falls einer der Aufrufe JA liefert, NEIN sonst.
• if F = (x ∨ y ∨ z) für x, y, z ∈ L, then
Rufe Branch-3SAT(Φ[x = 1]), Branch-3SAT(Φ[x = 0, y = 1]) und Branch3SAT(Φ[x = 0, y = 0, z = 1]) auf und gib JA aus, falls einer der Aufrufe JA
liefert, NEIN sonst.
Theorem 2. Der Algorithmus Branch-3SAT löst 3Sat in Zeit O∗ (1.84n ).
Beweis. Wir beweisen die Korrektheit und Laufzeitschranke wieder einzeln.
1. Korrektheit: Betrachte die Klausel F = (x ∨ y ∨ z) der Länge 3 mit x, y, z ∈ L. Um
Φ zu erfüllen, muss auch F erfüllt werden, also muss mindestens eines der Literale
x, y, z auf 1 gesetzt werden. Dies ist genau dann der Fall, wenn einer der drei Fälle
• x = 1,
• x = 0 und y = 1,
• x = y = 0 und z = 1
eintritt. Die Argumentation für kürzere Klauseln ist analog.
2. Laufzeit: Die Entscheidung für eine Formel mit n Variablen wird zurückgeführt auf
(maximal) drei Teilprobleme mit n − 1, n − 2 und n − 3 Variablen. Um die Laufzeit
abzuschätzen, reicht es wieder aus, die Anzahl der Knoten im Verzweigungsbaum
abzuschätzen, da für jeden Knoten nur polynomieller Aufwand nötig ist (hier: linearer
Aufwand für die Berechnung von Φ[l = α] aus Φ).
Die Anzahl der Knoten im Verzweigungsbaum (Anzahl der betrachteten Formeln)
ist beschrieben durch
T (n) = T (n − 1) + T (n − 2) + T (n − 3) ,
T (0) = 1 .
5
Diese Rekurrenz lässt sich wie folgt lösen: Wir nehmen an, dass T (n) = an gilt für
1 ≤ a ≤ 2.
=⇒ T (n) ist die Lösung der Gleichung an = an−1 + an−2 + an−3 . Das ist äquivalent
zu: a3 = a2 + a + 1. Die einzige Lösung dieser kubischen Gleichung im Intervall [1, 2]
ist a = 1.839 . . ..
=⇒ T (n) ∈ O∗ (1.84n )
=⇒ Die Gesamtlaufzeit ist in O∗ (1.84n ).
2. Methode: Dynamische Programmierung
Beispiel 4 (TSP). O∗ (2n )-Algorithmus für TSP → siehe Übung.
Bemerkung. Dieser Algorithmus wurde vor ca. 50 Jahren entworfen und ist bis heute
der beste bekannte exakte Algorithmus für TSP.
Beispiel 5 (Graphfärbung).
Definition 5. Sei G = (V, E) ein ungerichteter Graph, k ∈ N. Eine k-Färbung von G ist
eine Abbildung c : V → {1, . . . , k}, so dass
{x, y} ∈ E =⇒ c(x) 6= c(y) .
Die chromatische Zahl χ(G) von G ist das kleinste k, so dass G eine k-Färbung besitzt.
Definition 6. Das Graphfärbungsproblem (Coloring) ist das folgende Berechnungsproblem: Gegeben ein Graph G, berechne χ(G).
Theorem 3 (Hier ohne Beweis). Coloring ist NP-schwer.
Trivialer Algorithmus für Coloring. Probiere jede Farbe für jeden Knoten aus. Da
die chromatische Zahl allgemein nur durch n = |V | beschränkt werden kann, ergibt sich
für einen Graphen mit n Knoten eine Laufzeit von O∗ (nn ).
Definition 7. Sei G = (V, E) ein ungerichteter Graph, sei c : V → {1, . . . , k} eine kFärbung von G. Wir nennen die Menge Ci := {x ∈ V | c(x) = i} die i-te Farbklasse
von c.
Beobachtung. Jede Farbklasse von c ist ein IS in G.
Beobachtung. Sei G ein ungerichteter Graph, c eine k-Färbung von G, Ci eine Farbklasse
von c. Falls Ci kein (inklusions-)maximales IS ist, gibt es einen Knoten x ∈ V − Ci , der
mit der Farbe i gefärbt werden kann, so dass das Resultat eine gültige k-Färbung ist.
6
Algorithmus DP-COL
Eingabe: Ungerichteter Graph G = (V, E).
col(∅) := 0
for i := 1 to |V | do
for all X ⊆ V mit |X| = i do
col(X) := 1 + min{col(X − I) | I ist ein maximales IS in G[X]}
(G[X] ist der von X induzierte Teilgraph von G.)
Ausgabe: χ(G) := col(V )
Theorem 4. DP-COL löst Coloring auf Graphen mit n Knoten in Zeit O∗ (2.45n ).
Beweis. Wir beweisen die Korrektheit und Laufzeitschranke wieder einzeln.
1. Korrektheit: Weil jede Farbklasse einer optimalen Färbung ein IS ist, kann man die
optimale Färbungszahl finden durch Ausprobieren aller IS und Reduktion auf den
Restgraphen. Wegen der Beobachtung oben reicht es aus, das Ausprobieren auf
maximale IS zu beschränken.
2. Laufzeit: Der Algorithmus iteriert für alle Teilmengen X von V über alle maximalen IS
i
von X. Die maximalen IS lassen sich für |X| = i in Zeit O∗ (3 3 ) aufzählen (einfache
Erweiterung des Max-IS-Algorithmus oben).
=⇒ Die Gesamtlaufzeit ist in O∗
n
X
i=1
!
i
n
· 33
i
!
Wegen
n
X
i=1
√
i
n
3
· 3 3 = (1 + 3)n < 2.45n
i
!
(die erste Gleichung folgt aus dem binomischen Satz) folgt die Behauptung.
Beispiel 6 (Anzahl perfekter Matchings bestimmen).
Ziel. „Schneller“ Exponentialzeit-Algorithmus, der in einem gegebenen Graphen zählt,
wie viele perfekte Matchings existieren.
Definition 8. Sei G = (V, E) ein ungerichteter Graph mit n = |V | gerade. Ein perfektes
Matching in G ist eine Menge M ⊆ E von n2 paarweise disjunkten Kanten.
Beobachtung. Nicht jeder Graph hat ein perfektes Matching (z. B. Stern).
Beobachtung. Ein Graph kann mehrere perfekte Matchings besitzen (z. B. gerader Kreis).
7
Entscheidungsproblem. Existiert in G ein perfektes Matching?
=⇒ In Polynomzeit lösbar, aber kompliziert.
Zählproblem. Wie viele verschiedene perfekte Matchings hat G?
=⇒ Schweres Problem.
Ziel. Algorithmus, der dynamische Programmierung verwendet mit Laufzeit O∗ (1.681n ).
Trivialer Algorithmus. Alle Kantenteilmengen der Grösse
n
2
ausprobieren.
2
Beobachtung. Führt in dichten Graphen mit O(n2 ) Kanten zu einer Laufzeit von 2O(n ) .
Definition 9. Sei G = (V, E) ein ungerichteter Graph. Sei für alle X ⊆ V , |X| gerade,
die Anzahl perfekter Matchings in G[X] definiert als pm(X).
Offensichtlich gilt pm(X) = 0, falls E(G[X]) = ∅, und pm(V ) ist der gesuchte Wert.
Um pm(V ) zu bestimmen, zählen wir zunächst alle geordneten perfekten Matchings, also
alle geordneten Folgen (e1 , . . . , en/2 ) paarweise disjunkter Kanten. Sei opm(X) die Anzahl
geordneter perfekter Matchings in G[X] für alle X ⊆ V , |X| gerade.
Der Wert opm(X) lässt sich mit dynamischer Programmierung berechnen als
opm(X) =
X
opm(X − e) .
e∈E(G[X])
(Wie oben ist G[X] der von X induzierte Teilgraph von G und für e = {v, w} ∈ E ist
X − e := X − {v, w}.)
Offenbar gilt pm(V ) = opm(V )/( n2 !).
Beobachtung. Es gibt ungefähr 2n−1 Teilmengen gerader Mächtigkeit in G und die Berechnung eines der 2n−1 Werte opm(X) umfasst eine Summe mit höchstens n2 Summanden.
=⇒ Die Gesamtlaufzeit der Berechnung von pm(V ) ist in O(n2 · 2n−1 ) ⊆ O∗ (2n ).
Ziel. Dynamische Programmierung verbessern. Nicht alle Werte opm(X) sind nötig.
Definition 10. Sei G = (V, E) ein ungerichteter Graph mit V = {v1 , . . . , vn } und n = |V |
gerade. Die Ordnung der Knoten aus V induziert eine eindeutige lexikographische Ordnung
auf der Menge aller perfekten Matchings:
• Ordne Knoten einer Kante aufsteigend nach Index.
• Ordne Kanten des Matchings lexikographisch aufsteigend.
Die resultierende Darstellung eines perfekten Matchings heisst lexikographisch geordnetes
perfektes Matching.
Beobachtung. Zu jedem perfekten Matching gibt es ein eindeutiges lexikographisch geordnetes perfektes Matching.
Idee. Verbessere Laufzeit, indem nur lexikographisch geordnete perfekte Matchings gezählt
werden.
8
Beobachtung. Sei G = (V, E) und sei (e1 , . . . , e n2 ) ein lexikographisch geordnetes perfektes Matching in G. Dann gilt
• v1 ∈ e1 ,
• für alle j ∈ {2, . . . , n2 } enthält ej den Knoten mit dem kleinsten Index, der in
e1 , . . . , ej−1 nicht vorkommt.
Idee. Definiere Klassen von relevanten Knotenmengen, die in der dynamischen Programmierung untersucht werden müssen:
Für 1 ≤ j ≤
n
2
sei
• R1 = {e ∈ E | v1 ∈ e},
• Rj = {Y ∪ e | Y ∈ Rj−1 , e ∈ E, Y ∩ e = ∅, min{V − Y } ∈ e},
=⇒ Rj enthält alle Knotenmengen, für die ein lexikographisch geordnetes perfektes
Matching (e1 , . . . , ej ) existiert, sodass ej den Knoten mit dem kleinsten Index enthält, der
in e1 , . . . , ej−1 nicht vorkommt.
Ziel. Berechne die Anzahl lopm(X) = pm(X) lexikographisch geordneter perfekter Matchings für alle relevanten Knotenmengen X mit dynamischer Programmierung.
Algorithmus DP-LOPM
Eingabe: Ungerichteter Graph G = (V, E).
R1 = {e ∈ E | v1 ∈ e}
for all X ∈ R1 , setze lopm(X) = 1
for j = 2 to n2 do
Rj = {Y ∪ e | Y ∈ Rj−1 , e ∈ E, Y ∩ e = ∅, min{V − Y } ∈ e};
for all X ∈ Rj do
lopm(X) :=
X
lopm(Y )
X=Y ∪e
Y ∩e=∅
Y ∈Rj−1
min{V −Y }∈e
Ausgabe: lopm(V ).
Anschaulich: Die Anzahl lexikographisch geordneter perfekter Matchings für X ∈ Rj lässt
sich zurückführen auf die entsprechenden Anzahlen für alle Mengen Y ∈ Rj−1 , die sich
so durch Hinzunahme einer Kante e zu X erweitern lassen, dass e den nächstgrösseren
Knoten (gemäss der Ordnung v1 , . . . , vn ) enthält.
Um die Korrektheit von DP-LOPM abzuschätzen, benötigen wir das folgende Lemma.
9
Lemma 1. Sei Fk die k-te Fibonacci-Zahl (F1 = F2 = 1, Fi = Fi−1 + Fi−2 ). Dann gilt
n
Fn+1 =
n−k
k
2
X
k=1
!
für alle geraden n ≥ 2.
Beweis. Wir bestimmen die Anzahl an aller Wörter über {0, 1} der Länge n ≥ 1, die keine
zwei aufeinanderfolgenden Nullen enthalten. Es gilt
• a1 = 2
(Wörter 0 und 1),
• a2 = 3
(Wörter 01, 10 und 11) und
• an = an−1 + an−2
(alle Wörter, die mit 1 beginnen, danach alle zulässigen
Wörter der Länge n − 1, und alle Wörter, die mit 01 beginnen,
danach alle zulässigen Wörter der Länge n − 2).
=⇒ an = Fn+2 .
Nun bestimmen wir an auf eine alternative Weise, um damit eine Darstellung für Fn+2 zu
gewinnen.
Wenn ein solches Wort der Länge n genau k Nullen enthält, gibt es n − k Einsen und
n − k + 1 Stellen, an denen jeweils höchstens eine Null eingefügt werden kann. Dies sind
n−k+1
k
!
Möglichkeiten, also insgesamt
n
X
k=0
n−k+1
k
!
und somit ist
Fn+2 =
n
X
k=0
n−k+1
k
!
und
Fn+1 =
n−1
X
k=0
!
n−k
.
k
Weil bei mehr als n2 Nullen zwei davon aufeinander folgen müssen, sind alle entsprechenden
Summanden 0, also gilt
bn
c
2
Fn+1 =
X
k=0
!
n−k
.
k
Theorem 5. Der Algorithmus DP-LOPM berechnet die Anzahl aller lexikographisch geordneten perfekten Matchings in Zeit O∗ (1.6181n ).
10
Beweis. Wir beweisen die Korrektheit und Laufzeitschranke wieder einzeln.
1. Korrektheit: Weil die Ordnung eines Matchings eindeutig ist, gilt pm(V ) = lopm(V ).
2. Laufzeit: In der j-ten Iteration sind |Rj | Mengen X zu betrachten und für jede solche
Menge müssen höchstens |E| Kanten e getestet werden.
n
=⇒ Die Gesamtlaufzeit ist in O
∗
|E| ·
2
X
!
|Rj | .
j=1
Nun schätzen wir noch |Rj | ab. Jede Knotenmenge X enthält die Knoten v1 , . . . , vj
und j weitere Knoten aus {vj+1 , . . . , vn }.
!
n−j
=⇒ |Rj | ≤
.
j
Mit Lemma 1 gilt
n
n
2
X
2
X
|Rj | ≤
j=1
j=1
!
n
!
2
X
n−j
n−j
≤
= Fn+1 .
j
j
j=0
Ferner ist |E| ∈ O(n2 ).
=⇒ Die Gesamtlaufzeit ist in O∗ (Fn+1 ).
Nach der Formel von Moivre ist
ϕn+1
= √
∈ O(ϕn ) ,
5
$
Fn+1
wobei ϕ =
√
1+ 5
2
%
≈ 1.6181 das Verhältnis des goldenen Schnittes ist.
3. Methode: Inklusion-Exklusion-Prinzip
Idee. Zähle Objekte (z. B. Graphen), die eine bestimmte Eigenschaft haben.
Beispiel 7. Sei S eine Menge mit N = |S|, seien A, B Eigenschaften von Elementen in
S, jedes Element kann keine, eine oder beide Eigenschaften haben. Sei Z die Anzahl der
Elemente ohne A und ohne B, NA die Anzahl der Elemente mit A, NB die Anzahl der
Elemente mit B und NA∩B die Anzahl der Elemente mit A und B.
Dann gilt Z = N − (NA + NB ) + NA∩B .
11
N
A∩B
A
B
Z
Verallgemeinerung. Inklusion-Exklusion-Prinzip.
Theorem 6. Gegeben sei eine Kollektion von N kombinatorischen Objekten und n Eigenschaften P1 , . . . , Pn , so dass jedes Objekt eine Teilmenge dieser Eigenschaften hat. Für
W ⊆ {1, . . . , n} sei N (W ) die Anzahl Objekte, die die Eigenschaften Pi haben für alle
i ∈ W . Sei Z die Anzahl Objekte, die keine der Eigenschaften P1 , . . . , Pn haben.
Dann gilt
(−1)|W | · N (W ) .
X
Z=N+
W ⊆{1,...,n}
W 6=∅
Beweis-Idee. Es gilt für n = 3:
Z=
N
|{z}
− N ({1}) − N ({2}) − N ({3})
alle Objekte
| {z }
Objekte mit P1
| {z }
Objekte mit P2
| {z }
Objekte mit P3
+ N ({1, 2}) + N ({1, 3}) + N ({2, 3}) − N ({1, 2, 3})
=N−
X
N (W ) +
W ⊆{1,2,3}
|W |=1
=N−
X
X
N (W ) −
W ⊆{1,2,3}
|W |=2
X
N (W )
W ⊆{1,2,3}
|W |=3
(−1)|W | · N (W ) .
W ⊆{1,2,3}
W 6=∅
Die Erweiterung auf beliebige n ist einfach.
Theorem 7 (Umformulierung von Theorem 6). Gegeben sei eine Kollektion von N
Objekten und n Eigenschaften Q1 , . . . , Qn , so dass jedes Objekt eine Teilmenge dieser
Eigenschaften hat. Für W ⊆ {1, . . . , n} sei N (W ) die Anzahl Objekte, die die Eigenschaften
Qi nicht haben für alle i ∈ W . Sei X die Anzahl Objekte, die alle Eigenschaften Q1 , . . . , Qn
haben.
Dann gilt
X=N+
X
(−1)|W | · N (W ) .
W ⊆{1,...,n}
W 6=∅
12
Beweis. Folgt sofort aus Theorem 6 für Eigenschaften Pi , so dass ein Objekt die Eigenschaft
Pi genau dann hat, wenn es Qi nicht hat.
Ziel. Inklusion-Exklusion verwenden, um einen besseren Algorithmus für Coloring zu
entwerfen.
Hierfür: Betrachte das Set-Cover-Problem.
Definition 11. Das Set-Cover-Problem (SetCover) ist das folgende Entscheidungsproblem: Gegeben eine Menge U mit n Elementen, eine Familie S von Teilmengen von U und
S
ein k ∈ N, entscheide, ob es eine Teilmenge C = {C1 , . . . , Ck0 } ⊆ S gibt mit C∈C C = U
und k 0 ≤ k. Eine solche Teilmenge C nennen wir ein k 0 -Set-Cover.
Im Folgenden wollen wir das Inklusion-Exklusion-Prinzip verwenden, um alle k-Set-Cover
einer gegebenen Instanz (U, S, k) abzuschätzen.
Definition 12. Sei (U, S, k) eine Set-Cover-Instanz. Sei ck die Anzahl geordneter k-SetCover mit Wiederholungen (C1 , . . . , Ck ) für (U, S, k), wobei Ci = Cj für i =
6 j erlaubt
ist.
Für W ⊆ U sei S[W ] = {X ∈ S | X ∩ W = ∅}, sei s[W ] = |S[W ]|.
Lemma 2. Die Anzahl geordneter k-Set-Cover mit Wiederholungen für eine Set-CoverInstanz (U, S, k) ist
ck = |S|k +
X
(−1)|W | · s[W ]k .
W ⊆U
W 6=∅
Beweis. Wir verwenden die Umformulierung des Inklusion-Exklusion-Theorems, also Theorem 7. Hierfür definieren wir die Objekte und die Eigenschaften wie folgt: Die Objekte
seien alle k-Tupel (S1 , . . . , Sk ) mit Si ∈ S. Man beachte, dass die Si in einem solchen
Tupel nicht verschieden sein müssen. Also gibt es N = |S|k viele solche Objekte.
S
Für jedes u ∈ U sagen wir, dass (S1 , . . . , Sk ) die Eigenschaft Q(u) hat, falls u ∈ ki=1 Si
gilt.
Jedes Objekt, das alle Eigenschaften Q(u) hat für alle u ∈ U , ist ein geordneter k-Set-Cover
mit Wiederholungen und umgekehrt.
Die Anzahl N (W ) der Objekte, die die Eigenschaft Q(u) nicht haben für alle u ∈ W lässt
sich berechnen als N (W ) = s[W ]k : Jede Menge Si ∈ S in einem solchen Objekt lässt sich
frei wählen aus der Menge S[W ] aller X ∈ S, die W vermeiden.
Damit folgt aus Theorem 7, dass
ck = N +
X
W ⊆U
W 6=∅
(−1)|W | · N (W ) = |S|k +
X
W ⊆U
W 6=∅
(−1)|W | · s[W ]k .
Beobachtung. Eine SetCover-Instanz (U, S, k) besitzt ein Set-Cover der Grösse ≤ k
genau dann, wenn sie ein geordnetes k-Set-Cover mit Wiederholungen besitzt, wenn also
ck > 0 gilt.
13
Theorem 8. Sei (U, S, k) eine SetCover-Instanz mit |U | = n. Die Anzahl geordneter
k-Set-Cover mit Wiederholungen ck lässt sich in Zeit O∗ (2n ) bestimmen.
Beweis. Zeige, dass sich die Werte s[W ] für alle W ⊆ U in Zeit O∗ (2n ) berechnen lassen.
Damit lässt sich dann offenbar auch die Formel aus Lemma 2 in Zeit O∗ (2n ) auswerten.
Sei für alle X ⊆ U die charakteristische Funktion f (X) definiert durch
f (X) =

1,
falls X ∈ S,
sonst.
0,
Dann gilt
X
s[W ] =
f (X) .
X⊆U −W
(Jede Menge X ∈ S, die W vermeidet, trägt 1 zu der Summe bei.)
Wir bestimmen s[W ] jetzt mit Hilfe dynamischer Programmierung. Sei U = {u1 , . . . , un }.
Für i ∈ {0, 1, . . . , n} und W ⊆ U sei gi (W ) die Anzahl von Mengen in S, die W vermeiden
und alle Elemente aus {ui+1 , . . . , un } − W enthalten, d. h.
X
gi (W ) =
f (S) .
{ui+1 ,...,un }−W ⊆S
S⊆U −W
Für i = 0 gilt also
g0 (W ) =
X
X
f (S) =
U −W ⊆S⊆U −W
f (S) = f (U − W ) .
S=U −W
=⇒ Mit einem Durchlauf durch S lassen sich alle Werte g0 (W ) für alle W ⊆ U in Zeit
O(2n ) bestimmen.
Weiterhin können wir aus
gn (W ) =
X
f (S) =
X
f (S) = s[W ]
S⊆U −W
∅⊆S⊆U −W
die Werte s[W ] ablesen.
Es bleibt zu zeigen, wie sich gi (W ) aus den bereits berechneten gi−1 -Werten ableiten lässt.
Wir unterscheiden zwei Fälle.
• Falls ui ∈ W ist, dann gilt {ui , . . . , un } − W = {ui+1 , . . . , un } − W , also ist
gi (W ) =
X
f (S) =
{ui+1 ,...,un }−W ⊆S⊆U −W
X
f (S) = gi−1 (W ) .
{ui ,...,un }−W ⊆S⊆U −W
• Falls ui ∈
/ W , dann zählt gi−1 (W ) alle Mengen von gi (W ), die ui enthalten, und
gi−1 (W ∪ {ui }) zählt alle Mengen aus gi (W ), die ui nicht enthalten. Also gilt:
gi (W ) = gi−1 (W ) + gi−1 (W ∪ {ui }) .
In jedem der beiden Fälle lässt sich gi (W ) mit konstantem Aufwand berechnen, es
ergibt sich also eine Gesamtlaufzeit in O(n · 2n ) ⊆ O∗ (2n ).
14
Anwendung für Coloring
Beobachtung. Sei G = (V, E) ein ungerichteter Graph, sei S ⊆ Pot(V ) die Menge aller
IS von G. Betrachte die SetCover-Instanz (V, S, k). Dann hat (V, S, k) ein k-Set-Cover
genau dann, wenn G k-färbbar ist.
Beweis. Wir zeigen die Äquivalenz durch zwei Implikationen.
=⇒ : Sei {C1 , . . . , Ck } ein k-Set-Cover von (V, S, k). Da jede Teilmenge eines IS wieder
ein IS ist, gibt es dann auch ein k-Set-Cover (C10 , . . . , Ck0 ), so dass die Ci0 paarweise
disjunkt sind. =⇒ c : V → {1, . . . , k}: c(u) = i ⇐⇒ u ∈ Ci0 ist eine k-Färbung
von G.
⇐= : Sei c eine k-Färbung von G. Die Farbklassen von c sind IS von G, also gibt es k IS,
die V überdecken.
Algorithmus IE-COLORING
Eingabe: Graph G = (V, E) mit |V | = n.
1. Schritt: Konstruiere ein Tupel (V, S), wobei S die Menge aller IS von G sei.
2. Schritt: k := 1
while k < n do
Berechne Anzahl geordneter k-Set-Cover mit Wiederholungen ck für (V, S, k)
if ck > 0, then return χ(G) = k, else k := k + 1
Theorem 9. Der Algorithmus IE-COLORING löst Coloring in Zeit O∗ (2n ).
Beweis. Wir beweisen die Korrektheit und Laufzeitschranke wieder einzeln.
1. Korrektheit: Folgt unmittelbar aus den Beobachtungen oben.
2. Laufzeit: Da es maximal 2n IS in G gibt, ist Schritt 1 in Zeit O(2n ) durchführbar,
Schritt 2 läuft nach Theorem 8 in O∗ (n · 2n ) ⊆ O∗ (2n ).
Beobachtung. Der Algorithmus zur Bestimmung der geordneten k-Set-Cover und der
Algorithmus IE-COLORING brauchen exponentiellen Platz zur Berechnung der s[W ].
Ziel. Polynomielle Platzkomplexität für für Bestimmung geordneter k-Set-Cover.
Theorem 10. Sei (U, S, k) eine SetCover-Instanz mit |U | = n, und sei S = {S1 , . . . , Sl }
in polynomiellem Platz und polynomieller Zeit aufzählbar, d. h. es existiert ein Polynom p,
so dass Si+1 aus Si in Zeit und Platz p(n) berechenbar ist.
Dann lässt sich die Anzahl der geordneten k-Set-Cover von (U, S, k) in polynomiellem
Platz und in Zeit 2n · |S| · p(n) berechnen.
Beweis-Idee. Für jede Teilmenge W ⊆ U separat über alle X ∈ S iterieren, um s[W ] zu
berechnen, Wert s[W ] auf laufende Summe aufaddieren.
15
Literaturhinweise
Dieses Kapitel der Vorlesung basiert im Wesentlichen auf folgendem Buch.
Fedor Fomin, Dieter Kratsch: Exact Exponential Algorithms, Springer 2010.
16