2599 lines
118 KiB
TeX
2599 lines
118 KiB
TeX
\documentclass[11pt]{article}
|
|
\input{style_guide.tex}
|
|
|
|
\linespread{1.06}
|
|
\setlength{\parskip}{0.5em}
|
|
|
|
\title{\textbf{\Huge Das vollständige Fundament}\\[0.5em]
|
|
\large Komplexitätstheorie und Approximation, ausführlich erklärt\\
|
|
\normalsize \textit{Analyse von Algorithmen und Komplexität} -- CAU Kiel, SS 2026}
|
|
\author{}
|
|
\date{}
|
|
|
|
\begin{document}
|
|
\maketitle
|
|
\thispagestyle{empty}
|
|
|
|
\begin{center}\itshape\large
|
|
Das gesamte Wissen der Vorlesung -- jedes Problem einzeln,\\
|
|
mit Idee statt Abkürzung, mit Bild wo es hilft.
|
|
\end{center}
|
|
|
|
\vfill
|
|
|
|
\noindent\textbf{Was dieses Heft leistet.}
|
|
Es erklärt den kompletten Stoff des Kurses, ohne etwas zu überspringen. Der Kern
|
|
ist ein \emph{Katalog aller Probleme}. Zu jedem Problem findest du vier Dinge,
|
|
jedes ausführlich:
|
|
\begin{enumerate}
|
|
\item die \textbf{Definition} -- was gefragt ist, mit Beispiel;
|
|
\item \textbf{warum es in $\NP$ liegt} -- die Idee des Zertifikats, Schritt für
|
|
Schritt erklärt;
|
|
\item \textbf{woher seine Schwere kommt} -- die Reduktion, die es schwer macht,
|
|
mit ihrer Konstruktions-Idee;
|
|
\item \textbf{was daraus folgt} -- die Reduktionen, die von ihm ausgehen, jede
|
|
mit eigener Idee.
|
|
\end{enumerate}
|
|
Danach folgen die untere-Schranken-Theorie (ETH) und die Approximation -- auch
|
|
dort steht bei jedem Ergebnis die \emph{Idee} des Beweises.
|
|
|
|
\medskip
|
|
\noindent\textbf{Zwei Versprechen.}
|
|
Erstens: Kein Problem wird mit einem anderen zusammengelegt, auch wenn sie sich
|
|
ähneln -- jedes bekommt seinen eigenen, vollständigen Abschnitt. Zweitens: Nichts
|
|
wird als \glqq trivial\grqq{} oder \glqq analog\grqq{} abgetan; jeder Nachweis
|
|
wird wirklich ausgeführt.
|
|
|
|
\medskip
|
|
\noindent\textbf{Die farbigen Kästen.}
|
|
\begin{center}\small
|
|
\begin{tabular}{ll}
|
|
\ding{72}~Intuition & die Idee in einfachen Worten\\
|
|
\ding{43}~Analogie & ein Bild aus dem Alltag\\
|
|
\ding{110}~Definition & die präzise Fassung\\
|
|
\ding{115}~Satz & ein Ergebnis mit erklärter Beweisidee\\
|
|
\ding{108}~Beispiel & durchgerechnet, mit echten Zahlen\\
|
|
\ding{43}~Idee & die Konstruktion hinter einer Reduktion oder einem Beweis\\
|
|
\ding{73}~Aha & die Pointe\\
|
|
\ding{55}~Stolperstein & der häufige Fehler\\
|
|
\ding{228}~Zusammenhang & wie es ins große Ganze passt\\
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
\vfill
|
|
\newpage
|
|
\tableofcontents
|
|
\newpage
|
|
|
|
% ##################################################################
|
|
\part*{Teil A -- Die Grundlagen}
|
|
\addcontentsline{toc}{section}{\textbf{Teil A -- Die Grundlagen}}
|
|
% ##################################################################
|
|
|
|
% ==================================================================
|
|
\section{Ein Problem, das sich wehrt}
|
|
% ==================================================================
|
|
|
|
Bevor wir die Theorie aufbauen, brauchen wir einen Grund für sie. Diesen Grund
|
|
liefert ein einzelnes Problem, das harmlos aussieht und trotzdem jeden Computer
|
|
überfordert: das Cliquenproblem.
|
|
|
|
Ein \emph{Graph} ist ein Netz aus Punkten (\emph{Knoten}) und Verbindungslinien
|
|
(\emph{Kanten}). Eine \emph{Clique} ist eine Gruppe von Knoten, in der jeder mit
|
|
jedem direkt verbunden ist. Das Cliquenproblem fragt: Gibt es in einem Graphen
|
|
eine Clique aus mindestens $k$ Knoten?
|
|
|
|
\begin{bsp}{Eine Clique erkennen}
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{center}
|
|
\begin{picture}(5,3)(-0.6,-0.5)
|
|
\put(0,1){\circle*{0.15}}\put(-0.5,1){\small $1$}
|
|
\put(1.2,2.4){\circle*{0.15}}\put(1.1,2.6){\small $2$}
|
|
\put(2.4,1){\circle*{0.15}}\put(2.55,1){\small $3$}
|
|
\put(1.6,-0.2){\circle*{0.15}}\put(1.5,-0.55){\small $4$}
|
|
\put(3.6,0.3){\circle*{0.15}}\put(3.75,0.2){\small $5$}
|
|
\qbezier(0,1)(0.6,1.7)(1.2,2.4)
|
|
\put(0,1){\line(1,0){2.4}}
|
|
\qbezier(1.2,2.4)(1.8,1.7)(2.4,1)
|
|
\qbezier(2.4,1)(2.0,0.4)(1.6,-0.2)
|
|
\qbezier(2.4,1)(3.0,0.65)(3.6,0.3)
|
|
\end{picture}
|
|
\end{center}
|
|
Die Gruppe $\{1,2,3\}$ bildet ein Dreieck -- alle drei Kanten sind da, also eine
|
|
Clique der Größe 3. Die Gruppe $\{2,3,4\}$ ist keine, weil zwischen 2 und 4 die
|
|
Kante fehlt.
|
|
\end{bsp}
|
|
|
|
Der naheliegende Algorithmus probiert alle Gruppen aus $k$ Knoten durch. Bei $n$
|
|
Knoten und $k = n/2$ sind das mindestens $2^{n/2}$ Gruppen -- eine Zahl, die sich
|
|
mit jedem zusätzlichen Knoten ungefähr verdoppelt. Schon bei hundert Knoten ist
|
|
das jenseits des Machbaren, und kein schnellerer Rechner holt exponentielles
|
|
Wachstum je ein.
|
|
|
|
\begin{aha}
|
|
Die Komplexitätstheorie fragt nicht \glqq wie löse ich die Clique schnell?\grqq,
|
|
sondern \glqq ist die Clique \emph{überhaupt} schnell lösbar -- oder gehört sie
|
|
zu einer großen Familie von Problemen, die alle gemeinsam schwer sind?\grqq{}
|
|
Genau diese zweite, tiefere Frage beantwortet der ganze Kurs. Wir bauen dafür
|
|
jetzt die Werkzeuge.
|
|
\end{aha}
|
|
|
|
% ==================================================================
|
|
\section{Effizient lösbar: die Klasse P}
|
|
% ==================================================================
|
|
|
|
Wir müssen zuerst \glqq schnell\grqq{} präzise machen. Die Laufzeit eines
|
|
Algorithmus misst man immer \emph{relativ zur Größe seiner Eingabe}, geschrieben
|
|
$n$, und man betrachtet den schlechtesten Fall -- weil man eine Garantie will,
|
|
keine Hoffnung.
|
|
|
|
\begin{defn}{Klasse P}
|
|
$\Pclass$ ist die Menge aller Entscheidungsprobleme, für die ein Algorithmus
|
|
existiert, der sie in \emph{polynomieller} Zeit löst -- also mit Laufzeit
|
|
$O(n^d)$ für eine feste Zahl $d$ (etwa $n$, $n^2$, $n^3$).
|
|
\end{defn}
|
|
|
|
\begin{intuition}
|
|
Man setzt \glqq polynomiell\grqq{} mit \glqq effizient\grqq{} gleich. Das ist
|
|
eine Konvention, aber eine gute: Der entscheidende Bruch verläuft zwischen
|
|
polynomiell und exponentiell. Eine polynomielle Laufzeit wächst zahm, eine
|
|
exponentielle explodiert. Und die Grenze bleibt dieselbe, egal welchen
|
|
realistischen Rechnertyp man zugrunde legt.
|
|
\end{intuition}
|
|
|
|
Ein \emph{Entscheidungsproblem} ist eine Frage mit Antwort Ja oder Nein. Statt
|
|
\glqq wie groß ist die größte Clique?\grqq{} fragt man \glqq gibt es eine Clique
|
|
mit $\ge k$ Knoten?\grqq. Formal identifiziert man ein Problem mit der Menge
|
|
seiner Ja-Eingaben. Beispiele in $\Pclass$: Sortieren, kürzeste Wege, minimale
|
|
Spannbäume, Matching -- für all das kennt man schnelle Algorithmen.
|
|
|
|
\begin{stolper}
|
|
\textbf{Zahlen sind binär kodiert.} Eine Zahl $K$ steht als Eingabe nur mit
|
|
ihren Ziffern da, also mit Länge $O(\log K)$. Ihr \emph{Wert} $K$ ist
|
|
exponentiell größer als diese Länge. Ein Algorithmus, der \glqq bis $K$
|
|
zählt\grqq, macht $K$ Schritte und ist damit \emph{nicht} polynomiell in der
|
|
Eingabelänge. An diesem Punkt hängt später die Schwere der Zahlprobleme.
|
|
\end{stolper}
|
|
|
|
% ==================================================================
|
|
\section{Effizient überprüfbar: die Klasse NP}
|
|
% ==================================================================
|
|
|
|
Jetzt kommt die zweite, wichtigere Klasse. Sie beruht auf einer Beobachtung, die
|
|
den ganzen Kurs trägt: \emph{Eine Lösung zu finden ist oft schwer -- eine
|
|
vorgelegte Lösung zu prüfen ist leicht.}
|
|
|
|
\begin{analogie}
|
|
Ein schweres Sudoku zu lösen dauert eine halbe Stunde. Ein fertig ausgefülltes
|
|
Gitter zu prüfen dauert eine Minute: Zeilen, Spalten, Blöcke abhaken. Genau
|
|
diese Asymmetrie zwischen Lösen und Prüfen ist der Kern von $\NP$.
|
|
\end{analogie}
|
|
|
|
\subsection{Die erste Sicht: Zertifikat und Verifizierer}
|
|
|
|
Die \glqq vorgelegte Lösung\grqq{} bekommt einen Namen.
|
|
|
|
\begin{defn}{Verifizierer, Zertifikat}
|
|
Ein \emph{Verifizierer} für ein Problem $L$ ist ein Algorithmus $A$, der zwei
|
|
Eingaben bekommt: die eigentliche Instanz $x$ und einen Lösungsvorschlag $c$. Er
|
|
erfüllt
|
|
\[
|
|
x \in L \quad\Longleftrightarrow\quad
|
|
\text{es gibt ein } c \text{ mit } A(x,c) = 1.
|
|
\]
|
|
Der Vorschlag $c$ heißt \emph{Zertifikat}.
|
|
\end{defn}
|
|
|
|
Lies die beiden Richtungen einzeln, beide sind wichtig. Ist $x$ eine
|
|
Ja-Instanz, so \emph{gibt es} ein Zertifikat, das $A$ überzeugt. Ist $x$ eine
|
|
Nein-Instanz, so überzeugt $A$ \emph{kein} Zertifikat -- man kann ihm vorlegen,
|
|
was man will.
|
|
|
|
\begin{defn}{Klasse NP}
|
|
$\NP$ ist die Menge aller Probleme, die einen Verifizierer besitzen, der ein
|
|
\emph{polynomiell langes} Zertifikat in \emph{polynomieller} Zeit prüft.
|
|
\end{defn}
|
|
|
|
\begin{intuition}
|
|
$\NP$ heißt \glqq effizient \emph{überprüfbar}\grqq, nicht \glqq effizient
|
|
\emph{lösbar}\grqq. Das Zertifikat ist die kurze Antwort auf die Frage
|
|
\glqq und woher weiß ich, dass das stimmt?\grqq. Wer die Lösung schon in der Hand
|
|
hält, kann sie billig kontrollieren -- sie zu \emph{finden} ist die eigentliche
|
|
Arbeit.
|
|
\end{intuition}
|
|
|
|
\subsection{Die zweite Sicht: nichtdeterministisches Raten}
|
|
|
|
Es gibt eine gleichwertige zweite Art, $\NP$ zu sehen. Stell dir einen
|
|
Algorithmus vor, der an jeder Verzweigung nicht \emph{eine} Möglichkeit wählt,
|
|
sondern sich in Kopien aufteilt und \emph{alle gleichzeitig} verfolgt. So ein
|
|
Algorithmus heißt \emph{nichtdeterministisch}. Er \glqq akzeptiert\grqq, wenn
|
|
\emph{irgendeine} Kopie ans Ziel kommt; für eine Nein-Instanz kommt keine an.
|
|
|
|
Sein Arbeitsmuster ist immer dasselbe: \emph{rate die Lösung, dann prüfe sie}.
|
|
Die Folge der Rate-Entscheidungen \emph{ist} genau das Zertifikat. Deshalb
|
|
beschreiben \glqq richtig raten können\grqq{} und \glqq ein Zertifikat geschenkt
|
|
bekommen\grqq{} dieselbe Fähigkeit -- und dieselbe Klasse $\NP$.
|
|
|
|
Diese Rate-Sicht ist praktisch, wenn man einen NP-Nachweis in Worten führt: Man
|
|
sagt, was die Maschine rät (das Zertifikat) und wie sie es danach
|
|
deterministisch prüft.
|
|
|
|
\subsection{P steckt in NP}
|
|
|
|
\begin{satz}{$\Pclass \subseteq \NP$}
|
|
Jedes effizient lösbare Problem ist auch effizient überprüfbar.\\[0.3em]
|
|
\emph{Warum:} Wer ein Problem selbst schnell lösen kann, braucht das Zertifikat
|
|
gar nicht. Er ignoriert es und rechnet die Antwort direkt aus. Der Löser ist
|
|
damit ein besonders fauler Verifizierer.
|
|
\end{satz}
|
|
|
|
Die große offene Frage ist die Umkehrung: Gilt $\Pclass = \NP$? Ist alles, was
|
|
man schnell prüfen kann, auch schnell lösbar? Niemand weiß es. Es ist eines der
|
|
sieben Millennium-Probleme. Die meisten glauben $\Pclass \ne \NP$. Der ganze Rest
|
|
des Kurses ist der Umgang mit dieser Unwissenheit.
|
|
|
|
% ==================================================================
|
|
\section{Reduktionen: Probleme vergleichen}
|
|
% ==================================================================
|
|
|
|
Jetzt das wichtigste Werkzeug. Mit einer \emph{Reduktion} vergleicht man zwei
|
|
Probleme nach Schwierigkeit -- ohne für eines von beiden einen Algorithmus zu
|
|
kennen.
|
|
|
|
\begin{defn}{Polynomielle Reduktion $A \redp B$}
|
|
Eine \emph{Reduktion} von $A$ auf $B$ ist eine Funktion $f$, die jede
|
|
$A$-Eingabe $w$ in eine $B$-Eingabe $f(w)$ übersetzt, sodass die Antworten
|
|
zusammenpassen:
|
|
\[
|
|
w \in A \quad\Longleftrightarrow\quad f(w) \in B.
|
|
\]
|
|
Sie ist \emph{polynomiell}, wenn $f$ in polynomieller Zeit berechenbar ist. Man
|
|
schreibt $A \redp B$.
|
|
\end{defn}
|
|
|
|
\begin{intuition}
|
|
$A \redp B$ bedeutet: \glqq $B$ ist \emph{mindestens so schwer} wie $A$.\grqq{}
|
|
Denn wer $B$ schnell lösen kann, löst über die billige Umformung $f$ auch $A$
|
|
schnell: erst $f(w)$ berechnen, dann den $B$-Löser fragen, dessen Antwort ist
|
|
auch die für $w$. Die Schwierigkeit fließt entlang des Pfeils.
|
|
\end{intuition}
|
|
|
|
\begin{stolper}
|
|
\textbf{Die Richtung ist der teuerste Fehler.} Um zu zeigen, dass ein
|
|
\emph{neues} Problem $Y$ schwer ist, reduziert man ein \emph{bekannt schweres}
|
|
$X$ \emph{auf} $Y$ -- also $X \redp Y$, \glqq bekannt $\redp$ neu\grqq. Die
|
|
Reduktion nimmt eine $X$-Instanz und baut daraus eine $Y$-Instanz. Andersherum
|
|
($Y \redp X$) zeigt man nur, dass $Y$ \emph{höchstens} so schwer wie $X$ ist --
|
|
und das sagt über $Y$ nichts.
|
|
\end{stolper}
|
|
|
|
\begin{satz}{Transitivität}
|
|
$A \redp B$ und $B \redp C$ ergeben zusammen $A \redp C$.\\[0.3em]
|
|
\emph{Warum:} Man schaltet die beiden Umformungen hintereinander. Die
|
|
Zwischenausgabe ist polynomiell groß, also bleibt die Verkettung polynomiell.
|
|
\end{satz}
|
|
|
|
Deshalb kann eine ganze \emph{Kette} von Reduktionen die Schwere Glied für Glied
|
|
weitertragen. Genau diese Kette bauen wir im Problem-Katalog auf.
|
|
|
|
% ==================================================================
|
|
\section{NP-schwer, NP-vollständig, und der Anker}
|
|
% ==================================================================
|
|
|
|
Mit der Reduktion können wir \glqq die schwersten Probleme in $\NP$\grqq{}
|
|
präzise fassen.
|
|
|
|
\begin{defn}{NP-schwer, NP-vollständig}
|
|
Ein Problem $L_0$ heißt \emph{NP-schwer}, wenn sich \emph{jedes} $L \in \NP$ auf
|
|
$L_0$ reduzieren lässt ($L \redp L_0$). Es heißt \emph{NP-vollständig}, wenn es
|
|
NP-schwer ist \textbf{und} selbst in $\NP$ liegt.
|
|
\end{defn}
|
|
|
|
\begin{intuition}
|
|
Zwei Schranken treffen sich. \emph{NP-schwer} ist eine untere Schranke:
|
|
mindestens so schwer wie alles in $\NP$. \emph{In $\NP$} ist eine obere Schranke:
|
|
nicht schwerer als $\NP$. \emph{NP-vollständig} heißt beides -- die schwersten
|
|
Probleme innerhalb von $\NP$.
|
|
\end{intuition}
|
|
|
|
\begin{satz}{Ein Algorithmus für eines löst alle}
|
|
Ist $L_0$ NP-vollständig, dann gilt $\Pclass = \NP$ genau dann, wenn
|
|
$L_0 \in \Pclass$.\\[0.3em]
|
|
\emph{Warum:} Läge $L_0$ in $\Pclass$, könnte man jedes $L \in \NP$ lösen -- erst
|
|
die Reduktion $L \redp L_0$ rechnen, dann den schnellen $L_0$-Löser. Damit läge
|
|
ganz $\NP$ in $\Pclass$.
|
|
\end{satz}
|
|
|
|
Damit die Reduktionskette starten kann, braucht man ein \emph{erstes}
|
|
NP-vollständiges Problem, das man von Hand als schwer nachweist. Das lieferten
|
|
Cook und Levin.
|
|
|
|
\begin{satz}{Cook (1971), Levin (1973)}
|
|
\problem{SAT} ist NP-vollständig -- das erste solche Problem.\\[0.3em]
|
|
\emph{Die Idee:} Man nimmt ein \emph{beliebiges} $L \in \NP$ mit seiner ratenden
|
|
Maschine und gießt deren gesamte Rechnung in eine große logische Formel.
|
|
Variablen beschreiben Aussagen wie \glqq zur Zeit $t$ ist die Maschine im Zustand
|
|
$q$\grqq{} oder \glqq zur Zeit $t$ steht auf Feld $i$ das Symbol $a$\grqq.
|
|
Teilformeln erzwingen einen gültigen Ablauf. Das Entscheidende: Eine erfüllende
|
|
Belegung entspricht \emph{genau} einem akzeptierenden Rechenweg. Also ist die
|
|
Formel erfüllbar genau dann, wenn $L$ die Eingabe akzeptiert. Da $L$ beliebig
|
|
war, ist \problem{SAT} schwer für ganz $\NP$.
|
|
\end{satz}
|
|
|
|
\begin{idee}{Das Vererbungskorollar -- so wächst der Katalog}
|
|
Um ein \emph{neues} Problem $Y$ als NP-vollständig nachzuweisen, genügen zwei
|
|
Dinge: (1) eine Reduktion $X \redp Y$ von einem \emph{bereits bekannten}
|
|
NP-vollständigen $X$, und (2) der Nachweis $Y \in \NP$. Denn dann gilt für jedes
|
|
$L \in \NP$ die Kette $L \redp X \redp Y$ -- also ist $Y$ NP-schwer, und mit
|
|
$Y \in \NP$ auch NP-vollständig.
|
|
\end{idee}
|
|
|
|
Ab hier braucht man nie wieder \glqq alle $L \in \NP$\grqq{} zu betrachten. Jedes
|
|
neue Problem hängt sich über \emph{eine} Reduktion an ein schon bekanntes. Der
|
|
folgende Katalog geht genau so vor: Er beginnt bei \problem{SAT} und hängt jedes
|
|
Problem an ein früheres. Deshalb steht bei jedem Problem, \emph{woher} seine
|
|
Schwere kommt (die eingehende Reduktion) und \emph{wohin} sie weiterfließt (die
|
|
ausgehenden Reduktionen).
|
|
|
|
\begin{center}
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{picture}(13,8.7)(0,-0.3)
|
|
\put(5.1,7.7){\framebox(2.4,0.7){\textbf{\problem{SAT}}}}
|
|
\put(6.3,7.7){\vector(-2,-1){2.6}}
|
|
\put(6.3,7.7){\vector(0,-1){1.3}}
|
|
\put(6.3,7.7){\vector(2,-1){2.6}}
|
|
\put(2.6,5.7){\framebox(2.0,0.7){\problem{3-SAT}}}
|
|
\put(5.3,5.7){\framebox(2.0,0.7){\problem{$k$-Clique}}}
|
|
\put(8.0,5.7){\framebox(2.0,0.7){\problem{3-DM}}}
|
|
\put(3.6,5.7){\vector(0,-1){1.3}}
|
|
\put(6.3,5.7){\vector(0,-1){1.3}}
|
|
\put(9.0,5.7){\vector(0,-1){1.3}}
|
|
\put(2.4,3.7){\framebox(2.4,0.7){\problem{Color}, \problem{HK}}}
|
|
\put(5.1,3.7){\framebox(2.4,0.7){\problem{IS}, \problem{VC}}}
|
|
\put(8.0,3.7){\framebox(2.0,0.7){\problem{3-EC}}}
|
|
\put(3.6,3.7){\vector(0,-1){1.3}}
|
|
\put(6.3,3.7){\vector(0,-1){1.3}}
|
|
\put(9.0,3.7){\vector(0,-1){1.3}}
|
|
\put(2.2,1.7){\framebox(2.8,0.7){\problem{HK}$\to$\problem{TSP}; Hitting Set}}
|
|
\put(5.1,1.7){\framebox(2.4,0.7){\problem{FVS}, $\Delta$-Cover}}
|
|
\put(8.0,1.7){\framebox(2.0,0.7){\problem{SubSetSum}}}
|
|
\put(9.0,1.7){\vector(0,-1){1.3}}
|
|
\put(6.6,0.0){\framebox(3.8,0.7){\problem{Partition}, \problem{Knapsack}, $P\|\Cmax$}}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
% ##################################################################
|
|
\part*{Teil B -- Der Problem-Katalog}
|
|
\addcontentsline{toc}{section}{\textbf{Teil B -- Der Problem-Katalog}}
|
|
% ##################################################################
|
|
|
|
\noindent Jetzt kommt das Herzstück. Wir gehen alle Probleme des Kurses durch --
|
|
jedes für sich, keines mit einem anderen zusammengelegt. Der Aufbau ist bei jedem
|
|
gleich: erst die \textbf{Definition} mit Beispiel, dann \textbf{warum es in $\NP$
|
|
liegt}, dann \textbf{woher seine Schwere kommt} (die eingehende Reduktion) und
|
|
schließlich \textbf{was daraus folgt} (die ausgehenden Reduktionen). Die
|
|
Reihenfolge folgt der Reduktionskette: Jedes Problem wird an ein früheres
|
|
gehängt, das du schon kennst.
|
|
|
|
% ==================================================================
|
|
\section{SAT}
|
|
% ==================================================================
|
|
|
|
\problem{SAT} steht am Anfang von allem -- es ist das erste NP-vollständige
|
|
Problem und der Anker, an dem die ganze Kette hängt. Es geht um Formeln der
|
|
Aussagenlogik in einer festen Form.
|
|
|
|
\begin{defn}{SAT}
|
|
Eine \emph{konjunktive Normalform} (KNF) ist ein UND von \emph{Klauseln}, wobei
|
|
jede Klausel ein ODER von \emph{Literalen} ist; ein Literal ist eine Variable
|
|
$x_j$ oder ihre Verneinung $\neg x_j$. \problem{SAT} fragt: Gegeben eine
|
|
KNF-Formel $\alpha$, gibt es eine Belegung der Variablen mit wahr/falsch, die die
|
|
ganze Formel wahr macht -- also jede Klausel erfüllt?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{SAT von Hand}
|
|
$\alpha = (x_1 \vee x_{10}) \wedge (x_1 \vee \neg x_{10}) \wedge (x_{10})$.
|
|
Die dritte Klausel besteht nur aus $x_{10}$ und zwingt daher $x_{10} = \true$.
|
|
Damit die zweite Klausel wahr wird -- $\neg x_{10}$ ist jetzt falsch -- muss
|
|
$x_1 = \true$ sein. Mit beiden auf wahr ist auch die erste Klausel erfüllt. Die
|
|
Formel ist also erfüllbar, ein Zeuge ist $x_1 = x_{10} = \true$.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum SAT in NP liegt}
|
|
|
|
Wir führen den Nachweis vollständig, in vier Gedanken.
|
|
|
|
\emph{Das Zertifikat.} Die \glqq Lösung\grqq{} einer erfüllbaren Formel ist eine
|
|
Belegung $\psi$ -- für jede Variable ein Wahrheitswert. Man kodiert sie mit einem
|
|
Bit pro Variable. Hat die Formel $v$ Variablen, so ist das Zertifikat $v$ Bits
|
|
lang, also höchstens so lang wie die Formel selbst und damit polynomiell.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer bekommt die Formel $\alpha$ und die Belegung
|
|
$\psi$. Er setzt $\psi$ in $\alpha$ ein und wertet Klausel für Klausel aus: Eine
|
|
Klausel ist wahr, sobald eines ihrer Literale wahr ist. Er akzeptiert genau dann,
|
|
wenn \emph{alle} Klauseln wahr sind.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Ist $\alpha$ erfüllbar, so gibt
|
|
es eine erfüllende Belegung; legt man genau sie als Zertifikat vor, macht sie
|
|
jede Klausel wahr und der Verifizierer akzeptiert. Ist $\alpha$ dagegen
|
|
unerfüllbar, so macht \emph{keine} Belegung alle Klauseln wahr -- egal, welches
|
|
$\psi$ man vorlegt, mindestens eine Klausel bleibt falsch und der Verifizierer
|
|
lehnt ab. Beide Richtungen stimmen also.
|
|
|
|
\emph{Die Laufzeit.} Das Einsetzen und Auswerten geht die Formel einmal durch,
|
|
kostet also lineare Zeit in der Formellänge. Damit ist der Verifizierer
|
|
polynomiell, und es folgt $\problem{SAT} \in \NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{Cook--Levin: jede NDTM-Rechnung wird zu einer Formel}
|
|
\problem{SAT} ist nicht über eine Reduktion von einem \emph{anderen} Problem
|
|
schwer -- es ist der Startpunkt. Cook und Levin zeigen direkt, dass sich
|
|
\emph{jedes} $L \in \NP$ auf \problem{SAT} reduziert. Zu einem $L$ mit ratender
|
|
Maschine $M$ und Eingabe $u$ baut man eine KNF $\alpha_u$, deren Variablen die
|
|
gesamte Rechnung von $M$ beschreiben: \glqq zur Zeit $t$ ist der Zustand $q$\grqq,
|
|
\glqq zur Zeit $t$ steht auf Feld $i$ das Symbol $a$\grqq{} und so weiter.
|
|
Teilformeln erzwingen einen korrekten Anfang, korrekte Übergänge und einen
|
|
akzeptierenden Schluss. Dann gilt: $\alpha_u$ ist erfüllbar genau dann, wenn $M$
|
|
die Eingabe $u$ akzeptiert. Also $u \in L \iff \alpha_u \in \problem{SAT}$.
|
|
\end{idee}
|
|
|
|
\subsection*{Was daraus folgt}
|
|
|
|
Von \problem{SAT} gehen mehrere Reduktionen aus -- sie machen die nächsten
|
|
Probleme schwer.
|
|
|
|
\begin{idee}{$\problem{SAT} \redp \problem{3-SAT}$: lange Klauseln aufspalten}
|
|
Eine lange Klausel wird mit einer neuen Hilfsvariablen in zwei kürzere zerlegt,
|
|
etwa $(y_1 \vee y_2 \vee y_3 \vee y_4)$ in $(y_1 \vee y_2 \vee x) \wedge
|
|
(\neg x \vee y_3 \vee y_4)$. Ist ursprünglich ein $y_i$ wahr, lässt sich $x$
|
|
passend setzen; ist keines wahr, entsteht in der Kette ein Widerspruch. So
|
|
schrumpfen alle Klauseln auf höchstens drei Literale, ohne die Erfüllbarkeit zu
|
|
ändern.
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{SAT} \redp \problem{$k$-Clique}$: ein Knoten pro Literal}
|
|
Man baut einen Graphen mit \emph{einem Knoten pro Literalvorkommen} und verbindet
|
|
zwei Knoten genau dann, wenn sie aus verschiedenen Klauseln stammen und sich
|
|
nicht widersprechen. Gesucht wird eine Clique der Größe $k = m$ (Zahl der
|
|
Klauseln). Eine solche Clique wählt aus jeder Klausel ein widerspruchsfreies,
|
|
wahres Literal -- also eine erfüllende Belegung. (Diese Reduktion zeichnen wir
|
|
beim Cliquenproblem in Ruhe.)
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{SAT} \redp \problem{3-dim.\ Matching}$: Zahnrad und Garbage Collection}
|
|
Pro Variable baut man eine \glqq Zahnrad\grqq-Struktur aus Tripeln, die nur zwei
|
|
konsistente Auswahlen zulässt -- Variable wahr oder falsch. Klausel-Tripel prüfen,
|
|
ob ein erfüllendes Literal gewählt wurde, und eine \glqq Garbage-Collection\grqq{}
|
|
aus weiteren Tripeln räumt die übrig gebliebenen Literale weg.
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{SAT} \redp \problem{Halteproblem}$: alle Belegungen durchprobieren}
|
|
Zu einer Formel $\varphi$ baut man ein Programm, das der Reihe nach alle
|
|
Belegungen durchprobiert und genau dann anhält, wenn es eine erfüllende findet.
|
|
Dann hält das Programm genau dann, wenn $\varphi$ erfüllbar ist. (Mehr dazu beim
|
|
Halteproblem am Ende des Katalogs.)
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{3-SAT}
|
|
% ==================================================================
|
|
|
|
\problem{3-SAT} ist die \glqq handliche\grqq{} Version von \problem{SAT}. Kurze
|
|
Klauseln lassen sich viel leichter in andere Probleme einbauen, deshalb starten
|
|
fast alle späteren Reduktionen hier statt beim allgemeinen \problem{SAT}.
|
|
|
|
\begin{defn}{3-SAT}
|
|
Wie \problem{SAT}, aber jede Klausel hat \emph{höchstens drei} Literale. Frage:
|
|
Ist die Formel erfüllbar?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{3-SAT von Hand}
|
|
$\alpha = (x_1 \vee x_2 \vee \neg x_3) \wedge (\neg x_1 \vee x_2)$. Setzt man
|
|
$x_2 = \true$, so ist die zweite Klausel über $x_2$ erfüllt und die erste
|
|
ebenfalls. Also erfüllbar, unabhängig von $x_1$ und $x_3$.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum 3-SAT in NP liegt}
|
|
|
|
Wir führen den Nachweis eigenständig und vollständig -- auch wenn er dem von
|
|
\problem{SAT} ähnelt.
|
|
|
|
\emph{Das Zertifikat.} Wieder eine Belegung $\psi$, ein Bit pro Variable, also
|
|
polynomiell lang.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer setzt $\psi$ in die Formel ein und wertet
|
|
jede Klausel aus. Weil jede Klausel jetzt höchstens drei Literale hat, kostet das
|
|
Auswerten einer Klausel sogar nur konstante Zeit; er akzeptiert, wenn alle
|
|
Klauseln wahr sind.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Ist die Formel erfüllbar, wird
|
|
die erfüllende Belegung akzeptiert. Ist sie unerfüllbar, bleibt bei jeder Belegung
|
|
mindestens eine Klausel falsch, und der Verifizierer lehnt ab.
|
|
|
|
\emph{Die Laufzeit.} Ein Durchlauf durch die Formel, also linear. Damit
|
|
$\problem{3-SAT} \in \NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{$\problem{SAT} \redp \problem{3-SAT}$: lange Klauseln zerlegen}
|
|
Man ersetzt jede zu lange Klausel durch eine \emph{Kette} kürzerer Klauseln, die
|
|
durch neue Hilfsvariablen verbunden sind. Eine Klausel $(y_1 \vee y_2 \vee y_3
|
|
\vee y_4)$ wird etwa zu $(y_1 \vee y_2 \vee x) \wedge (\neg x \vee y_3 \vee y_4)$
|
|
mit einer neuen Variablen $x$. Bei längeren Klauseln setzt sich diese Kette fort:
|
|
$(y_1 \vee y_2 \vee x_1) \wedge (\neg x_1 \vee y_3 \vee x_2) \wedge \dots$
|
|
\end{idee}
|
|
|
|
Warum das die Erfüllbarkeit erhält -- beide Richtungen. Ist die ursprüngliche
|
|
Klausel erfüllt, so ist eines ihrer Literale $y_i$ wahr; dann kann man die
|
|
Hilfsvariablen der Kette so setzen, dass jede kurze Klausel wahr wird (vor $y_i$
|
|
die $x$-Literale wahr, danach die $\neg x$-Literale). Ist umgekehrt \emph{kein}
|
|
$y_i$ wahr, so erzwingt die erste kurze Klausel, dass ihre Hilfsvariable wahr
|
|
sein muss, diese erzwingt die nächste, und so fort -- am Ende der Kette entsteht
|
|
ein Widerspruch, die kurze Formel ist also nicht erfüllbar. Erfüllbar bleibt
|
|
genau erfüllbar. Da jede Klausel nur konstant vergrößert wird, ist die
|
|
Umformung polynomiell. Weil \problem{SAT} NP-vollständig ist und
|
|
$\problem{3-SAT} \in \NP$ gilt, ist auch \problem{3-SAT} NP-vollständig.
|
|
|
|
\subsection*{Was daraus folgt}
|
|
|
|
\begin{idee}{$\problem{3-SAT} \redp \problem{$k$-Color}$: Wahrheit als Farbe}
|
|
Man baut ein Gadget mit den Knoten $x_i, \bar x_i, v_i$ pro Variable, einem
|
|
Klauselknoten pro Klausel und einem Zentrum $z$. Die $v_i$ und $z$ bilden eine
|
|
Clique und erzwingen $n+1$ Farben; dadurch bleibt jedem Paar $x_i, \bar x_i$ nur
|
|
\glqq wahr\grqq{} oder \glqq falsch\grqq. Die Klauselknoten sind so verdrahtet,
|
|
dass sie sich genau dann korrekt färben lassen, wenn die Klausel erfüllt ist.
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{3-SAT}' \redp \problem{Hamiltonkreis}$: A- und B-Komponenten}
|
|
Für die Variante mit genau drei Literalen pro Klausel baut man
|
|
\glqq A-Komponenten\grqq, die die Variablensetzung kodieren (zwei
|
|
Durchlaufrichtungen = wahr/falsch), und \glqq B-Komponenten\grqq{} pro Klausel,
|
|
die nur dann durchlaufbar sind, wenn mindestens ein Literal wahr ist. Ein
|
|
Hamiltonkreis existiert genau dann, wenn eine erfüllende Belegung existiert.
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{3-SAT} \redp \problem{Hitting Set}$}
|
|
Das Universum sind alle Literale $x_i, \bar x_i$. Pro Variable bildet man die
|
|
Menge $\{x_i, \bar x_i\}$ (sie zwingt die Trefferwahl, genau ein Literal je
|
|
Variable zu wählen), pro Klausel die Menge ihrer Literale (sie verlangt, dass ein
|
|
erfüllendes Literal getroffen wird). Mit Schranke $k = n$ trifft eine Lösung
|
|
genau dann alle Mengen, wenn die Formel erfüllbar ist.
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{$k$-Clique}
|
|
% ==================================================================
|
|
|
|
Das Cliquenproblem aus der Einleitung, jetzt vollständig behandelt.
|
|
|
|
\begin{defn}{$k$-Clique}
|
|
Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Eine \emph{Clique} ist eine
|
|
Knotengruppe, in der alle paarweise durch eine Kante verbunden sind. Frage: Gibt
|
|
es eine Clique der Größe $\ge k$?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Eine Clique}
|
|
Im Graphen mit $V = \{1,2,3,4\}$ und Kanten $\{1,2\}, \{1,3\}, \{2,3\}, \{3,4\}$
|
|
ist $\{1,2,3\}$ eine Clique der Größe 3, weil die drei Kanten zwischen ihnen
|
|
existieren. $\{1,3,4\}$ ist keine Clique, weil zwischen 1 und 4 die Kante fehlt.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum $k$-Clique in NP liegt}
|
|
|
|
\emph{Das Zertifikat.} Die Lösung ist die Knotengruppe $C \subseteq V$ selbst,
|
|
etwa als Liste der gewählten Knoten. Sie hat höchstens $|V|$ Einträge, ist also
|
|
polynomiell lang.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer bekommt $(G, k)$ und die Gruppe $C$. Er
|
|
prüft zwei Dinge. Erstens, ob wirklich \emph{jedes} Paar $\{u,v\}$ aus $C$ durch
|
|
eine Kante verbunden ist -- dazu geht er alle Paare aus $C$ durch und schlägt in
|
|
der Kantenliste nach. Zweitens, ob $|C| \ge k$ gilt. Er akzeptiert, wenn beides
|
|
zutrifft.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Gibt es eine $k$-Clique, so ist
|
|
genau sie ein Zertifikat, bei dem alle Paare verbunden sind und die Größe stimmt;
|
|
der Verifizierer akzeptiert. Gibt es keine, so hat jede vorgelegte Gruppe der
|
|
Größe $\ge k$ mindestens ein unverbundenes Paar, und der Verifizierer lehnt ab.
|
|
|
|
\emph{Die Laufzeit.} Es gibt höchstens $\binom{|C|}{2} = O(|V|^2)$ Paare, jeder
|
|
Kantennachschlag kostet $O(1)$; die Größenprüfung kostet $O(|V|)$. Insgesamt
|
|
$O(|V|^2)$, also polynomiell. Damit $\problem{$k$-Clique} \in \NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{$\problem{SAT} \redp \problem{$k$-Clique}$: ein Knoten pro Literal}
|
|
Zu einer KNF $F = F_1 \wedge \dots \wedge F_m$ baut man den Graphen so: Für jedes
|
|
Literalvorkommen -- das $j$-te Literal in Klausel $i$ -- setzt man einen Knoten
|
|
$[i,j]$. Zwei Knoten werden verbunden, wenn sie aus \emph{verschiedenen} Klauseln
|
|
stammen \emph{und} sich nicht widersprechen (nicht $x$ gegen $\neg x$). Gesucht
|
|
ist eine Clique der Größe $k = m$.
|
|
\end{idee}
|
|
|
|
Warum das stimmt: Eine $m$-Clique muss aus jeder Klausel genau einen Knoten
|
|
nehmen -- Knoten derselben Klausel sind nie verbunden, es passt also höchstens
|
|
einer pro Klausel hinein, und bei $m$ Knoten ist es genau einer. Weil verbundene
|
|
Knoten sich nicht widersprechen, wählt die Clique aus jeder Klausel ein
|
|
widerspruchsfreies Literal. Setzt man diese Literale auf wahr, erfüllt man jede
|
|
Klausel. Umgekehrt liefert jede erfüllende Belegung eine solche Clique.
|
|
|
|
\begin{bsp}{$\problem{SAT} \redp \problem{Clique}$ am Beispiel}
|
|
$F = (x_1 \vee x_2 \vee x_3) \wedge (\neg x_1 \vee \neg x_2) \wedge (x_1 \vee
|
|
\neg x_2 \vee \neg x_3)$, also $m = 3$ und $k = 3$. Es entstehen acht Knoten in
|
|
drei Spalten (eine je Klausel). Fett die Lösungs-Clique $\{[1,1],[2,2],[3,1]\}$,
|
|
die für $x_1, \neg x_2, x_1$ steht und die Belegung $x_1 = \true$,
|
|
$x_2 = \false$ liefert.
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{center}
|
|
\begin{picture}(10,3.6)(-0.7,-0.4)
|
|
\put(1.0,3.3){\small Klausel 1}
|
|
\put(0.5,2.6){\circle*{0.17}}\put(-0.7,2.55){\small $[1,1]\,x_1$}
|
|
\put(0.5,1.5){\circle{0.17}}\put(-0.05,1.42){\small $x_2$}
|
|
\put(0.5,0.5){\circle{0.17}}\put(-0.05,0.42){\small $x_3$}
|
|
\put(4.0,3.3){\small Klausel 2}
|
|
\put(4.5,2.6){\circle{0.17}}\put(4.7,2.55){\small $\neg x_1$}
|
|
\put(4.5,1.5){\circle*{0.17}}\put(4.7,1.42){\small $[2,2]\,\neg x_2$}
|
|
\put(7.6,3.3){\small Klausel 3}
|
|
\put(8.5,2.6){\circle*{0.17}}\put(7.15,2.55){\small $x_1\,[3,1]$}
|
|
\put(8.5,1.5){\circle{0.17}}\put(8.7,1.42){\small $\neg x_2$}
|
|
\put(8.5,0.5){\circle{0.17}}\put(8.7,0.42){\small $\neg x_3$}
|
|
\linethickness{1.3pt}
|
|
\put(0.5,2.6){\line(4,-1){4}}
|
|
\put(4.5,1.5){\line(4,1){4}}
|
|
\put(0.5,2.6){\line(1,0){8}}
|
|
\end{picture}
|
|
\end{center}
|
|
Die drei fetten Kanten bilden das Dreieck (die 3-Clique). Die vielen dünnen
|
|
Kanten zwischen anderen verträglichen Paaren sind der Übersicht halber
|
|
weggelassen.
|
|
\end{bsp}
|
|
|
|
\subsection*{Was daraus folgt}
|
|
|
|
\begin{idee}{$\problem{Clique} \redp \problem{Vertex Cover}$: Komplement}
|
|
Aus $(G, k)$ mit $n = |V|$ macht man $(\bar G, n-k)$ -- Komplementgraph und
|
|
Schranke $n-k$. Eine Clique der Größe $k$ in $G$ ist ein Independent Set in
|
|
$\bar G$, und dessen Rest $V \setminus C$ ein Vertex Cover der Größe $n-k$.
|
|
(Ausführlich beim Vertex Cover.)
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{Clique} \redp \problem{Independent Set}$: Komplement}
|
|
Aus $(G,k)$ macht man $(\bar G, k)$. Eine Clique in $G$ ist genau ein Independent
|
|
Set im Komplementgraphen $\bar G$ -- dort fehlen genau die Kanten, die $G$ hat.
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{Clique} \redp \problem{Clique-Nomember}$: isolierter Dummy}
|
|
\problem{Clique-Nomember} fragt nach einer $k$-Clique, die einen bestimmten
|
|
Knoten $v$ \emph{nicht} enthält. Man fügt einfach einen neuen, isolierten Knoten
|
|
$v$ hinzu -- er kann in keiner Clique liegen, also ändert die Zusatzbedingung
|
|
nichts an der Antwort.
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{Clique} \redp \problem{Clique-Universal}$: universeller Knoten}
|
|
\problem{Clique-Universal} verlangt, dass die Instanz einen \emph{universellen}
|
|
Knoten enthält (mit allen verbunden). Man fügt einen solchen Knoten $u$ hinzu und
|
|
erhöht die Schranke auf $k+1$. Jede $k$-Clique in $G$ wird mit $u$ zu einer
|
|
$(k+1)$-Clique, und umgekehrt.
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{Independent Set}
|
|
% ==================================================================
|
|
|
|
\problem{Independent Set} ist das genaue Gegenstück zur Clique: Dort sind alle
|
|
verbunden, hier keiner.
|
|
|
|
\begin{defn}{Independent Set (IS)}
|
|
Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Ein \emph{Independent Set} ist
|
|
eine Knotengruppe, in der \emph{keine} zwei Knoten verbunden sind. Frage: Gibt
|
|
es ein Independent Set der Größe $\ge k$?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Ein Independent Set}
|
|
Im Graphen mit $V = \{1,2,3,4\}$ und Kanten $\{1,2\}, \{2,3\}, \{3,4\}$ ist
|
|
$\{1,3\}$ ein Independent Set der Größe 2 -- zwischen 1 und 3 gibt es keine
|
|
Kante. Auch $\{1,4\}$ ist eines. $\{1,2\}$ ist keines, weil 1 und 2 verbunden
|
|
sind.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Independent Set in NP liegt}
|
|
|
|
\emph{Das Zertifikat.} Die Knotengruppe $I \subseteq V$, polynomiell lang.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer geht alle Paare aus $I$ durch und prüft, dass
|
|
\emph{keines} von ihnen durch eine Kante verbunden ist; außerdem prüft er
|
|
$|I| \ge k$. Er akzeptiert, wenn beides zutrifft.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Gibt es ein Independent Set der
|
|
Größe $\ge k$, wird es akzeptiert. Gibt es keines, enthält jede vorgelegte Gruppe
|
|
der Größe $\ge k$ ein verbundenes Paar, und der Verifizierer lehnt ab.
|
|
|
|
\emph{Die Laufzeit.} Wieder $O(|V|^2)$ Paare mit je $O(1)$-Kantennachschlag, plus
|
|
$O(|V|)$ für die Größe. Insgesamt $O(|V|^2)$, also $\problem{IS} \in \NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{$\problem{Clique} \redp \problem{Independent Set}$: Komplementgraph}
|
|
Man bildet den Komplementgraphen $\bar G$ (dieselben Knoten, genau die fehlenden
|
|
Kanten) und behält die Schranke $k$. Eine Knotengruppe $C$ ist genau dann eine
|
|
Clique in $G$, wenn zwischen ihren Knoten in $\bar G$ \emph{keine} Kante liegt --
|
|
also ein Independent Set in $\bar G$. So wird aus der $k$-Clique-Frage in $G$
|
|
wörtlich die $k$-IS-Frage in $\bar G$.
|
|
\end{idee}
|
|
|
|
\subsection*{Was daraus folgt}
|
|
|
|
\problem{Independent Set} ist im Kurs vor allem das Bindeglied der Dualität
|
|
zwischen Clique, IS und Vertex Cover: Eine Menge $I$ ist genau dann ein
|
|
Independent Set, wenn ihr Komplement $V \setminus I$ ein Vertex Cover ist. Diese
|
|
Beziehung wird beim Vertex Cover benutzt. Eine eigenständige Reduktion \emph{von}
|
|
Independent Set auf ein weiteres Kursproblem wird im Material nicht geführt.
|
|
|
|
% ==================================================================
|
|
\section{Vertex Cover}
|
|
% ==================================================================
|
|
|
|
\problem{Vertex Cover} ist das dritte Problem des engen Verwandtenkreises -- und
|
|
der Startpunkt für mehrere weitere Reduktionen.
|
|
|
|
\begin{defn}{Vertex Cover (VC)}
|
|
Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Ein \emph{Vertex Cover} ist eine
|
|
Knotenmenge, die \emph{jede} Kante berührt (von jeder Kante liegt mindestens ein
|
|
Endpunkt in der Menge). Frage: Gibt es ein Vertex Cover der Größe $\le k$?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Ein Vertex Cover}
|
|
Im Graphen mit $V = \{1,2,3,4\}$ und Kanten $\{1,2\}, \{2,3\}, \{3,4\}$ ist
|
|
$\{2,3\}$ ein Vertex Cover der Größe 2: Kante $\{1,2\}$ berührt 2, $\{2,3\}$
|
|
berührt beide, $\{3,4\}$ berührt 3. Der einzelne Knoten $\{2\}$ genügt nicht --
|
|
$\{3,4\}$ bliebe unberührt.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Vertex Cover in NP liegt}
|
|
|
|
\emph{Das Zertifikat.} Die Knotenmenge $C \subseteq V$, polynomiell lang.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer geht \emph{jede} Kante $\{u,v\} \in E$ durch
|
|
und prüft, ob $u \in C$ oder $v \in C$ gilt -- ob die Kante also berührt wird.
|
|
Zusätzlich prüft er $|C| \le k$. Er akzeptiert, wenn jede Kante berührt ist und
|
|
die Größe stimmt.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Gibt es ein Vertex Cover der
|
|
Größe $\le k$, wird es akzeptiert. Gibt es keines, bleibt bei jeder vorgelegten
|
|
Menge dieser Größe mindestens eine Kante unberührt, und der Verifizierer lehnt
|
|
ab.
|
|
|
|
\emph{Die Laufzeit.} Ein Durchlauf durch alle Kanten, also $O(|E|)$, plus
|
|
$O(|V|)$ für die Größe. Damit $\problem{VC} \in \NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{$\problem{Clique} \redp \problem{Vertex Cover}$: Komplement und $n-k$}
|
|
Aus der Clique-Instanz $(G, k)$ mit $n = |V|$ bildet man den Komplementgraphen
|
|
$\bar G$ und fragt nach einem Vertex Cover der Größe $\le n - k$. Der Grund für
|
|
das $n-k$ steckt in der Dualität: Eine Clique der Größe $k$ in $G$ ist ein
|
|
Independent Set der Größe $k$ in $\bar G$; das Komplement eines Independent Set
|
|
ist ein Vertex Cover; also wird aus einem IS der Größe $k$ ein VC der Größe
|
|
$n - k$.
|
|
\end{idee}
|
|
|
|
\begin{aha}
|
|
\textbf{Das Dualitätsdreieck} fasst alle drei Probleme in einem Bild zusammen.
|
|
Für einen Graphen $G$, seinen Komplementgraphen $\bar G$ und jede Knotenmenge
|
|
$C$ gilt:
|
|
\[
|
|
C \text{ Clique in } G
|
|
\;\iff\;
|
|
C \text{ Independent Set in } \bar G
|
|
\;\iff\;
|
|
V \setminus C \text{ Vertex Cover in } \bar G.
|
|
\]
|
|
\end{aha}
|
|
|
|
\begin{bsp}{Ein Bild, drei Rollen}
|
|
Links ein Graph $G$, in dem $\{1,2,3\}$ eine Clique ist; rechts sein Komplement
|
|
$\bar G$, in dem dieselbe Menge ein Independent Set ist und der Knoten $\{4\}$
|
|
ein Vertex Cover.
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{center}
|
|
\begin{picture}(12,3.2)(0,-0.5)
|
|
\put(1.3,2.6){\small $G$: $\{1,2,3\}$ ist Clique}
|
|
\put(1,0){\circle*{0.15}}\put(0.6,-0.05){\small $1$}
|
|
\put(1,1.7){\circle*{0.15}}\put(0.6,1.65){\small $2$}
|
|
\put(2.5,0.85){\circle*{0.15}}\put(2.65,0.8){\small $3$}
|
|
\put(3.9,0.85){\circle*{0.15}}\put(4.05,0.8){\small $4$}
|
|
\put(1,0){\line(0,1){1.7}}
|
|
\qbezier(1,0)(1.75,0.42)(2.5,0.85)
|
|
\qbezier(1,1.7)(1.75,1.27)(2.5,0.85)
|
|
\put(7.0,2.6){\small $\bar G$: $\{1,2,3\}$ ist IS, $\{4\}$ ist VC}
|
|
\put(7,0){\circle*{0.15}}\put(6.6,-0.05){\small $1$}
|
|
\put(7,1.7){\circle*{0.15}}\put(6.6,1.65){\small $2$}
|
|
\put(8.5,0.85){\circle*{0.15}}\put(8.2,1.0){\small $3$}
|
|
\put(10,0.85){\circle*{0.15}}\put(10.15,0.8){\small $4$}
|
|
\qbezier(7,0)(8.5,0.42)(10,0.85)
|
|
\qbezier(7,1.7)(8.5,1.27)(10,0.85)
|
|
\put(8.5,0.85){\line(1,0){1.5}}
|
|
\end{picture}
|
|
\end{center}
|
|
\end{bsp}
|
|
|
|
\subsection*{Was daraus folgt}
|
|
|
|
\begin{idee}{$\problem{VC} \redp \problem{Feedback Vertex Set}$: antiparallele Bögen}
|
|
Man macht aus jeder ungerichteten Kante $\{u,v\}$ zwei entgegengesetzte Pfeile
|
|
$u \to v$ und $v \to u$ -- einen gerichteten Kreis der Länge 2. Ein Knoten, der
|
|
die Kante überdeckt, zerstört genau diesen Kreis. (Ausführlich beim FVS.)
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{VC} \redp \Delta\text{-Cover}$: Kante wird Dreieck}
|
|
Man hängt an jede Kante $\{u,v\}$ einen neuen Knoten $v_e$ und bildet so das
|
|
Dreieck $\{v_e, u, v\}$. Ein Knoten, der die Kante überdeckt, trifft auch dieses
|
|
Dreieck. (Ausführlich beim $\Delta$-Cover.)
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{Feedback Vertex Set}
|
|
% ==================================================================
|
|
|
|
Das erste Problem, das nicht mehr von der Clique-Familie kommt, sondern vom
|
|
Vertex Cover. Es spielt auf \emph{gerichteten} Graphen.
|
|
|
|
\begin{defn}{Feedback Vertex Set (FVS)}
|
|
Gegeben ein \emph{gerichteter} Graph $G = (V,E)$ und eine Zahl $k$. Frage: Gibt
|
|
es eine Knotenmenge $X \subseteq V$ mit $|X| \le k$, sodass $G \setminus X$
|
|
\emph{kreisfrei} ist (keinen gerichteten Kreis mehr enthält)?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Ein Feedback Vertex Set}
|
|
Hat ein gerichteter Graph die Kreise $a \to b \to a$ und $b \to c \to b$, so
|
|
zerstört das Entfernen von $b$ beide Kreise auf einmal -- $\{b\}$ ist ein
|
|
Feedback Vertex Set der Größe 1.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Feedback Vertex Set in NP liegt}
|
|
|
|
\emph{Das Zertifikat.} Die Knotenmenge $X \subseteq V$, ein Bit pro Knoten, also
|
|
polynomiell lang.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer prüft zuerst $|X| \le k$. Dann muss er
|
|
feststellen, ob $G \setminus X$ kreisfrei ist. Dafür benutzt er einen bekannten
|
|
Algorithmus aus der Vorlesung: die \emph{topologische Sortierung}. Sie findet
|
|
genau dann eine Reihenfolge der Knoten, in der alle Kanten \glqq nach vorne\grqq{}
|
|
zeigen, wenn der Graph kreisfrei ist. Der Verifizierer akzeptiert, wenn die Größe
|
|
stimmt und die Sortierung gelingt.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Existiert ein FVS der Größe
|
|
$\le k$, so ist $G \setminus X$ kreisfrei, die topologische Sortierung gelingt,
|
|
der Verifizierer akzeptiert. Existiert keines, so bleibt bei jeder Menge $X$
|
|
dieser Größe ein Kreis übrig, die Sortierung scheitert, der Verifizierer lehnt
|
|
ab.
|
|
|
|
\emph{Die Laufzeit.} Die topologische Sortierung läuft in $O(|V| + |E|)$, die
|
|
Größenprüfung in $O(|V|)$. Damit $\problem{FVS} \in \NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{$\problem{VC} \redp \problem{FVS}$: jede Kante wird ein 2-Kreis}
|
|
Aus der ungerichteten VC-Instanz $(G, k)$ baut man einen gerichteten Graphen,
|
|
indem man jede Kante $\{u,v\}$ durch \emph{zwei antiparallele Bögen} $u \to v$
|
|
und $v \to u$ ersetzt. Die Schranke bleibt $k$.
|
|
\end{idee}
|
|
|
|
\begin{center}
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{picture}(9,1.7)(0,-0.4)
|
|
\put(0.6,0.5){\circle*{0.14}}\put(0.3,0.7){\small $u$}
|
|
\put(2.6,0.5){\circle*{0.14}}\put(2.75,0.7){\small $v$}
|
|
\put(0.6,0.5){\line(1,0){2}}
|
|
\put(1.1,-0.05){\small ungerichtete Kante in $G$}
|
|
\put(3.4,0.45){\small $\leadsto$}
|
|
\put(5.0,0.5){\circle*{0.14}}\put(4.7,0.7){\small $u$}
|
|
\put(7.0,0.5){\circle*{0.14}}\put(7.15,0.7){\small $v$}
|
|
\put(5.15,0.68){\vector(1,0){1.7}}
|
|
\put(6.85,0.32){\vector(-1,0){1.7}}
|
|
\put(5.0,-0.05){\small zwei antiparallele Bögen in $G'$}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
Warum das stimmt: Jeder gerichtete Kreis in diesem Graphen benutzt Bögen, die
|
|
aus Original-Kanten entstanden sind. Der kleinste solche Kreis ist ein 2-Kreis
|
|
$u \to v \to u$, der genau aus einer Kante $\{u,v\}$ stammt. Um ihn zu zerstören,
|
|
muss man $u$ oder $v$ entfernen -- also die Kante \glqq überdecken\grqq. Ist $C$
|
|
ein Vertex Cover, so berührt es jede Kante und zerstört damit jeden 2-Kreis; der
|
|
Graph wird kreisfrei. Ist umgekehrt $X$ ein FVS, so muss es jeden 2-Kreis
|
|
treffen, also jede Kante überdecken -- $X$ ist ein Vertex Cover.
|
|
|
|
\subsection*{Was daraus folgt}
|
|
|
|
Von \problem{Feedback Vertex Set} geht im Kurs keine weitere Reduktion aus; es
|
|
ist ein Endpunkt der Kette.
|
|
|
|
% ==================================================================
|
|
\section{$\Delta$-Cover (Dreiecksüberdeckung)}
|
|
% ==================================================================
|
|
|
|
Auch dieses Problem erbt seine Schwere vom Vertex Cover, über ein anderes Gadget.
|
|
|
|
\begin{defn}{$\Delta$-Cover}
|
|
Gegeben ein ungerichteter Graph $G = (V,E)$ und eine Zahl $k$. Ein
|
|
\emph{$\Delta$-Cover} ist eine Knotenmenge $C_\Delta \subseteq V$, die
|
|
\emph{jedes Dreieck} (jede 3-Clique) von $G$ trifft -- von jedem Dreieck liegt
|
|
also mindestens ein Knoten in $C_\Delta$. Frage: Gibt es ein $\Delta$-Cover der
|
|
Größe $\le k$?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Ein $\Delta$-Cover}
|
|
Besteht $G$ aus einem einzigen Dreieck $\{a,b,c\}$, so genügt ein beliebiger
|
|
seiner Knoten, etwa $\{a\}$, um das Dreieck zu treffen -- ein $\Delta$-Cover der
|
|
Größe 1.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum $\Delta$-Cover in NP liegt}
|
|
|
|
\emph{Das Zertifikat.} Die Knotenmenge $C_\Delta \subseteq V$, polynomiell lang.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer prüft $|C_\Delta| \le k$. Danach muss er
|
|
sicherstellen, dass jedes Dreieck getroffen wird. Dazu geht er alle
|
|
Knoten\emph{tripel} durch -- davon gibt es höchstens $\binom{|V|}{3} = O(|V|^3)$
|
|
-- und für jedes Tripel prüft er, ob es ein Dreieck bildet (alle drei Kanten
|
|
vorhanden) und, falls ja, ob mindestens einer seiner Knoten in $C_\Delta$ liegt.
|
|
Er akzeptiert, wenn die Größe stimmt und kein Dreieck ungedeckt bleibt.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Existiert ein $\Delta$-Cover
|
|
der Größe $\le k$, wird es akzeptiert. Existiert keines, bleibt bei jeder Menge
|
|
dieser Größe ein Dreieck ungetroffen, und der Verifizierer lehnt ab.
|
|
|
|
\emph{Die Laufzeit.} Es gibt $O(|V|^3)$ Tripel, jede Dreiecks- und
|
|
Trefferprüfung kostet $O(|V|)$; insgesamt $O(|V|^4)$, also polynomiell. Damit
|
|
$\Delta\text{-Cover} \in \NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{$\problem{VC} \redp \Delta\text{-Cover}$: jede Kante wird ein Dreieck}
|
|
Aus der VC-Instanz $(G,k)$ baut man $G'$: Für jede Kante $e = \{u,v\}$ fügt man
|
|
einen neuen Knoten $v_e$ hinzu und die Kanten $\{v_e, u\}$ und $\{v_e, v\}$. So
|
|
wird jede Kante zum Dreieck $\{v_e, u, v\}$ aufgeblasen. Die Schranke bleibt $k$.
|
|
\end{idee}
|
|
|
|
\begin{center}
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{picture}(9,2.2)(0,-0.4)
|
|
\put(0.6,0.4){\circle*{0.14}}\put(0.3,0.55){\small $u$}
|
|
\put(2.6,0.4){\circle*{0.14}}\put(2.75,0.55){\small $v$}
|
|
\put(0.6,0.4){\line(1,0){2}}
|
|
\put(1.0,-0.1){\small Kante $\{u,v\}$}
|
|
\put(3.4,0.4){\small $\leadsto$}
|
|
\put(5.0,0.2){\circle*{0.14}}\put(4.7,0.0){\small $u$}
|
|
\put(7.0,0.2){\circle*{0.14}}\put(7.15,0.0){\small $v$}
|
|
\put(6.0,1.5){\circle*{0.14}}\put(6.1,1.55){\small $v_e$}
|
|
\put(5.0,0.2){\line(1,0){2}}
|
|
\qbezier(5.0,0.2)(5.5,0.85)(6.0,1.5)
|
|
\qbezier(7.0,0.2)(6.5,0.85)(6.0,1.5)
|
|
\put(4.9,-0.35){\small Dreieck $\{v_e,u,v\}$}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
Warum das stimmt: Ist $C$ ein Vertex Cover, so liegt von jeder Kante $\{u,v\}$
|
|
ein Endpunkt in $C$ -- damit ist auch das zugehörige Gadget-Dreieck getroffen.
|
|
Umgekehrt kann man aus einem $\Delta$-Cover ein Vertex Cover machen.
|
|
|
|
\begin{stolper}
|
|
\textbf{Ein echter Punktabzug lauert hier.} In der Rückrichtung darf man
|
|
\emph{nicht} behaupten, jedes Dreieck von $G'$ habe die Gadget-Form
|
|
$\{v_e, u, v\}$. Denn $G'$ enthält alle Kanten von $G$ weiter -- also \emph{erbt}
|
|
$G'$ auch jedes Dreieck, das $G$ selbst schon hatte (drei paarweise verbundene
|
|
Original-Knoten). Diese geerbten Dreiecke muss der Beweis mitbehandeln: Auch sie
|
|
werden von einem Vertex Cover getroffen, weil ihre Kanten überdeckt sind. Wer
|
|
diesen Fall vergisst, verliert Punkte.
|
|
\end{stolper}
|
|
|
|
\subsection*{Was daraus folgt}
|
|
|
|
Von \problem{$\Delta$-Cover} geht im Kurs keine weitere Reduktion aus.
|
|
|
|
% ==================================================================
|
|
\section{$k$-Color (Färbung)}
|
|
% ==================================================================
|
|
|
|
Ein Problem, das nicht von der Clique-Familie, sondern direkt von \problem{3-SAT}
|
|
kommt.
|
|
|
|
\begin{defn}{$k$-Color}
|
|
Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Eine \emph{$k$-Färbung} gibt
|
|
jedem Knoten eine von $k$ Farben, sodass keine Kante zwei gleichfarbige Enden
|
|
verbindet. Frage: Ist $G$ mit $k$ Farben färbbar?
|
|
\end{defn}
|
|
|
|
Man denkt an eine Landkarte, deren Länder so gefärbt werden, dass keine zwei
|
|
Nachbarn dieselbe Farbe tragen. Schon $k = 3$ ist NP-vollständig.
|
|
|
|
\begin{bsp}{Eine gültige 3-Färbung}
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{center}
|
|
\begin{picture}(4.5,2.6)(-0.3,-0.3)
|
|
\put(0,0){\circle*{0.18}}\put(-0.35,-0.05){\small $r$}
|
|
\put(2,0){\circle*{0.18}}\put(2.1,-0.05){\small $g$}
|
|
\put(1,1.7){\circle*{0.18}}\put(1.1,1.7){\small $b$}
|
|
\put(3.4,0.85){\circle*{0.18}}\put(3.5,0.8){\small $r$}
|
|
\put(0,0){\line(1,0){2}}
|
|
\qbezier(0,0)(0.5,0.85)(1,1.7)
|
|
\qbezier(2,0)(1.5,0.85)(1,1.7)
|
|
\qbezier(2,0)(2.7,0.42)(3.4,0.85)
|
|
\end{picture}
|
|
\end{center}
|
|
Drei Farben $r,g,b$. Das Dreieck braucht alle drei; der rechte Knoten darf
|
|
wieder $r$ sein, weil er nur mit $g$ benachbart ist.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum $k$-Color in NP liegt}
|
|
|
|
\emph{Das Zertifikat.} Die Färbung selbst -- eine Farbe pro Knoten, also eine
|
|
Zahl aus $\{1,\dots,k\}$ je Knoten. Das ist polynomiell lang.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer geht jede Kante $\{u,v\} \in E$ durch und
|
|
prüft, ob ihre beiden Enden verschiedene Farben haben. Er akzeptiert, wenn keine
|
|
Kante gleichfarbig ist.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Ist $G$ färbbar, wird eine
|
|
gültige Färbung akzeptiert. Ist $G$ nicht färbbar, hat jede vorgelegte Färbung
|
|
eine gleichfarbige Kante, und der Verifizierer lehnt ab.
|
|
|
|
\emph{Die Laufzeit.} Ein Durchlauf durch alle Kanten, also $O(|E|)$. Damit
|
|
$\problem{$k$-Color} \in \NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{$\problem{3-SAT} \redp \problem{$k$-Color}$: Farben als Wahrheitswerte}
|
|
Man baut pro Variable die Knoten $x_i, \bar x_i, v_i$, einen Knoten $F_j$ pro
|
|
Klausel und ein Zentrum $z$. Die Knoten $v_1, \dots, v_n, z$ bilden eine Clique
|
|
und erzwingen genau $n+1$ Farben; man kann $z$ die Farbe \glqq neutral\grqq{}
|
|
geben und jedem $v_i$ eine eigene. Für jedes Paar $x_i, \bar x_i$ (verbunden)
|
|
bleibt dann nur die Wahl zwischen \glqq wahr\grqq{} und \glqq falsch\grqq{} --
|
|
das kodiert die Belegung. Jeder Klauselknoten $F_j$ ist mit genau den Literalen
|
|
verbunden, die \emph{nicht} in seiner Klausel stehen; er lässt sich genau dann
|
|
korrekt färben, wenn ein Literal seiner Klausel wahr ist. Der Graph ist also mit
|
|
$n+1$ Farben färbbar genau dann, wenn die Formel erfüllbar ist.
|
|
\end{idee}
|
|
|
|
\subsection*{Was daraus folgt}
|
|
|
|
Von \problem{$k$-Color} geht im Kurs keine weitere Härte-Reduktion aus; es taucht
|
|
später nur bei den ETH-Schranken wieder auf.
|
|
|
|
% ==================================================================
|
|
\section{Hamiltonkreis}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{Hamiltonkreis (HK)}
|
|
Gegeben ein Graph $G = (V,E)$. Frage: Gibt es einen Rundweg, der \emph{jeden}
|
|
Knoten \emph{genau einmal} besucht und am Start wieder ankommt? (Die Aussage
|
|
gilt für gerichtete wie ungerichtete Graphen.)
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Ein Hamiltonkreis}
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{center}
|
|
\begin{picture}(4,2.8)(-0.4,-0.3)
|
|
\put(0,0){\circle*{0.15}}
|
|
\put(3,0){\circle*{0.15}}
|
|
\put(3,2){\circle*{0.15}}
|
|
\put(0,2){\circle*{0.15}}
|
|
\put(1.5,2.6){\circle*{0.15}}
|
|
\linethickness{1.2pt}
|
|
\put(0,0){\line(1,0){3}}
|
|
\put(3,0){\line(0,1){2}}
|
|
\qbezier(3,2)(2.25,2.3)(1.5,2.6)
|
|
\qbezier(1.5,2.6)(0.75,2.3)(0,2)
|
|
\put(0,2){\line(0,-1){2}}
|
|
\end{picture}
|
|
\end{center}
|
|
Der fette Weg besucht alle fünf Knoten genau einmal und schließt sich.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Hamiltonkreis in NP liegt}
|
|
|
|
\emph{Das Zertifikat.} Die Besuchsreihenfolge -- eine Permutation der Knoten, die
|
|
den behaupteten Rundweg angibt. Sie ist genau $|V|$ Einträge lang, also
|
|
polynomiell.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer prüft zweierlei: erstens, dass jeder Knoten
|
|
in der Reihenfolge genau einmal vorkommt; zweitens, dass zwischen je zwei
|
|
aufeinanderfolgenden Knoten -- und zwischen dem letzten und dem ersten -- wirklich
|
|
eine Kante existiert. Er akzeptiert, wenn beides zutrifft.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Gibt es einen Hamiltonkreis, so
|
|
ist seine Reihenfolge ein akzeptiertes Zertifikat. Wird umgekehrt eine
|
|
Reihenfolge akzeptiert, so besucht sie jeden Knoten einmal und benutzt nur echte
|
|
Kanten -- sie ist also ein Hamiltonkreis.
|
|
|
|
\emph{Die Laufzeit.} Die Verschiedenheit prüft man in $O(|V|)$ (etwa durch
|
|
Abhaken), die Kantenbedingung in $O(|V|)$ Nachschlägen. Insgesamt $O(|V|+|E|)$.
|
|
Damit $\problem{HK} \in \NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{$\problem{3-SAT}' \redp \problem{HK}$: A- und B-Komponenten}
|
|
Man baut für die Variante mit genau drei Literalen pro Klausel zwei Sorten von
|
|
Gadgets. Die \glqq A-Komponenten\grqq{} (Leitergraphen) haben genau zwei
|
|
mögliche Durchlaufrichtungen und kodieren so die Setzung einer Variablen auf
|
|
wahr oder falsch. Die \glqq B-Komponenten\grqq{} -- eine pro Klausel -- sind so
|
|
gebaut, dass sie sich für \emph{jede nichtleere} Auswahl ihrer Kanten
|
|
durchlaufen lassen, aber \emph{nicht} für die leere. Die leere Auswahl entspricht
|
|
\glqq alle Literale dieser Klausel falsch\grqq. Ein Hamiltonkreis existiert also
|
|
genau dann, wenn jede Klausel mindestens ein wahres Literal hat -- wenn die
|
|
Formel erfüllbar ist.
|
|
\end{idee}
|
|
|
|
\subsection*{Was daraus folgt}
|
|
|
|
\begin{idee}{$\problem{HK} \redp \problem{TSP}$: Kanten als Distanzen}
|
|
Man macht aus dem Graphen eine TSP-Instanz: Jede echte Kante bekommt Distanz 1,
|
|
jede fehlende Kante die große Distanz $|V|+1$, und die Schranke ist $L = |V|$.
|
|
Eine Rundreise der Länge $\le |V|$ kann nur echte Kanten benutzen -- sie ist also
|
|
ein Hamiltonkreis. (Ausführlich beim TSP.)
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{HamiltonianCycle} \redp \problem{HamiltonianPath}$: Knoten aufspalten}
|
|
Um aus der Kreis- eine Pfad-Frage zu machen, verdoppelt man einen Knoten $v$ zu
|
|
$v$ und $v^*$ (mit gleicher Nachbarschaft) und hängt zwei neue Grad-1-Knoten $s$
|
|
(an $v$) und $t$ (an $v^*$) als Pfadenden an. Ein Hamiltonpfad von $s$ nach $t$
|
|
entspricht genau einem Hamiltonkreis durch $v$. (Die Gegenrichtung
|
|
\problem{Path} $\redp$ \problem{Cycle} schließt den Pfad über einen universellen
|
|
Knoten zum Kreis.)
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{TSP (Traveling Salesman)}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{TSP, Entscheidungsvariante}
|
|
Gegeben Städte mit paarweisen Distanzen $d(i,j)$ und eine Schranke $L$. Frage:
|
|
Gibt es eine Rundreise durch alle Städte (jede genau einmal) mit Gesamtlänge
|
|
$\le L$?
|
|
\end{defn}
|
|
|
|
Der Unterschied zum Hamiltonkreis: Dort fragt man nur, \emph{ob} es eine
|
|
Rundreise gibt; hier gibt es Distanzen und eine Längengrenze. Als
|
|
Optimierungsproblem -- \glqq finde die kürzeste Rundreise\grqq{} -- ist TSP der
|
|
Star des Approximationskapitels.
|
|
|
|
\begin{bsp}{Eine kurze Rundreise}
|
|
Vier Städte auf einem Quadrat, jede Seite Distanz 1, die Diagonalen Distanz 2.
|
|
Die Rundreise entlang der vier Seiten hat Länge 4 und ist optimal; sie
|
|
unterschreitet jede Schranke $L \ge 4$.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum TSP in NP liegt}
|
|
|
|
\emph{Das Zertifikat.} Die Reihenfolge der Städte -- eine Permutation, die die
|
|
Rundreise angibt. Polynomiell lang.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer addiert die Distanzen entlang der Rundreise
|
|
(inklusive der Rückkehr zum Start) und prüft, ob die Summe $\le L$ ist; außerdem
|
|
prüft er, dass jede Stadt genau einmal vorkommt. Er akzeptiert bei beidem.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Gibt es eine Rundreise der
|
|
Länge $\le L$, wird ihre Reihenfolge akzeptiert. Gibt es keine, überschreitet
|
|
jede vorgelegte Reihenfolge die Schranke, und der Verifizierer lehnt ab.
|
|
|
|
\emph{Die Laufzeit.} Das Aufsummieren der $n$ Distanzen kostet $O(n)$. Damit
|
|
liegt die Entscheidungsvariante von TSP in $\NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{$\problem{HK} \redp \problem{TSP}$: Kanten Distanz 1, Nicht-Kanten teuer}
|
|
Aus einem Graphen $G$ für den Hamiltonkreis baut man die Städte $=$ Knoten und
|
|
setzt $d(u,v) = 1$, wenn $\{u,v\}$ eine Kante von $G$ ist, sonst $d(u,v) = |V|+1$.
|
|
Die Schranke ist $L = |V|$. Eine Rundreise der Länge $\le |V|$ besucht $|V|$
|
|
Städte und darf keine teure Nicht-Kante benutzen -- sie besteht also nur aus
|
|
echten Kanten und ist ein Hamiltonkreis. Umgekehrt hat jeder Hamiltonkreis genau
|
|
die Länge $|V|$. TSP bleibt sogar dann NP-vollständig, wenn man symmetrische
|
|
Distanzen mit Dreiecksungleichung verlangt.
|
|
\end{idee}
|
|
|
|
\subsection*{Was daraus folgt}
|
|
|
|
Von TSP geht keine Härte-Reduktion aus. Stattdessen ist es das zentrale
|
|
Optimierungsproblem für die Approximation (Teil D): $\Delta$TSP$_1$ und
|
|
Christofides.
|
|
|
|
% ==================================================================
|
|
\section{3-dimensionales Matching}
|
|
% ==================================================================
|
|
|
|
Ab hier verlassen wir die Graphen und arbeiten mit Mengen und Zahlen. Den Anfang
|
|
macht ein Problem, das direkt von \problem{SAT} kommt.
|
|
|
|
\begin{defn}{3-dimensionales Matching (3-DM)}
|
|
Gegeben drei gleich große Mengen $U, V, W$ und eine Liste $T$ von \emph{Tripeln},
|
|
wobei jedes Tripel je ein Element aus $U$, aus $V$ und aus $W$ enthält. Frage:
|
|
Gibt es eine Auswahl von Tripeln, die jedes Element aus $U$, $V$ und $W$
|
|
\emph{genau einmal} trifft?
|
|
\end{defn}
|
|
|
|
Man denkt an eine perfekte Zuordnung zu dritt: Jede Person aus $U$ soll mit genau
|
|
einer Aufgabe aus $V$ und genau einem Termin aus $W$ zusammengebracht werden, und
|
|
die erlaubten Kombinationen stehen in $T$.
|
|
|
|
\begin{bsp}{Ein 3-dimensionales Matching}
|
|
$U = \{a_1, a_2\}$, $V = \{b_1, b_2\}$, $W = \{c_1, c_2\}$ und die Tripel
|
|
$(a_1,b_1,c_1)$, $(a_2,b_2,c_2)$, $(a_1,b_2,c_2)$. Die Auswahl der ersten beiden
|
|
Tripel trifft jedes der sechs Elemente genau einmal -- ein gültiges Matching.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum 3-DM in NP liegt}
|
|
|
|
\emph{Das Zertifikat.} Die ausgewählte Menge $M \subseteq T$ von Tripeln.
|
|
Höchstens $|U|$ Tripel, also polynomiell lang.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer prüft, dass $M$ genau $|U|$ Tripel enthält
|
|
und dass in $M$ keine zwei Tripel in irgendeiner ihrer drei Komponenten
|
|
übereinstimmen -- dass also jedes Element aus $U$, $V$, $W$ höchstens (und damit
|
|
genau) einmal vorkommt. Dazu zählt er für jedes Element seine Vorkommen.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Existiert ein Matching, wird es
|
|
akzeptiert. Existiert keines, kommt bei jeder Auswahl ein Element doppelt oder
|
|
gar nicht vor, und der Verifizierer lehnt ab.
|
|
|
|
\emph{Die Laufzeit.} Das Zählen der Vorkommen über alle Tripel läuft in $O(|T|)$.
|
|
Damit $\problem{3-DM} \in \NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{$\problem{SAT} \redp \problem{3-DM}$: Zahnrad, Klauseln, Garbage Collection}
|
|
Pro Variable baut man eine \glqq Zahnrad\grqq-Struktur aus Tripeln, die
|
|
kreisförmig angeordnet sind. Ein perfektes Matching kann dieses Zahnrad nur auf
|
|
zwei Arten abdecken -- die eine steht für \glqq Variable wahr\grqq, die andere
|
|
für \glqq falsch\grqq. Pro Klausel gibt es ein Knotenpaar $v_j, w_j$, dessen
|
|
Tripel nur dann matchbar sind, wenn ein erfüllendes Literal der Klausel
|
|
\glqq frei\grqq{} geblieben ist. Weil dabei nicht alle Literale verbraucht
|
|
werden, räumt eine \glqq Garbage Collection\grqq{} aus zusätzlichen Tripeln die
|
|
übrig gebliebenen Literale weg, damit am Ende doch jedes Element genau einmal
|
|
getroffen ist.
|
|
\end{idee}
|
|
|
|
\subsection*{Was daraus folgt}
|
|
|
|
\begin{idee}{$\problem{3-DM} \redp \problem{3-Exact Cover}$: Tripel als 3er-Mengen}
|
|
Man muss gar nichts umbauen: Fasst man jedes Tripel $(u,v,w)$ als die
|
|
dreielementige Menge $\{u,v,w\}$ über dem Universum $U \cup V \cup W$ auf, so wird
|
|
aus \glqq jedes Element genau einmal treffen\grqq{} wörtlich \glqq das Universum
|
|
exakt überdecken\grqq. Jede 3-DM-Instanz ist also direkt eine 3-EC-Instanz.
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{3-Exact Cover}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{3-Exact Cover (3-EC)}
|
|
Gegeben ein Universum $U$ mit $|U| = 3m$ und eine Familie $S_1, \dots, S_n$ von
|
|
\emph{dreielementigen} Teilmengen von $U$. Frage: Gibt es eine Auswahl von
|
|
Mengen, die $U$ \emph{exakt} überdeckt -- disjunkt und lückenlos, sodass jedes
|
|
Element in genau einer gewählten Menge liegt?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Eine exakte Überdeckung}
|
|
$U = \{1,2,3,4,5,6\}$ und die Mengen $S_1 = \{1,2,3\}$, $S_2 = \{4,5,6\}$,
|
|
$S_3 = \{1,2,4\}$. Die Auswahl $\{S_1, S_2\}$ überdeckt jedes Element genau
|
|
einmal. Die Auswahl $\{S_1, S_3\}$ dagegen nicht: 1 und 2 lägen doppelt, 5 und 6
|
|
gar nicht.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum 3-EC in NP liegt}
|
|
|
|
\emph{Das Zertifikat.} Die ausgewählte Teilfamilie von Mengen. Da eine exakte
|
|
Überdeckung genau $m$ Mengen braucht (jede deckt drei der $3m$ Elemente), ist sie
|
|
polynomiell lang.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer markiert für jede gewählte Menge ihre drei
|
|
Elemente und kontrolliert, dass am Ende jedes Element aus $U$ \emph{genau einmal}
|
|
markiert wurde -- keines doppelt, keines gar nicht.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Existiert eine exakte
|
|
Überdeckung, wird sie akzeptiert. Existiert keine, bleibt bei jeder Auswahl ein
|
|
Element unbedeckt oder wird doppelt bedeckt, und der Verifizierer lehnt ab.
|
|
|
|
\emph{Die Laufzeit.} Das Markieren und Kontrollieren läuft in $O(|U| +
|
|
\text{Anzahl gewählter Mengen})$, also polynomiell. Damit $\problem{3-EC} \in
|
|
\NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{$\problem{3-DM} \redp \problem{3-EC}$: dieselbe Instanz, anders gelesen}
|
|
Man muss an der Instanz gar nichts umbauen -- man liest sie nur anders. Ein
|
|
Tripel $(u,v,w)$ aus der 3-DM-Instanz fasst man als die dreielementige Menge
|
|
$\{u,v,w\}$ auf, und als Universum nimmt man $U \cup V \cup W$.
|
|
\end{idee}
|
|
|
|
Warum das genau passt: Die 3-DM-Forderung \glqq jedes Element aus $U$, $V$ und
|
|
$W$ wird von den gewählten Tripeln genau einmal getroffen\grqq{} ist wörtlich die
|
|
3-EC-Forderung \glqq jedes Element des Universums liegt in genau einer gewählten
|
|
Menge\grqq. Eine Auswahl von Tripeln ist also genau dann ein 3-dimensionales
|
|
Matching, wenn dieselbe Auswahl, als Mengenfamilie gelesen, eine exakte
|
|
Überdeckung ist. Die Umformung kostet keine Rechenzeit über das Umschreiben
|
|
hinaus, ist also polynomiell. Da \problem{3-DM} NP-vollständig und
|
|
$\problem{3-EC} \in \NP$ ist, ist auch \problem{3-EC} NP-vollständig.
|
|
|
|
\subsection*{Was daraus folgt}
|
|
|
|
\begin{idee}{$\problem{3-EC} \redp \problem{SubSet Sum}$: Mengen werden Ziffern}
|
|
Man schreibt jede Menge als Bitvektor über dem Universum und liest ihn als Zahl
|
|
zur Basis $n+1$. Das Ziel ist die Zahl \glqq überall 1\grqq. Weil bei so großer
|
|
Basis nie ein Übertrag entsteht, trifft eine Auswahl die Zielsumme genau dann,
|
|
wenn sie jede Stelle genau einmal überdeckt -- eine exakte Überdeckung.
|
|
(Ausführlich mit Zahlen beim SubSet Sum.)
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{SubSet Sum}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{SubSet Sum}
|
|
Gegeben ganze Zahlen $c_1, \dots, c_n$ und ein Zielwert $K$. Frage: Gibt es eine
|
|
Teilmenge dieser Zahlen mit Summe \emph{genau} $K$?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{SubSet Sum ausprobiert}
|
|
Zahlen $3, 7, 8, 4$ und Ziel $K = 15$. Es gilt $3 + 4 + 8 = 15$ -- die Teilmenge
|
|
$\{3,4,8\}$ trifft das Ziel genau. Die Teilmenge $\{7,4\}$ ergäbe nur $11$.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum SubSet Sum in NP liegt}
|
|
|
|
\emph{Das Zertifikat.} Die Teilmenge $S \subseteq \{1,\dots,n\}$, ein Bit pro
|
|
Zahl, also polynomiell lang.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer addiert die Zahlen $c_j$ für $j \in S$ und
|
|
vergleicht die Summe mit $K$. Er akzeptiert bei Gleichheit.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Existiert eine Teilmenge mit
|
|
Summe $K$, wird sie akzeptiert. Existiert keine, trifft keine Teilmenge den
|
|
Zielwert, und der Verifizierer lehnt ab.
|
|
|
|
\emph{Die Laufzeit.} Es sind höchstens $n$ Additionen, also $O(n)$
|
|
Arithmetikschritte. Damit $\problem{SubSet Sum} \in \NP$. (Beachte: \glqq $O(n)$
|
|
Additionen\grqq{} zählt Rechenschritte auf großen Zahlen; die Schwere des
|
|
Problems steckt nicht in der Prüfung, sondern im \emph{Finden} der richtigen
|
|
Teilmenge unter $2^n$ Möglichkeiten.)
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{$\problem{3-EC} \redp \problem{SubSet Sum}$: Ziffern zur Basis $n+1$}
|
|
Man schreibt jede Menge $S_j$ als Bitvektor über dem Universum (eine 1 an jeder
|
|
Stelle, die $S_j$ enthält) und liest diesen Bitvektor als Zahl zur \emph{Basis
|
|
$n+1$}, wobei $n$ die Anzahl der Mengen ist. Das Ziel $K$ ist die Zahl zum
|
|
Bitvektor \glqq überall 1\grqq.
|
|
\end{idee}
|
|
|
|
Warum die krumme Basis $n+1$? Damit beim Addieren \emph{kein Übertrag} entsteht.
|
|
Es gibt nur $n$ Mengen, an jeder Stelle also höchstens $n$ Einsen -- das bleibt
|
|
unter $n+1$, keine Stelle läuft über. Ohne Übertrag zählt jede Stelle für sich,
|
|
und \glqq Summe trifft das Ziel\grqq{} bedeutet genau \glqq jede Stelle wird genau
|
|
einmal überdeckt\grqq.
|
|
|
|
\begin{bsp}{Die Ziffern-Reduktion mit Zahlen}
|
|
$U = \{1,\dots,6\}$, Mengen $S_1 = \{1,2,3\}$, $S_2 = \{4,5,6\}$,
|
|
$S_3 = \{1,2,4\}$, $S_4 = \{3,5,6\}$; also $n = 4$, Basis 5.
|
|
\begin{center}\small
|
|
\begin{tabular}{lll}
|
|
\toprule
|
|
Menge & Bitvektor & Zahl zur Basis 5\\
|
|
\midrule
|
|
$S_1=\{1,2,3\}$ & $111000$ & $5^0+5^1+5^2 = 31$\\
|
|
$S_2=\{4,5,6\}$ & $000111$ & $5^3+5^4+5^5 = 3875$\\
|
|
$S_3=\{1,2,4\}$ & $110100$ & $5^0+5^1+5^3 = 131$\\
|
|
$S_4=\{3,5,6\}$ & $001011$ & $5^2+5^4+5^5 = 3775$\\
|
|
\midrule
|
|
Ziel $K$ & $111111$ & $5^0+\dots+5^5 = 3906$\\
|
|
\bottomrule
|
|
\end{tabular}
|
|
\end{center}
|
|
Es gilt $S_1 + S_2 = 31 + 3875 = 3906 = K$, und tatsächlich ist $\{S_1,S_2\}$
|
|
eine exakte Überdeckung. Ebenso $S_3 + S_4 = 3906$ mit exakter Überdeckung
|
|
$\{S_3,S_4\}$.
|
|
\end{bsp}
|
|
|
|
Es gibt noch eine \emph{zweite}, direktere Reduktion auf \problem{SubSet Sum} --
|
|
diesmal von \problem{3-SAT} aus. Sie ist für die Praxis unwichtiger, aber für die
|
|
unteren Schranken in Teil C zentral, weil sie besonders \emph{wenige} Zahlen
|
|
erzeugt.
|
|
|
|
\begin{idee}{$\problem{3-SAT} \redp \problem{SubSet Sum}$: Ziffern zur Basis 10}
|
|
Man kodiert jede Zahl als Dezimalzahl mit $n + m$ Ziffern -- eine Stelle pro
|
|
Variable und eine pro Klausel. Der Aufbau hat drei Bausteine:
|
|
\begin{itemize}
|
|
\item \emph{Zwei Items pro Variable.} Für jede Variable $x_i$ gibt es zwei
|
|
Zahlen: eine steht für \glqq $x_i$ wahr\grqq, die andere für \glqq $x_i$
|
|
falsch\grqq. Beide haben an der Variablen-Stelle $i$ eine 1 (genau eine der
|
|
beiden wird gewählt) und an den Klausel-Stellen eine 1, wo das jeweilige Literal
|
|
vorkommt.
|
|
\item \emph{Der Zielwert} verlangt an jeder Variablen-Stelle genau eine 1 (also
|
|
eine gültige Belegung) und an jeder Klausel-Stelle den Wert 3.
|
|
\item \emph{Dummy-Items pro Klausel.} Da eine erfüllte Klausel ein bis drei wahre
|
|
Literale haben kann, an der Klausel-Stelle aber genau die 3 stehen muss, füllt
|
|
man mit zwei Füll-Zahlen (\glqq Dummies\grqq) pro Klausel den Rest auf 3 auf.
|
|
\end{itemize}
|
|
\end{idee}
|
|
|
|
Der Trick der großen Ziffernabstände sorgt wieder dafür, dass es keine Überträge
|
|
gibt, sodass jede Stelle für sich zählt. Entscheidend für Teil C: Diese
|
|
Reduktion erzeugt nur $|A| = 2n + 2m = O(m)$ Zahlen. Deshalb liefert sie sogar
|
|
eine $2^{o(n)}$-untere Schranke für \problem{SubSet Sum} und \problem{Partition}
|
|
-- viel schärfer als die Kette über 3-EC.
|
|
|
|
\subsection*{Was daraus folgt}
|
|
|
|
\begin{idee}{$\problem{SubSet Sum} \redp \problem{Partition}$: zwei Zusatzzahlen}
|
|
Man ergänzt die Zahlen um zwei geschickt gewählte Werte, sodass die
|
|
\glqq halbe Gesamtsumme\grqq-Frage von \problem{Partition} genau die
|
|
Zielsummen-Frage von SubSet Sum wird. (Ausführlich bei Partition.)
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{SubSet Sum} \redp \problem{Knapsack}$: Spezialfall}
|
|
Setzt man beim Rucksack für jeden Gegenstand Gewicht gleich Profit ($w_j = p_j =
|
|
c_j$) und Kapazität gleich Zielprofit ($B = P = K$), so fragt der Rucksack genau,
|
|
ob eine Teilmenge die Summe $K$ trifft. SubSet Sum ist also ein Spezialfall von
|
|
Knapsack.
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{SubSet Sum} \redp \problem{SubSet Sum Cardinality}$: Padding und Shift}
|
|
Die Variante verlangt zusätzlich, dass die Teilmenge genau $n$ Zahlen enthält.
|
|
Man erhöht jede Originalzahl um 1 (\glqq Shift\grqq) und fügt $n$ Einsen als
|
|
\glqq Padding\grqq{} hinzu; das Ziel wird $K + n$. Die Einsen füllen die
|
|
geforderte Anzahl auf, ohne die eigentliche Summe zu stören.
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{Partition}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{Partition}
|
|
Gegeben ganze Zahlen $c_1, \dots, c_n$. Frage: Gibt es eine Teilmenge, deren
|
|
Summe \emph{genau die Hälfte} der Gesamtsumme beträgt -- die die Zahlen also in
|
|
zwei gleich schwere Hälften teilt?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Eine Partition}
|
|
Zahlen $1, 5, 6, 2$ mit Gesamtsumme $14$, Hälfte also $7$. Die Teilmenge
|
|
$\{1, 6\}$ hat Summe $7$, der Rest $\{5, 2\}$ ebenfalls -- eine gültige
|
|
Zweiteilung.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Partition in NP liegt}
|
|
|
|
\emph{Das Zertifikat.} Die Teilmenge $S$, ein Bit pro Zahl, polynomiell lang.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer berechnet die Gesamtsumme $N = \sum_j c_j$
|
|
und die Teilsumme $\sum_{j \in S} c_j$ und prüft, ob die Teilsumme gleich $N/2$
|
|
ist. Er akzeptiert bei Gleichheit.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Existiert eine hälftige
|
|
Teilmenge, wird sie akzeptiert. Existiert keine, trifft keine Teilmenge genau die
|
|
Hälfte, und der Verifizierer lehnt ab.
|
|
|
|
\emph{Die Laufzeit.} Zwei Summen über höchstens $n$ Zahlen, also $O(n)$. Damit
|
|
$\problem{Partition} \in \NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{$\problem{SubSet Sum} \redp \problem{Partition}$: zwei Zusatzzahlen}
|
|
Aus den Zahlen $c_1, \dots, c_n$ mit Ziel $K$ und $N = (\sum_j c_j) + 1$ bildet
|
|
man eine neue Zahlenmenge: alle $c_j$ \emph{plus} zwei Zusatzzahlen
|
|
$c_{n+1} = N - K$ und $c_{n+2} = K + 1$.
|
|
\end{idee}
|
|
|
|
Warum das stimmt: Die Gesamtsumme der neuen Menge ist $\sum c_j + (N-K) + (K+1) =
|
|
2N$, ihre Hälfte also $N$. Die beiden Zusatzzahlen summieren sich zu
|
|
$(N-K)+(K+1) = N+1$ -- das ist schon \emph{mehr} als eine Hälfte, also können sie
|
|
nie beide in derselben Hälfte liegen; sie werden immer getrennt. Trifft nun eine
|
|
Teilmenge der Originalzahlen den Wert $K$, so ergänzt man sie um $c_{n+1} = N-K$
|
|
und erhält die Summe $N$ -- eine Halbierung. Umgekehrt enthält jede Halbierung
|
|
genau eine Zusatzzahl; zieht man sie ab, bleibt eine Original-Teilmenge mit Summe
|
|
$K$.
|
|
|
|
\begin{bsp}{Die Zusatzzahlen mit Zahlen}
|
|
Zahlen $3, 5, 8, 4$ (Summe $20$), Ziel $K = 12$. Dann $N = 21$, die Zusatzzahlen
|
|
sind $N-K = 9$ und $K+1 = 13$. Neue Menge $\{3,5,8,4,9,13\}$, Gesamtsumme $42$,
|
|
Hälfte $21$. Die Original-Teilmenge $\{8,4\}$ trifft $K = 12$; ergänzt um $9$
|
|
ergibt $\{8,4,9\}$ die Summe $21$ -- eine gültige Halbierung.
|
|
\end{bsp}
|
|
|
|
\subsection*{Was daraus folgt}
|
|
|
|
\begin{idee}{$\problem{Partition} \redp P2\|\Cmax$: Zahlen als Jobs}
|
|
Man nimmt die Partition-Zahlen als Job-Laufzeiten und stellt zwei Maschinen
|
|
bereit. Beide Maschinen exakt gleich auszulasten heißt, die Zahlen in zwei gleich
|
|
schwere Hälften zu teilen. (Ausführlich beim Scheduling.)
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{Knapsack (Rucksackproblem)}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{Knapsack (Rucksack)}
|
|
Gegeben $n$ Gegenstände, jeder mit Gewicht $w_i$ und Profit $p_i$, eine Kapazität
|
|
$B$ und ein Zielprofit $P$. Frage: Gibt es eine Auswahl von Gegenständen mit
|
|
Gesamtgewicht $\le B$ und Gesamtprofit $\ge P$?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Eine Rucksack-Füllung}
|
|
Drei Gegenstände $(w,p) = (3,4), (4,5), (5,6)$, Kapazität $B = 7$, Zielprofit
|
|
$P = 9$. Die ersten beiden zusammen haben Gewicht $3+4 = 7 \le B$ und Profit
|
|
$4+5 = 9 \ge P$ -- sie erfüllen beide Schranken.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Knapsack in NP liegt}
|
|
|
|
\emph{Das Zertifikat.} Die Auswahl $S \subseteq \{1,\dots,n\}$, ein Bit pro
|
|
Gegenstand.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer berechnet $\sum_{i \in S} w_i$ und
|
|
$\sum_{i \in S} p_i$ und prüft die beiden Schranken $\sum_{i \in S} w_i \le B$
|
|
und $\sum_{i \in S} p_i \ge P$. Er akzeptiert, wenn beide erfüllt sind.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Existiert eine zulässige
|
|
Auswahl mit genügend Profit, wird sie akzeptiert. Existiert keine, verletzt jede
|
|
Auswahl eine der beiden Schranken, und der Verifizierer lehnt ab.
|
|
|
|
\emph{Die Laufzeit.} Zwei Summen und zwei Vergleiche über $n$ Gegenstände, also
|
|
$O(n)$. Damit $\problem{Knapsack} \in \NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{$\problem{SubSet Sum} \redp \problem{Knapsack}$: Gewicht gleich Profit}
|
|
Aus einer SubSet-Sum-Instanz $(c_1,\dots,c_n, K)$ macht man eine
|
|
Knapsack-Instanz, indem man für jeden Gegenstand $w_i = p_i = c_i$ setzt und
|
|
$B = P = K$ wählt. Dann verlangt der Rucksack eine Auswahl mit Gewicht $\le K$
|
|
\emph{und} Profit $\ge K$ -- bei $w_i = p_i$ heißt das Summe genau $K$. SubSet Sum
|
|
ist also der Spezialfall $w_i = p_i$ des Rucksacks.
|
|
\end{idee}
|
|
|
|
\subsection*{Was daraus folgt}
|
|
|
|
Von \problem{Knapsack} geht keine Härte-Reduktion aus. Als Optimierungsproblem
|
|
ist es in Teil D wichtig (Greedy, Modified Greedy, Sahni, FPTAS).
|
|
|
|
% ==================================================================
|
|
\section{$P\|\Cmax$ (Scheduling)}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{$P\|\Cmax$ (Scheduling auf identischen Maschinen)}
|
|
Gegeben $n$ Jobs mit Laufzeiten $p_1, \dots, p_n$ und $m$ gleiche Maschinen.
|
|
Verteile die Jobs so auf die Maschinen, dass die \emph{höchste} Maschinenlast --
|
|
der \emph{Makespan} $\Cmax$ -- möglichst klein wird. (Entscheidungsvariante:
|
|
Gibt es eine Verteilung mit Makespan $\le T$?)
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Ein Schedule}
|
|
Drei Jobs der Größen $2, 3, 3$ auf zwei Maschinen. Legt man den 2er und einen 3er
|
|
auf $M_1$ (Last 5) und den anderen 3er auf $M_2$ (Last 3), so ist der Makespan 5.
|
|
Besser: die beiden 3er auf getrennte Maschinen und den 2er dazu -- Makespan 5
|
|
bleibt, denn eine Maschine trägt mindestens $8/2 = 4$ und der 2er passt nicht
|
|
ohne einen 3er. Optimal ist hier Makespan 5.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum $P\|\Cmax$ in NP liegt}
|
|
|
|
\emph{Das Zertifikat.} Die Zuordnung \glqq welcher Job läuft auf welcher
|
|
Maschine\grqq{} -- also eine Aufteilung der Jobs in $m$ Gruppen.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer summiert für jede Maschine die Laufzeiten
|
|
der ihr zugeordneten Jobs, nimmt das Maximum über alle Maschinen (den Makespan)
|
|
und prüft, ob es $\le T$ ist. Er akzeptiert bei Erfolg.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Existiert eine Verteilung mit
|
|
Makespan $\le T$, wird sie akzeptiert. Existiert keine, überschreitet jede
|
|
Verteilung die Schranke, und der Verifizierer lehnt ab.
|
|
|
|
\emph{Die Laufzeit.} Das Aufsummieren geht jeden Job einmal an, also $O(n)$.
|
|
Damit liegt die Entscheidungsvariante in $\NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{$\problem{Partition} \redp P2\|\Cmax$: gleich lange Hälften}
|
|
Man nimmt die Partition-Zahlen $c_1, \dots, c_n$ als Job-Laufzeiten und zwei
|
|
Maschinen. Beide Maschinen tragen zusammen die Gesamtlast $N = \sum c_j$. Ein
|
|
Makespan von genau $N/2$ ist nur möglich, wenn beide Maschinen exakt gleich
|
|
ausgelastet sind -- also wenn sich die Zahlen in zwei gleich schwere Hälften
|
|
teilen lassen. Damit ist $P\|\Cmax$ schon für $m = 2$ Maschinen NP-vollständig.
|
|
\end{idee}
|
|
|
|
\subsection*{Was daraus folgt}
|
|
|
|
Von $P\|\Cmax$ geht keine Härte-Reduktion aus. Als Optimierungsproblem ist es in
|
|
Teil D wichtig (List Scheduling, LPT).
|
|
|
|
% ==================================================================
|
|
\section{Hitting Set}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{Hitting Set}
|
|
Gegeben ein Universum $U$, eine Familie von Mengen $F_1, \dots, F_r \subseteq U$
|
|
und eine Zahl $k$. Ein \emph{Hitting Set} ist eine Menge $H \subseteq U$, die
|
|
\emph{jede} der Mengen trifft ($H \cap F_i \ne \emptyset$ für alle $i$). Frage:
|
|
Gibt es ein Hitting Set der Größe $\le k$?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Ein Hitting Set}
|
|
$U = \{1,2,3,4\}$, Mengen $F_1 = \{1,2\}$, $F_2 = \{2,3\}$, $F_3 = \{3,4\}$. Das
|
|
Element $\{2\}$ trifft $F_1$ und $F_2$, aber nicht $F_3$. Die Menge $\{2,3\}$
|
|
trifft alle drei -- ein Hitting Set der Größe 2.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Hitting Set in NP liegt}
|
|
|
|
\emph{Das Zertifikat.} Die Menge $H \subseteq U$, ein Bit pro Element, also
|
|
polynomiell lang.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer prüft $|H| \le k$ und geht dann jede der
|
|
Mengen $F_i$ durch, um sicherzustellen, dass $H$ mindestens ein Element von $F_i$
|
|
enthält. Er akzeptiert, wenn die Größe stimmt und jede Menge getroffen ist.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Existiert ein Hitting Set der
|
|
Größe $\le k$, wird es akzeptiert. Existiert keines, bleibt bei jeder Menge
|
|
dieser Größe ein $F_i$ ungetroffen, und der Verifizierer lehnt ab.
|
|
|
|
\emph{Die Laufzeit.} Für jede der $r$ Mengen ein Test gegen $H$, insgesamt
|
|
$O(r \cdot |U|)$, also polynomiell. Damit $\problem{Hitting Set} \in \NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{$\problem{3-SAT} \redp \problem{Hitting Set}$}
|
|
Das Universum sind alle Literale $x_1, \bar x_1, \dots, x_n, \bar x_n$. Für jede
|
|
Variable $i$ bildet man die Menge $F_i = \{x_i, \bar x_i\}$ -- sie zwingt das
|
|
Hitting Set, aus jedem solchen Paar (mindestens) ein Literal zu wählen, was einer
|
|
Belegung entspricht. Für jede Klausel $j$ bildet man die Menge $F_{n+j}$ ihrer
|
|
Literale -- sie verlangt, dass ein erfüllendes Literal getroffen wird. Mit
|
|
Schranke $k = n$ existiert ein Hitting Set genau dann, wenn die Formel erfüllbar
|
|
ist.
|
|
\end{idee}
|
|
|
|
\subsection*{Was daraus folgt}
|
|
|
|
\begin{idee}{$\problem{Hitting Set} \redp \problem{Set Cover}$: Rollen tauschen}
|
|
Hitting Set und Set Cover sind dual zueinander: Vertauscht man die Rollen von
|
|
\glqq Elementen\grqq{} und \glqq Mengen\grqq, wird aus dem einen das andere. Aus
|
|
einem Hitting Set (wähle Elemente, die alle Mengen treffen) wird ein Set Cover
|
|
(wähle Mengen, die alle Elemente überdecken). (Ausführlich beim Set Cover.)
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{Set Cover}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{Set Cover}
|
|
Gegeben ein Universum $U$, eine Familie von Mengen $S_1, \dots, S_r \subseteq U$
|
|
und eine Zahl $k$. Frage: Gibt es eine Auswahl von höchstens $k$ Mengen, deren
|
|
Vereinigung ganz $U$ ist (die also jedes Element überdeckt)?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Ein Set Cover}
|
|
$U = \{1,2,3,4\}$, Mengen $S_1 = \{1,2\}$, $S_2 = \{2,3\}$, $S_3 = \{3,4\}$. Die
|
|
Auswahl $\{S_1, S_3\}$ überdeckt $1,2$ und $3,4$ -- also ganz $U$, ein Set Cover
|
|
der Größe 2.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Set Cover in NP liegt}
|
|
|
|
\emph{Das Zertifikat.} Die Auswahl der Mengen (welche der $S_i$ genommen werden).
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer prüft, dass höchstens $k$ Mengen gewählt
|
|
sind, und markiert alle Elemente der gewählten Mengen; er kontrolliert, dass am
|
|
Ende jedes Element aus $U$ markiert ist.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Existiert ein Set Cover der
|
|
Größe $\le k$, wird es akzeptiert. Existiert keines, bleibt bei jeder Auswahl
|
|
dieser Größe ein Element unüberdeckt, und der Verifizierer lehnt ab.
|
|
|
|
\emph{Die Laufzeit.} Das Markieren läuft über alle Elemente der gewählten Mengen,
|
|
also $O(r \cdot |U|)$, polynomiell. Damit $\problem{Set Cover} \in \NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{$\problem{Hitting Set} \redp \problem{Set Cover}$: die duale Sicht}
|
|
Man baut den bipartiten Inzidenzgraphen zwischen Elementen und Mengen und
|
|
vertauscht die beiden Seiten: Aus einem Element wird eine Menge, aus einer Menge
|
|
ein Element. Konkret wird aus \glqq Element $u$ liegt in Menge $F_i$\grqq{} die
|
|
Beziehung \glqq neue Menge $u$ enthält neues Element $i$\grqq. Ein Hitting Set der
|
|
Größe $k$ auf der einen Seite entspricht dann genau einem Set Cover der Größe $k$
|
|
auf der anderen. Die Reduktion ist \emph{involutorisch}: zweimal angewandt landet
|
|
man wieder bei der Ausgangsinstanz.
|
|
\end{idee}
|
|
|
|
\subsection*{Was daraus folgt}
|
|
|
|
\begin{idee}{$\problem{Set Cover} \redp \problem{Hitting Set}$: die Rollen zurücktauschen}
|
|
Man macht denselben Tausch noch einmal, jetzt in die andere Richtung. Aus einer
|
|
Set-Cover-Instanz mit Universum $U$ und Mengen $S_1, \dots, S_r$ baut man eine
|
|
Hitting-Set-Instanz, deren Universum die \emph{Mengen-Indizes} $\{1, \dots, r\}$
|
|
sind. Für jedes Element $u \in U$ bildet man dort die Menge aller Indizes $i$,
|
|
für die $u \in S_i$ gilt.
|
|
\end{idee}
|
|
|
|
Warum das passt: Eine Auswahl von Set-Cover-Mengen überdeckt genau dann jedes
|
|
Element $u$, wenn sie für jedes $u$ mindestens eine der Mengen enthält, die $u$
|
|
abdecken -- also mindestens einen Index der neuen Menge zu $u$ trifft. Das ist
|
|
wörtlich die Hitting-Set-Bedingung, und die Schranke $k$ bleibt gleich. Weil
|
|
diese Reduktion \emph{involutorisch} ist -- zweimal angewandt landet man bei der
|
|
Ausgangsinstanz --, sind Set Cover und Hitting Set exakt gleich schwer. Im Kurs
|
|
dient das vor allem den ETH-Schranken für beide Probleme.
|
|
|
|
% ==================================================================
|
|
\section{Dominating Set}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{Dominating Set}
|
|
Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Ein \emph{Dominating Set} ist
|
|
eine Knotenmenge $D \subseteq V$, sodass jeder Knoten entweder selbst in $D$
|
|
liegt oder einen Nachbarn in $D$ hat. Frage: Gibt es ein Dominating Set der
|
|
Größe $\le k$?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Ein Dominating Set}
|
|
In einem Stern mit einem Mittelknoten und vier Blättern genügt der Mittelknoten:
|
|
$\{m\}$ ist ein Dominating Set, denn jedes Blatt hat $m$ als Nachbarn.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Dominating Set in NP liegt}
|
|
|
|
\emph{Das Zertifikat.} Die Knotenmenge $D \subseteq V$, ein Bit pro Knoten, Länge
|
|
$O(|V|)$.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer prüft zuerst $|D| \le k$. Dann geht er jeden
|
|
Knoten $v \in V$ durch und prüft die \emph{Dominanzbedingung}: ob $v \in D$ liegt
|
|
oder ob $v$ einen Nachbarn in $D$ hat -- dazu läuft er die Zeile von $v$ in der
|
|
Adjazenzmatrix durch. Er akzeptiert, wenn die Größe stimmt und jeder Knoten
|
|
dominiert wird.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Existiert ein Dominating Set
|
|
der Größe $\le k$, wird es akzeptiert. Existiert keines, bleibt bei jeder Menge
|
|
dieser Größe ein Knoten undominiert, und der Verifizierer lehnt ab.
|
|
|
|
\emph{Die Laufzeit.} Die Größenprüfung kostet $O(|V|)$; die Dominanzprüfung geht
|
|
für jeden der $|V|$ Knoten eine Matrixzeile durch, also $O(|V|^2)$. Insgesamt
|
|
$O(|V|^2)$. Damit $\problem{Dominating Set} \in \NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{zushang}
|
|
Im Material dieses Kurses wird für \problem{Dominating Set} nur die
|
|
\emph{NP-Zugehörigkeit} behandelt -- es war eine Klausuraufgabe genau zu diesem
|
|
Nachweis. Eine \emph{Härte-Reduktion} wird in den Vorlesungs- und Übungsquellen
|
|
nicht geführt. \problem{Dominating Set} ist zwar bekanntlich NP-vollständig
|
|
(Standardreduktion aus Vertex Cover), aber diese Reduktion gehört nicht zum
|
|
gesicherten Kursstoff -- deshalb wird sie hier nicht als solche dargestellt.
|
|
\end{zushang}
|
|
|
|
% ==================================================================
|
|
\section{Longest Path}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{Longest Path}
|
|
Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Frage: Gibt es einen
|
|
\emph{einfachen} Pfad (kein Knoten doppelt) der Länge $\ge k$?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Ein langer Pfad}
|
|
In einem Weg-Graphen $1 - 2 - 3 - 4 - 5$ ist die ganze Kette ein einfacher Pfad
|
|
der Länge 4 (vier Kanten). Für $k = 4$ ist die Antwort also Ja.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Longest Path in NP liegt}
|
|
|
|
\emph{Das Zertifikat.} Eine Folge von $k+1$ paarweise verschiedenen Knoten
|
|
$(v_0, v_1, \dots, v_k)$ -- der behauptete Pfad. Jeder Knoten braucht
|
|
$O(\log|V|)$ Bits, die Folge also $O(k \log|V|)$ Bits, polynomiell.
|
|
|
|
\emph{Die Prüfung.} Der Verifizierer prüft erstens, dass alle $v_i$ paarweise
|
|
verschieden sind, und zweitens, dass zwischen je zwei aufeinanderfolgenden
|
|
Knoten eine Kante liegt. Er akzeptiert bei beidem.
|
|
|
|
\emph{Warum das korrekt ist -- beide Richtungen.} Hat $G$ einen einfachen Pfad
|
|
der Länge $\ge k$, so bilden seine ersten $k+1$ Knoten ein akzeptiertes
|
|
Zertifikat. Wird umgekehrt ein Zertifikat akzeptiert, so ist es eine Folge
|
|
verschiedener Knoten mit lauter echten Kanten -- ein einfacher Pfad der Länge
|
|
$k$.
|
|
|
|
\emph{Die Laufzeit.} Die Verschiedenheit kostet $O(k^2)$ Vergleiche, die
|
|
Kantenbedingung $O(k)$ Nachschläge; insgesamt $O(k^2) \subseteq O(|V|^2)$. Damit
|
|
$\problem{Longest Path} \in \NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{zushang}
|
|
Wie bei \problem{Dominating Set} behandelt der Kurs für \problem{Longest Path}
|
|
nur die \emph{NP-Zugehörigkeit} (Klausuraufgabe). Eine Härte-Reduktion steht
|
|
nicht im Kursmaterial -- obwohl \problem{Longest Path} bekanntlich NP-vollständig
|
|
ist (es verallgemeinert den Hamiltonpfad). Wir halten uns hier an das, was der
|
|
Kurs gesichert liefert.
|
|
\end{zushang}
|
|
|
|
% ==================================================================
|
|
\section{Das Halteproblem -- schwer, aber nicht in NP}
|
|
% ==================================================================
|
|
|
|
Zum Abschluss des Katalogs ein Problem, das die Grenzen aufzeigt: Es ist
|
|
NP-schwer, liegt aber \emph{nicht} in $\NP$ -- weil es überhaupt nicht lösbar
|
|
ist.
|
|
|
|
\begin{defn}{Halteproblem}
|
|
Gegeben die Beschreibung eines Programms $M$ und einer Eingabe $w$. Frage: Hält
|
|
$M$ auf $w$ irgendwann an, oder läuft es für immer?
|
|
\end{defn}
|
|
|
|
Das Halteproblem ist \emph{unentscheidbar} -- kein Algorithmus löst es, mit
|
|
keiner noch so großen Laufzeit. Das ist ein tiefes, bewiesenes Resultat (Turing).
|
|
Deshalb kann es auch keinen Verifizierer geben, und das Halteproblem liegt
|
|
\emph{nicht} in $\NP$.
|
|
|
|
\subsection*{Woher die Schwere kommt}
|
|
|
|
\begin{idee}{$\problem{SAT} \redp \problem{Halteproblem}$}
|
|
Zu einer Formel $\varphi$ baut man ein Programm $M_\varphi$, das die Eingabe
|
|
ignoriert, \emph{alle} Belegungen der Reihe nach durchprobiert und genau dann
|
|
anhält, wenn es eine erfüllende findet -- sonst läuft es ewig weiter. Dann gilt:
|
|
$M_\varphi$ hält genau dann, wenn $\varphi$ erfüllbar ist. Also
|
|
$\varphi \in \problem{SAT} \iff \langle M_\varphi, \varepsilon\rangle \in
|
|
\problem{Halteproblem}$.
|
|
\end{idee}
|
|
|
|
\begin{aha}
|
|
Der Clou liegt im Zeitverhalten. $M_\varphi$ läuft im Nein-Fall \emph{ewig} --
|
|
aber die \emph{Konstruktion} von $M_\varphi$ aus $\varphi$ ist billig
|
|
(polynomiell), und nur das zählt bei einer Reduktion. Also ist das Halteproblem
|
|
mindestens so schwer wie \problem{SAT}, liegt aber nicht in $\NP$. Das zeigt:
|
|
\textbf{NP-schwer ist nicht dasselbe wie NP-vollständig.} NP-vollständig verlangt
|
|
zusätzlich die Zugehörigkeit zu $\NP$ -- die dem Halteproblem fehlt.
|
|
\end{aha}
|
|
|
|
% ##################################################################
|
|
\part*{Teil C -- Untere Schranken: die ETH}
|
|
\addcontentsline{toc}{section}{\textbf{Teil C -- Untere Schranken: die ETH}}
|
|
% ##################################################################
|
|
|
|
\noindent NP-Vollständigkeit sagt nur \glqq vermutlich nicht polynomiell\grqq.
|
|
Sie sagt nicht, \emph{wie} exponentiell ein Problem ist. Die
|
|
Exponentialzeit-Hypothese (ETH) ist eine schärfere Annahme, aus der man konkrete
|
|
\emph{untere} Laufzeitschranken herleitet. In diesem Teil steht bei jedem
|
|
Schritt die \emph{Idee}.
|
|
|
|
% ==================================================================
|
|
\section{Die Bausteine der ETH}
|
|
% ==================================================================
|
|
|
|
\subsection*{Die o-Notation}
|
|
|
|
\begin{defn}{Klein-o}
|
|
$f(x) = o(g(x))$ bedeutet: $f$ wächst \emph{echt langsamer} als $g$, formal
|
|
$f(x)/g(x) \to 0$. Für jedes feste $\delta > 0$ gilt $\delta n \ne o(n)$ --
|
|
$\delta n$ wächst nicht langsamer als $n$, nur mit anderem Vorfaktor.
|
|
\end{defn}
|
|
|
|
Deshalb sind \glqq kein $2^{\delta n}$ für ein festes $\delta$\grqq{} und
|
|
\glqq kein $2^{o(n)}$\grqq{} austauschbare Schreibweisen. Ein
|
|
\glqq $2^{o(n)}$-Algorithmus\grqq{} hätte einen Exponenten, der langsamer als
|
|
linear wächst -- er liefe \emph{subexponentiell}, etwa mit $2^{\sqrt n}$.
|
|
|
|
\subsection*{Die Hypothese}
|
|
|
|
\begin{defn}{Exponentialzeit-Hypothese (ETH)}
|
|
Es gibt eine Konstante $\delta > 0$, sodass \problem{3-SAT} mit $n$ Variablen
|
|
\emph{nicht} in Zeit $2^{\delta n}\cdot(n+m)^{O(1)}$ lösbar ist. Kurz: Es gibt
|
|
keinen $2^{o(n)}$-Algorithmus für \problem{3-SAT}.
|
|
\end{defn}
|
|
|
|
Das ist eine \emph{Annahme}, stärker als $\Pclass \ne \NP$, aber breit geglaubt:
|
|
Alle bekannten 3-SAT-Algorithmen brauchen $c^n$ (das kleinste bekannte $c$ liegt
|
|
knapp über $1{,}3$).
|
|
|
|
\subsection*{Das Sparsification-Lemma -- und warum $n$ gegen $m$}
|
|
|
|
\begin{satz}{Sparsification-Lemma}
|
|
Unter der ETH gibt es auch keinen $2^{o(m)}$-Algorithmus für \problem{3-SAT},
|
|
wobei $m$ die \emph{Klauselzahl} ist.
|
|
\end{satz}
|
|
|
|
\begin{intuition}
|
|
Warum braucht man dieses Lemma überhaupt? Die ETH ist über die \emph{Variablen}zahl
|
|
$n$ formuliert. Viele Reduktionen erzeugen ihre Zielgröße aber (auch) aus der
|
|
\emph{Klausel}zahl $m$. Und $m$ kann viel größer als $n$ sein. Deshalb folgt
|
|
\glqq kein $2^{o(m)}$\grqq{} \emph{nicht} automatisch aus \glqq kein
|
|
$2^{o(n)}$\grqq{}. Das Sparsification-Lemma überträgt die Härte von $n$ auf $m$.
|
|
Die Brücke zwischen beiden ist $n \le 3m$ (jede Variable kommt in einer Klausel
|
|
vor, jede Klausel hat $\le 3$ Literale).
|
|
\end{intuition}
|
|
|
|
\subsection*{Das Beweisschema: Kontraposition}
|
|
|
|
\begin{idee}{So beweist man eine untere Schranke}
|
|
Man nimmt an, das Zielproblem hätte einen zu schnellen Algorithmus, und leitet
|
|
daraus einen zu schnellen Algorithmus für \problem{3-SAT} ab -- ein Widerspruch.
|
|
Der Textbaustein, in \emph{jedem} Teilpunkt zu wiederholen:
|
|
\begin{quote}\itshape\small
|
|
Angenommen, es gäbe einen Algorithmus, der [Zielproblem] in
|
|
$2^{o(p)}\cdot|I|^{O(1)}$ löst. Weil der Parameter $p$ mit der Reduktionsgröße
|
|
$O(f(m))$ zusammenhängt, ergäbe die Kombination aus Reduktion und Algorithmus
|
|
einen $3$-SAT-Algorithmus in $2^{o(m)}\cdot|I|^{O(1)}$. Nach dem
|
|
Sparsification-Lemma geht das nur, wenn die ETH nicht gilt -- Widerspruch.
|
|
\end{quote}
|
|
\end{idee}
|
|
|
|
\begin{stolper}
|
|
Entscheidend ist die Frage: \emph{Hängt der Parameter an $n$ oder an $m$?} Hängt
|
|
er nur an der Variablenzahl $n$, argumentiert man \emph{direkt} mit der ETH und
|
|
braucht das Lemma nicht. Hängt er (auch) an der Klauselzahl $m$, \emph{muss} man
|
|
das Sparsification-Lemma zitieren. Es immer oder nie zu nennen, kostet Punkte.
|
|
\end{stolper}
|
|
|
|
\subsection*{Die Wurzel-Regel}
|
|
|
|
Wächst der Zielparameter \emph{polynomiell} in $m$, etwa $p = O(m^c)$, so wird
|
|
die Schranke zu $2^{o(\sqrt[c]{p})}$. Denn aus $q = o(\sqrt[c]{p})$ und $p =
|
|
O(m^c)$ folgt $q = o(m)$. Beispiel: Erzeugt eine Reduktion $O(m^2)$ Kanten, so
|
|
lautet die Schranke \glqq kein $2^{o(\sqrt{|E|})}$\grqq.
|
|
|
|
% ==================================================================
|
|
\section{Untere Schranken für die einzelnen Probleme}
|
|
% ==================================================================
|
|
|
|
Wendet man das Schema auf die Reduktionen des Katalogs an, bekommt man für jedes
|
|
Problem eine untere Schranke -- mit dem Parameter, an dem sie hängt. Wir gehen
|
|
die Probleme einzeln durch.
|
|
|
|
\subsection*{Clique}
|
|
|
|
Die Reduktion $\problem{3-SAT} \redp \problem{$k$-Clique}$ erzeugt einen Graphen
|
|
mit $|V| = O(m)$ Knoten (ein Knoten pro Literalvorkommen), $|E| = O(m^2)$ Kanten
|
|
und Cliquengröße $k = m$. Setzt man einen $2^{o(|V|)}$-Algorithmus für
|
|
\problem{Clique} an, so wäre er wegen $|V| = O(m)$ ein $2^{o(m)}$-Algorithmus für
|
|
\problem{3-SAT} -- ausgeschlossen nach dem Sparsification-Lemma. Also gibt es
|
|
keinen $2^{o(|V|)}$-Algorithmus. Für die Kanten liefert die Wurzel-Regel wegen
|
|
$|E| = O(m^2)$ die Schranke \glqq kein $2^{o(\sqrt{|E|})}$\grqq. Und wegen
|
|
$k = m$ gibt es keinen $2^{o(k)}$-Algorithmus.
|
|
|
|
\subsection*{Independent Set}
|
|
|
|
Die Reduktion $\problem{Clique} \redp \problem{Independent Set}$ bildet nur den
|
|
Komplementgraphen und lässt $k$ unverändert. Der Komplementgraph hat
|
|
\emph{dieselbe} Knotenzahl $|V|$ und dieselbe Cliquengröße $k$; die Kantenzahl
|
|
bleibt in der Größenordnung $O(|V|^2)$. Weil sich keiner der drei Parameter
|
|
vergrößert, überträgt sich jede Schranke von \problem{Clique} wörtlich: kein
|
|
$2^{o(|V|)}$, kein $2^{o(\sqrt{|E|})}$, kein $2^{o(k)}$ für \problem{Independent
|
|
Set}.
|
|
|
|
\subsection*{Vertex Cover}
|
|
|
|
Auch \problem{Vertex Cover} bekommt man über den Komplementgraphen -- hier mit
|
|
Schranke $k' = n - k$. Die Knoten- und Kantenzahl bleiben wie beim Independent
|
|
Set unverändert, und $k' = n - k \le n = O(|V|)$. Deshalb gelten für
|
|
\problem{Vertex Cover} dieselben unteren Schranken: kein $2^{o(|V|)}$, kein
|
|
$2^{o(\sqrt{|E|})}$, kein $2^{o(k')}$.
|
|
|
|
\subsection*{Hitting Set -- der Fall, an dem man beide Situationen sieht}
|
|
|
|
Die Reduktion $\problem{3-SAT} \redp \problem{Hitting Set}$ liefert die Parameter
|
|
$|U| = 2n$ (das Universum sind die Literale), $r = n + m$ (die Zahl der Mengen)
|
|
und $k = n$. An diesen drei Parametern sieht man nebeneinander, wann man das
|
|
Sparsification-Lemma braucht und wann nicht.
|
|
|
|
\emph{Die Schranke in $|U| = 2n$.} Nimmt man einen $2^{o(|U|)}$-Algorithmus für
|
|
\problem{Hitting Set} an, so ist er wegen $|U| = 2n$ ein $2^{o(n)}$-Algorithmus.
|
|
Über die Reduktion ergäbe das einen $2^{o(n)}$-Algorithmus für \problem{3-SAT} --
|
|
das widerspricht \emph{direkt} der ETH. Hier braucht man das Sparsification-Lemma
|
|
nicht, weil $|U|$ nur an der Variablenzahl $n$ hängt.
|
|
|
|
\emph{Die Schranke in $r = n + m$.} Nimmt man einen $2^{o(r)}$-Algorithmus an, so
|
|
ist er wegen $r = n + m$ und $n \le 3m$, also $r = O(m)$, ein
|
|
$2^{o(m)}$-Algorithmus für \problem{3-SAT}. Dass es keinen solchen gibt, sagt
|
|
\emph{nicht} die ETH selbst, sondern erst das Sparsification-Lemma -- weil der
|
|
Parameter an der Klauselzahl $m$ hängt. Diesen Zusatzschritt muss man hier also
|
|
zitieren.
|
|
|
|
\emph{Die Schranke in $k = n$.} Nimmt man einen $2^{o(k)}$-Algorithmus an, so ist
|
|
er wegen $k = n$ ein $2^{o(n)}$-Algorithmus und ergäbe wie im ersten Fall einen
|
|
$2^{o(n)}$-Algorithmus für \problem{3-SAT} -- direkter Widerspruch zur ETH, ohne
|
|
Sparsification-Lemma.
|
|
|
|
\subsection*{SubSet Sum und Partition}
|
|
|
|
Die gewöhnliche Kette bis \problem{SubSet Sum} erzeugt sehr viele Zahlen und gibt
|
|
nur eine schwache Wurzel-Schranke. Die \emph{strenge} Reduktion
|
|
$\problem{3-SAT} \redp \problem{SubSet Sum}$ (Ziffern zur Basis 10, siehe beim
|
|
SubSet Sum) erzeugt dagegen nur $|A| = 2n + 2m \le 8m = O(m)$ Zahlen. Ein
|
|
$2^{o(n)}$-Algorithmus für \problem{SubSet Sum} -- wobei $n$ hier die
|
|
\emph{Anzahl der Zahlen} ist -- ergäbe über diese wenigen Zahlen einen
|
|
$2^{o(m)}$-Algorithmus für \problem{3-SAT}, ausgeschlossen nach dem
|
|
Sparsification-Lemma. Es gibt also keinen $2^{o(n)}$-Algorithmus für
|
|
\problem{SubSet Sum}. Über die Reduktion $\problem{SubSet Sum} \redp
|
|
\problem{Partition}$, die nur zwei Zahlen hinzufügt, überträgt sich dieselbe
|
|
Schranke auf \problem{Partition}.
|
|
|
|
\subsection*{3-Color}
|
|
|
|
Für \problem{3-Color} benutzt man die eigene $O(n+m)$-Gadget-Konstruktion aus dem
|
|
Katalog: Sie baut aus einer 3-SAT-Formel einen Graphen mit $|V| = O(n+m) = O(m)$
|
|
Knoten. Ein $2^{o(|V|)}$-Algorithmus für \problem{3-Color} wäre damit ein
|
|
$2^{o(m)}$-Algorithmus für \problem{3-SAT} -- nach dem Sparsification-Lemma
|
|
ausgeschlossen. Also gibt es keinen $2^{o(|V|)}$-Algorithmus für \problem{3-Color}.
|
|
|
|
\subsection*{Set Cover}
|
|
|
|
Für \problem{Set Cover} nutzt man die Dualität zu \problem{Hitting Set}: Der
|
|
Rollentausch vertauscht Universum und Mengenzahl, macht also aus $|U|$ die
|
|
Mengenzahl und aus der Mengenzahl das neue $|U|$. Damit übertragen sich die
|
|
Hitting-Set-Schranken direkt: kein $2^{o(|U|)}$ und kein $2^{o(r)}$ für
|
|
\problem{Set Cover}, wieder mit dem Sparsification-Lemma bei der
|
|
$m$-abhängigen Mengenzahl.
|
|
|
|
% ##################################################################
|
|
\part*{Teil D -- Approximation}
|
|
\addcontentsline{toc}{section}{\textbf{Teil D -- Approximation}}
|
|
% ##################################################################
|
|
|
|
\noindent Wenn ein Optimierungsproblem (vermutlich) keine schnelle exakte Lösung
|
|
hat, berechnet man in Polynomialzeit eine \emph{beweisbar gute} Näherung. Bei
|
|
jedem Algorithmus steht hier die Güte (exakt) und die \emph{Idee} des
|
|
Güte-Beweises -- die zentrale Ungleichung.
|
|
|
|
% ==================================================================
|
|
\section{Der Gütebegriff}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{Multiplikative Güte}
|
|
Sei $\OPT(I)$ der optimale Wert einer Instanz $I$. Ein Algorithmus $A$ hat
|
|
\emph{Güte $\alpha$}, wenn für \emph{alle} Instanzen gilt: bei Minimierung
|
|
$A(I) \le \alpha\cdot\OPT(I)$; bei Maximierung $\OPT(I) \le \alpha\cdot A(I)$. Die
|
|
Güte heißt \emph{scharf}, wenn Instanzen den Faktor beliebig genau erreichen.
|
|
\end{defn}
|
|
|
|
\begin{intuition}
|
|
Güte $\alpha$ ist eine Garantie für den schlimmsten Fall. Güte 2 bei einem
|
|
Minimierungsproblem heißt: Egal welche Eingabe, die Lösung ist nie mehr als
|
|
doppelt so teuer wie die beste mögliche. Kleineres $\alpha$ ist besser;
|
|
$\alpha = 1$ wäre exakt optimal.
|
|
\end{intuition}
|
|
|
|
Manche Probleme erlauben sogar eine \emph{einstellbare} Genauigkeit -- eine
|
|
ganze Familie $(A_\varepsilon)$ mit Güte $1+\varepsilon$ für jedes $\varepsilon$.
|
|
Je nach Laufzeit trägt so eine Familie einen eigenen Namen; wir betrachten die
|
|
drei Stufen einzeln.
|
|
|
|
\begin{defn}{PTAS}
|
|
Eine Familie $(A_\varepsilon)$ mit Güte $1+\varepsilon$ heißt \emph{PTAS}
|
|
(polynomielles Approximationsschema), wenn die Laufzeit für \emph{jedes feste}
|
|
$\varepsilon$ polynomiell in $n$ ist.
|
|
\end{defn}
|
|
|
|
Der Haken: $\varepsilon$ darf im Exponenten von $n$ stecken, etwa
|
|
$n^{1/\varepsilon}$. Für kleines $\varepsilon$ wird das schnell unpraktisch.
|
|
|
|
\begin{defn}{EPTAS}
|
|
Ein \emph{EPTAS} ist ein PTAS, dessen Laufzeit die Form $f(1/\varepsilon)\cdot
|
|
\poly(n)$ hat -- $\varepsilon$ steht nicht mehr im Exponenten von $n$.
|
|
\end{defn}
|
|
|
|
\begin{defn}{FPTAS}
|
|
Ein \emph{FPTAS} ist ein PTAS, dessen Laufzeit polynomiell in $n$ \emph{und} in
|
|
$1/\varepsilon$ ist, etwa $O(n^3/\varepsilon)$. Das ist die stärkste Form.
|
|
\end{defn}
|
|
|
|
Ein verwandter Begriff: \emph{pseudopolynomiell} heißt eine Laufzeit, die
|
|
polynomiell in den \emph{Zahlenwerten} der Eingabe ist (etwa in der Kapazität).
|
|
Wegen der binären Kodierung (Kapitel 2) ist das \emph{nicht} dasselbe wie
|
|
polynomiell in der Eingabelänge.
|
|
|
|
% ==================================================================
|
|
\section{TSP ist im Allgemeinen nicht approximierbar}
|
|
% ==================================================================
|
|
|
|
\begin{satz}{Kein Näherungsalgorithmus für allgemeines TSP}
|
|
Für beliebige Distanzen gibt es \emph{keinen} Näherungsalgorithmus mit
|
|
beschränkter Güte -- außer $\Pclass = \NP$.\\[0.3em]
|
|
\emph{Die Idee:} Man reduziert \problem{Hamiltonkreis}. Echte Kanten bekommen
|
|
Distanz 1, fehlende Kanten eine \emph{riesige} Distanz. Gäbe es einen Algorithmus
|
|
mit fester Güte $\alpha$, müsste er die billige Hamilton-Tour (Länge $|V|$) von
|
|
jeder teuren unterscheiden -- und könnte damit \problem{HK} exakt entscheiden.
|
|
\end{satz}
|
|
|
|
Der Ausweg ist eine realistische Zusatzannahme: das \emph{metrische} TSP mit
|
|
symmetrischen Distanzen und der Dreiecksungleichung $d(i,j) \le d(i,k) + d(k,j)$.
|
|
Dort funktionieren die folgenden zwei Algorithmen.
|
|
|
|
% ==================================================================
|
|
\section{$\Delta$TSP$_1$: der Algorithmus als Bilderfolge}
|
|
% ==================================================================
|
|
|
|
\begin{idee}{Der Dreisprung}
|
|
Man baut zuerst ein billiges Gerüst, das alle Städte verbindet (einen minimalen
|
|
Spannbaum), macht daraus einen Rundweg über alle Kanten (einen Eulerkreis, indem
|
|
man alle Grade gerade macht) und kürzt diesen zur Tour ab.
|
|
\end{idee}
|
|
|
|
\noindent Wir gehen es an einem festen Beispiel durch: Städte $A,B,C,D,E$ mit
|
|
$d(A,E)=1$, $d(B,C)=1$, $d(A,C)=2$, $d(C,D)=2$ (übrige Distanzen 2 oder 3). Das
|
|
Layout bleibt in allen Bildern gleich.
|
|
|
|
\medskip
|
|
\noindent\textbf{Bild 1 -- die optimale Tour (zum Vergleich).} So sieht die beste
|
|
Rundreise aus; sie hat Länge 8. Der Algorithmus kennt sie nicht, wir zeigen sie
|
|
nur zum Vergleich.
|
|
\begin{center}
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{picture}(5.2,3.4)(-0.3,-0.3)
|
|
\put(0.5,2.2){\circle*{0.14}}\put(0.05,2.25){\small $A$}
|
|
\put(0.5,0.3){\circle*{0.14}}\put(0.05,0.15){\small $B$}
|
|
\put(2.6,1.3){\circle*{0.14}}\put(2.35,1.45){\small $C$}
|
|
\put(4.6,1.3){\circle*{0.14}}\put(4.75,1.3){\small $D$}
|
|
\put(2.6,3.0){\circle*{0.14}}\put(2.75,3.0){\small $E$}
|
|
\qbezier(2.6,1.3)(1.55,0.8)(0.5,0.3)
|
|
\qbezier(0.5,0.3)(2.55,0.5)(4.6,1.3)
|
|
\qbezier(4.6,1.3)(3.6,2.15)(2.6,3.0)
|
|
\qbezier(2.6,3.0)(1.55,2.6)(0.5,2.2)
|
|
\qbezier(0.5,2.2)(1.55,1.75)(2.6,1.3)
|
|
\put(-0.2,-0.2){\small optimale Tour $[C,B,D,E,A,C]$, Länge $8$}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
\noindent\textbf{Bild 2 -- Schritt 1: minimaler Spannbaum.} Der Algorithmus
|
|
verbindet alle Städte so billig wie möglich zu einem Baum: Kanten $A$--$E\,(1)$,
|
|
$B$--$C\,(1)$, $A$--$C\,(2)$, $C$--$D\,(2)$ mit Gewicht 6.
|
|
\begin{center}
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{picture}(5.2,3.4)(-0.3,-0.3)
|
|
\put(0.5,2.2){\circle*{0.14}}\put(0.05,2.25){\small $A$}
|
|
\put(0.5,0.3){\circle*{0.14}}\put(0.05,0.15){\small $B$}
|
|
\put(2.6,1.3){\circle*{0.14}}\put(2.35,1.45){\small $C$}
|
|
\put(4.6,1.3){\circle*{0.14}}\put(4.75,1.3){\small $D$}
|
|
\put(2.6,3.0){\circle*{0.14}}\put(2.75,3.0){\small $E$}
|
|
\linethickness{1.3pt}
|
|
\qbezier(0.5,2.2)(1.55,2.6)(2.6,3.0)\put(1.3,2.75){\small $1$}
|
|
\qbezier(0.5,0.3)(1.55,0.8)(2.6,1.3)\put(1.3,0.55){\small $1$}
|
|
\qbezier(0.5,2.2)(1.55,1.75)(2.6,1.3)\put(1.35,1.95){\small $2$}
|
|
\put(2.6,1.3){\line(1,0){2.0}}\put(3.5,1.4){\small $2$}
|
|
\put(0.0,-0.2){\small Spannbaum $T$, Gewicht $w(T)=6$}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
\begin{intuition}
|
|
Warum ein Spannbaum? Weil er \emph{garantiert billiger} ist als die optimale
|
|
Tour: Nimm die optimale Tour und lösche eine Kante -- übrig bleibt ein Weg durch
|
|
alle Städte, also ein Spannbaum. Der \emph{minimale} Spannbaum ist höchstens so
|
|
teuer. Also $w(T) \le \OPT$. Das ist die erste der drei Ungleichungen des
|
|
Güte-Beweises.
|
|
\end{intuition}
|
|
|
|
\noindent\textbf{Bild 3 -- Schritt 2 und 3: verdoppeln, dann Eulerkreis.} Jede
|
|
Baumkante wird verdoppelt (im Bild \glqq $\times 2$\grqq). Dadurch hat jeder
|
|
Knoten geraden Grad -- die Bedingung für einen Eulerkreis, der jede Kante genau
|
|
einmal nutzt. Sein Gewicht ist $2 \cdot 6 = 12$.
|
|
\begin{center}
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{picture}(5.2,3.4)(-0.3,-0.3)
|
|
\put(0.5,2.2){\circle*{0.14}}\put(0.05,2.25){\small $A$}
|
|
\put(0.5,0.3){\circle*{0.14}}\put(0.05,0.15){\small $B$}
|
|
\put(2.6,1.3){\circle*{0.14}}\put(2.35,1.45){\small $C$}
|
|
\put(4.6,1.3){\circle*{0.14}}\put(4.75,1.3){\small $D$}
|
|
\put(2.6,3.0){\circle*{0.14}}\put(2.75,3.0){\small $E$}
|
|
\linethickness{1.3pt}
|
|
\qbezier(0.5,2.2)(1.55,2.6)(2.6,3.0)\put(1.25,2.75){\small $\times 2$}
|
|
\qbezier(0.5,0.3)(1.55,0.8)(2.6,1.3)\put(1.25,0.5){\small $\times 2$}
|
|
\qbezier(0.5,2.2)(1.55,1.75)(2.6,1.3)\put(1.3,1.9){\small $\times 2$}
|
|
\put(2.6,1.3){\line(1,0){2.0}}\put(3.4,1.4){\small $\times 2$}
|
|
\put(-0.2,-0.2){\small Multigraph, Gewicht $12$, alle Grade gerade}
|
|
\end{picture}
|
|
\end{center}
|
|
Ein Eulerkreis ist z.\,B. $[C,A,E,A,C,B,C,D,C]$ mit Länge 12; manche Städte
|
|
werden dabei mehrfach besucht.
|
|
|
|
\noindent\textbf{Bild 4 -- Schritt 4: abkürzen zur Tour.} Eine echte Rundreise
|
|
darf jede Stadt nur einmal besuchen. Man läuft den Eulerkreis ab und
|
|
\emph{überspringt} bereits besuchte Städte. Aus $[C,A,E,A,C,B,C,D,C]$ wird die
|
|
Tour $[C,A,E,B,D,C]$.
|
|
\begin{center}
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{picture}(5.2,3.4)(-0.3,-0.3)
|
|
\put(0.5,2.2){\circle*{0.14}}\put(0.05,2.25){\small $A$}
|
|
\put(0.5,0.3){\circle*{0.14}}\put(0.05,0.15){\small $B$}
|
|
\put(2.6,1.3){\circle*{0.14}}\put(2.35,1.45){\small $C$}
|
|
\put(4.6,1.3){\circle*{0.14}}\put(4.75,1.3){\small $D$}
|
|
\put(2.6,3.0){\circle*{0.14}}\put(2.75,3.0){\small $E$}
|
|
\linethickness{1.1pt}
|
|
\qbezier(2.6,1.3)(1.55,1.75)(0.5,2.2)
|
|
\qbezier(0.5,2.2)(1.55,2.6)(2.6,3.0)
|
|
\qbezier(2.6,3.0)(1.55,1.65)(0.5,0.3)
|
|
\qbezier(0.5,0.3)(2.55,0.5)(4.6,1.3)
|
|
\put(2.6,1.3){\line(1,0){2.0}}
|
|
\put(-0.2,-0.2){\small Tour $[C,A,E,B,D,C]$, Länge $10 \le 2\cdot\OPT$}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
\begin{idee}{Die Güte 2 -- drei Ungleichungen}
|
|
$\Delta$TSP$_1$ hat Güte 2, und der Beweis besteht aus drei Schritten:
|
|
(1) $w(T) \le \OPT$ (Spannbaum billiger als Tour, s.o.);
|
|
(2) der Eulerkreis auf den verdoppelten Kanten hat Länge $2\,w(T) \le 2\,\OPT$;
|
|
(3) das Abkürzen verlängert wegen der Dreiecksungleichung nicht, also
|
|
$d(R) \le 2\,w(T) \le 2\,\OPT$. Im Beispiel: Länge 10, garantiert $\le 16$,
|
|
tatsächlich nahe am Optimum 8.
|
|
\end{idee}
|
|
|
|
\begin{intuition}
|
|
\textbf{Der schlimmste Fall} wird von einer Stern-Konstruktion erreicht: $n$
|
|
Städte, deren optimale Tour Länge $n$ hat, während $\Delta$TSP$_1$ auf Länge
|
|
$2n-2$ kommt. Das Verhältnis geht gegen 2 -- die Schranke ist also (fast)
|
|
scharf. Nötig sind Symmetrie und Dreiecksungleichung.
|
|
\end{intuition}
|
|
|
|
% ==================================================================
|
|
\section{Christofides: schlauer verdoppeln}
|
|
% ==================================================================
|
|
|
|
$\Delta$TSP$_1$ verdoppelt \emph{alle} Kanten -- das kostet zusätzlich etwa
|
|
$w(T) \approx \OPT$, daher die Güte 2. Christofides repariert nur die
|
|
\emph{ungeraden} Knoten und kommt so auf Güte $1{,}5$.
|
|
|
|
\begin{idee}{Nur die schiefen Knoten reparieren}
|
|
Ein Eulerkreis braucht nur, dass jeder Knoten geraden Grad hat. Im Spannbaum
|
|
haben ohnehin nur manche Knoten ungeraden Grad. Statt alles zu verdoppeln,
|
|
verbindet Christofides genau diese ungeraden Knoten durch ein \emph{minimales
|
|
perfektes Matching} -- die billigste Art, sie paarweise zu verkuppeln.
|
|
\end{idee}
|
|
|
|
\noindent\textbf{Bild 1 -- der minimale Spannbaum.} Christofides startet mit
|
|
demselben Spannbaum wie $\Delta$TSP$_1$: Kanten $A$--$E\,(1)$, $B$--$C\,(1)$,
|
|
$A$--$C\,(2)$, $C$--$D\,(2)$, Gewicht 6.
|
|
\begin{center}
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{picture}(5.2,3.4)(-0.3,-0.3)
|
|
\put(0.5,2.2){\circle*{0.14}}\put(0.05,2.25){\small $A$}
|
|
\put(0.5,0.3){\circle*{0.14}}\put(0.05,0.15){\small $B$}
|
|
\put(2.6,1.3){\circle*{0.14}}\put(2.35,1.45){\small $C$}
|
|
\put(4.6,1.3){\circle*{0.14}}\put(4.75,1.3){\small $D$}
|
|
\put(2.6,3.0){\circle*{0.14}}\put(2.75,3.0){\small $E$}
|
|
\linethickness{1.3pt}
|
|
\qbezier(0.5,2.2)(1.55,2.6)(2.6,3.0)
|
|
\qbezier(0.5,0.3)(1.55,0.8)(2.6,1.3)
|
|
\qbezier(0.5,2.2)(1.55,1.75)(2.6,1.3)
|
|
\put(2.6,1.3){\line(1,0){2.0}}
|
|
\put(0.0,-0.2){\small Spannbaum $T$, Gewicht 6}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
\noindent\textbf{Bild 2 -- die ungeraden Knoten.} Man zählt die Grade im Baum:
|
|
$A$ hat Grad 2 (gerade), alle anderen ungerade. Die ungeraden Knoten
|
|
$X = \{B,C,D,E\}$ sind mit einem Ring markiert.
|
|
\begin{center}
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{picture}(5.2,3.4)(-0.3,-0.3)
|
|
\put(0.5,2.2){\circle*{0.14}}\put(0.05,2.25){\small $A$}
|
|
\put(0.5,0.3){\circle*{0.14}}\put(0.05,0.15){\small $B$}\put(0.5,0.3){\circle{0.34}}
|
|
\put(2.6,1.3){\circle*{0.14}}\put(2.35,1.5){\small $C$}\put(2.6,1.3){\circle{0.34}}
|
|
\put(4.6,1.3){\circle*{0.14}}\put(4.75,1.3){\small $D$}\put(4.6,1.3){\circle{0.34}}
|
|
\put(2.6,3.0){\circle*{0.14}}\put(2.75,3.0){\small $E$}\put(2.6,3.0){\circle{0.34}}
|
|
\linethickness{1.3pt}
|
|
\qbezier(0.5,2.2)(1.55,2.6)(2.6,3.0)
|
|
\qbezier(0.5,0.3)(1.55,0.8)(2.6,1.3)
|
|
\qbezier(0.5,2.2)(1.55,1.75)(2.6,1.3)
|
|
\put(2.6,1.3){\line(1,0){2.0}}
|
|
\put(-0.3,-0.2){\small ungerade Grade: $X=\{B,C,D,E\}$}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
\noindent\textbf{Bild 3 -- das Matching.} Die billigste Paarung der vier Knoten
|
|
ist $\{B\text{--}C, D\text{--}E\}$ mit Kosten $1+2 = 3$. Diese zwei
|
|
Matching-Kanten (dünn) kommen zum Baum dazu -- jetzt haben alle Knoten geraden
|
|
Grad.
|
|
\begin{center}
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{picture}(5.2,3.4)(-0.3,-0.3)
|
|
\put(0.5,2.2){\circle*{0.14}}\put(0.05,2.25){\small $A$}
|
|
\put(0.5,0.3){\circle*{0.14}}\put(0.05,0.15){\small $B$}
|
|
\put(2.6,1.3){\circle*{0.14}}\put(2.35,1.5){\small $C$}
|
|
\put(4.6,1.3){\circle*{0.14}}\put(4.75,1.3){\small $D$}
|
|
\put(2.6,3.0){\circle*{0.14}}\put(2.75,3.0){\small $E$}
|
|
\linethickness{1.3pt}
|
|
\qbezier(0.5,2.2)(1.55,2.6)(2.6,3.0)
|
|
\qbezier(0.5,0.3)(1.55,0.8)(2.6,1.3)
|
|
\qbezier(0.5,2.2)(1.55,1.75)(2.6,1.3)
|
|
\put(2.6,1.3){\line(1,0){2.0}}
|
|
\linethickness{0.4pt}
|
|
\qbezier(0.6,0.25)(1.65,0.72)(2.7,1.22)\put(1.7,0.35){\small $M$}
|
|
\qbezier(4.6,1.3)(3.6,2.15)(2.6,3.0)\put(3.7,2.2){\small $M$}
|
|
\put(-0.3,-0.2){\small $+$ Matching $\{B\text{--}C, D\text{--}E\}$, Kosten 3}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
\noindent\textbf{Bild 4 -- Eulerkreis und abkürzen.} Aus $T + M$ gewinnt man
|
|
einen Eulerkreis und kürzt ihn ab. Ergebnis: Tour $[C,B,A,E,D,C]$ mit Länge 9 --
|
|
besser als die 10 von $\Delta$TSP$_1$.
|
|
\begin{center}
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{picture}(5.2,3.4)(-0.3,-0.3)
|
|
\put(0.5,2.2){\circle*{0.14}}\put(0.05,2.25){\small $A$}
|
|
\put(0.5,0.3){\circle*{0.14}}\put(0.05,0.15){\small $B$}
|
|
\put(2.6,1.3){\circle*{0.14}}\put(2.35,1.5){\small $C$}
|
|
\put(4.6,1.3){\circle*{0.14}}\put(4.75,1.3){\small $D$}
|
|
\put(2.6,3.0){\circle*{0.14}}\put(2.75,3.0){\small $E$}
|
|
\linethickness{1.1pt}
|
|
\qbezier(2.6,1.3)(1.55,0.8)(0.5,0.3)
|
|
\put(0.5,0.3){\line(0,1){1.9}}
|
|
\qbezier(0.5,2.2)(1.55,2.6)(2.6,3.0)
|
|
\qbezier(2.6,3.0)(3.6,2.15)(4.6,1.3)
|
|
\put(4.6,1.3){\line(-1,0){2.0}}
|
|
\put(0.1,-0.2){\small Tour $[C,B,A,E,D,C]$, Länge $9 \le 1{,}5\cdot\OPT$}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
\begin{idee}{Die Güte $1{,}5$ -- warum das Matching $\le \OPT/2$ kostet}
|
|
Die Tour hat Länge $w(T) + d(M) \le \OPT + d(M)$. Der Kern ist die Abschätzung
|
|
$d(M) \le \OPT/2$: Betrachtet man die ungeraden Knoten $X$ in der Reihenfolge
|
|
einer optimalen Tour, so bilden sie \emph{zwei} sich abwechselnde Matchings
|
|
$M_1, M_2$. Wegen der Dreiecksungleichung ist $\OPT \ge d(M_1) + d(M_2) \ge 2\,
|
|
d(M)$, da $M$ das \emph{minimale} perfekte Matching ist. Also $d(M) \le \OPT/2$
|
|
und die Tour $\le w(T) + \OPT/2 \le 1{,}5\,\OPT$.
|
|
\end{idee}
|
|
|
|
\begin{stolper}
|
|
Zwei Dinge werden oft falsch gemacht: Das Matching läuft \emph{nur} über die
|
|
ungerad-gradigen Knoten des Spannbaums, nicht über alle. Und ohne die
|
|
Dreiecksungleichung bricht das Abkürzen zusammen.
|
|
\end{stolper}
|
|
|
|
% ==================================================================
|
|
\section{Knapsack: Greedy}
|
|
% ==================================================================
|
|
|
|
Beim Rucksack als Optimierungsproblem packt man Gegenstände mit maximalem
|
|
Gesamtprofit ein, ohne die Kapazität $B$ zu überschreiten. Wir behandeln vier
|
|
Verfahren, jedes einzeln.
|
|
|
|
\begin{idee}{Greedy}
|
|
Sortiere die Gegenstände nach \glqq Profit pro Gewicht\grqq{} (Profitdichte
|
|
$p_i/w_i$) und pack der Reihe nach ein, was noch passt.
|
|
\end{idee}
|
|
|
|
\begin{satz}{Greedy hat \emph{keine} beschränkte Güte}
|
|
Das Verhältnis $\OPT/\mathrm{GA}$ kann beliebig groß werden.\\[0.3em]
|
|
\emph{Gegenbeispiel:} Ein Gegenstand mit Gewicht 1 und Profit 1, ein anderer mit
|
|
Gewicht $B$ und Profit $B-1$, Kapazität $B$. Greedy schaut auf die Dichte -- der
|
|
kleine hat Dichte 1, der große $(B-1)/B < 1$ -- und nimmt den kleinen, Profit 1.
|
|
Optimal wäre der große mit Profit $B-1$. Das Verhältnis $B-1$ wächst mit $B$ ins
|
|
Unendliche.
|
|
\end{satz}
|
|
|
|
% ==================================================================
|
|
\section{Knapsack: Modified Greedy}
|
|
% ==================================================================
|
|
|
|
\begin{idee}{Modified Greedy (MGA)}
|
|
Rechne zwei Kandidaten aus -- das Greedy-Ergebnis \emph{und} \glqq nimm nur den
|
|
einen profitabelsten Gegenstand\grqq{} -- und gib den besseren aus.
|
|
\end{idee}
|
|
|
|
\begin{satz}{MGA hat Güte 2}
|
|
$\OPT \le 2\,\mathrm{MGA}$ für alle Instanzen.\\[0.3em]
|
|
\emph{Die zentrale Ungleichungskette:} Man betrachtet die \emph{fraktionale}
|
|
Relaxierung, in der man Gegenstände auch anteilig einpacken darf; ihr Optimum
|
|
$\OPT_f$ ist mindestens $\OPT$. Die fraktionale Lösung packt die Gegenstände nach
|
|
Dichte, bis das erste nicht mehr ganz passt -- dieses \glqq Split-Item\grqq{}
|
|
$k+1$ wird anteilig genommen. Damit gilt
|
|
\[
|
|
\OPT \le \OPT_f \le \mathrm{GA} + p_{k+1} \le \mathrm{GA} + p_{\max}
|
|
\le 2\cdot\max\{\mathrm{GA}, p_{\max}\} = 2\,\mathrm{MGA}.
|
|
\]
|
|
Greedy verliert also seinen Rückstand nur an dem einen Split-Item, und dessen
|
|
Profit fängt der zweite Kandidat (bestes Einzel-Item) ab.
|
|
\end{satz}
|
|
|
|
% ==================================================================
|
|
\section{Knapsack: Sahni-Algorithmus}
|
|
% ==================================================================
|
|
|
|
\begin{idee}{Sahni ($k$-Enumeration)}
|
|
Probiere \emph{alle} Vorauswahlen von höchstens $k$ Gegenständen durch. Fülle
|
|
jede Vorauswahl mit Greedy auf und gib die beste Gesamtlösung aus.
|
|
\end{idee}
|
|
|
|
\begin{satz}{Sahni ist ein PTAS}
|
|
Der Sahni-Algorithmus erreicht Güte $1 + 1/k$ bei Laufzeit $O(n^{k+1})$.\\[0.3em]
|
|
Je größer $k$, desto besser die Garantie ($k=2$ gibt $3/2$, $k=3$ gibt $4/3$),
|
|
aber desto teurer die Laufzeit. Für festes $k$ ist sie polynomiell -- also genau
|
|
ein PTAS. Modified Greedy ist der Spezialfall, in dem man das beste Einzel-Item
|
|
vorwählt.
|
|
\end{satz}
|
|
|
|
% ==================================================================
|
|
\section{Knapsack: FPTAS}
|
|
% ==================================================================
|
|
|
|
\begin{idee}{FPTAS durch Profit-Skalierung}
|
|
Runde die Profite auf gröbere Werte ab (teile durch ein passendes $K$ und runde),
|
|
löse das gröbere Problem \emph{exakt} mit dynamischer Programmierung, und gib
|
|
diese Lösung aus.
|
|
\end{idee}
|
|
|
|
\begin{satz}{FPTAS für Knapsack}
|
|
Das Verfahren erreicht Güte $1 + \varepsilon$ bei Laufzeit $O(n^3/\varepsilon)$.
|
|
\\[0.3em]
|
|
\emph{Die zwei zentralen Ungleichungen:} Mit skalierten Profiten
|
|
$p_i' = \lfloor p_i/K \rfloor$ gilt (1) $\OPT \le K\cdot\OPT(I_K) + Kn$ -- durch
|
|
das Abrunden verliert jedes Item höchstens $K$, bei $\le n$ Items also $\le Kn$
|
|
gesamt; und (2) $K\cdot\OPT(I_K) \le A_K(I)$ -- die skalierte Lösung ist nicht
|
|
schlechter. Zusammen $\OPT \le A_K + Kn$, und mit $\OPT \ge p_{\max}$ und der
|
|
Wahl von $K$ folgt der relative Fehler $\le \varepsilon$. Das exakte
|
|
DP ist pseudopolynomiell ($O(n^2 p'_{\max})$); durch das Abrunden werden die
|
|
Werte klein genug, dass die Laufzeit $O(n^3/\varepsilon)$ wird.
|
|
\end{satz}
|
|
|
|
% ==================================================================
|
|
\section{Scheduling: List Scheduling}
|
|
% ==================================================================
|
|
|
|
Zurück zu $P\|\Cmax$: $n$ Jobs auf $m$ Maschinen, minimiere die höchste Last.
|
|
|
|
\begin{idee}{List Scheduling}
|
|
Gehe die Jobs in ihrer gegebenen Reihenfolge durch und lege jeden Job auf die
|
|
Maschine, die im Moment die \emph{kleinste} Last hat.
|
|
\end{idee}
|
|
|
|
Das folgende Gantt-Bild zeigt an drei Jobs der Größen $1,1,2$ auf zwei
|
|
Maschinen, warum die Reihenfolge zählt. Oben List Scheduling (Makespan 3), unten
|
|
die optimale Verteilung (Makespan 2). Die Balkenlänge ist die Zeit.
|
|
\begin{center}
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{picture}(9,4)(-1.6,-0.5)
|
|
\put(0,-0.1){\vector(1,0){4.2}}\put(3.9,-0.5){\small Zeit}
|
|
\multiput(0,-0.18)(1,0){4}{\line(0,1){0.12}}
|
|
\put(-0.05,-0.5){\small 0}\put(0.95,-0.5){\small 1}\put(1.95,-0.5){\small 2}\put(2.95,-0.5){\small 3}
|
|
\put(-1.6,3.1){\small \textbf{List Scheduling} (Reihenfolge $1,1,2$):}
|
|
\put(-1.3,2.4){\small $M_1$}
|
|
\put(0,2.2){\framebox(1,0.6){\small $1$}}
|
|
\put(1,2.2){\framebox(2,0.6){\small $2$}}
|
|
\put(-1.3,1.5){\small $M_2$}
|
|
\put(0,1.3){\framebox(1,0.6){\small $1$}}
|
|
\put(3.3,2.3){\small Makespan $3$}
|
|
\put(-1.6,0.85){\small \textbf{optimal}:}
|
|
\put(-1.3,0.3){\small $M_1$}
|
|
\put(0,0.1){\framebox(2,0.6){\small $2$}}
|
|
\put(2.3,0.2){\small Makespan $2$}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
\begin{satz}{List Scheduling hat Güte $2 - \tfrac1m$ (scharf)}
|
|
\emph{Die Idee:} Betrachte die Maschine mit der höchsten Last $L$ und den
|
|
\emph{letzten} Job $J_k$, der auf ihr landete. In dem Moment, als $J_k$
|
|
zugewiesen wurde, war diese Maschine die \emph{leerste} -- also waren alle
|
|
Maschinen mindestens so voll wie $L - p_k$. Daraus folgt
|
|
$\sum p_i \ge m(L - p_k) + p_k$. Mit den beiden \emph{Universalschranken}
|
|
$\OPT \ge \frac1m\sum p_i$ (die Last verteilt sich auf $m$ Maschinen) und
|
|
$\OPT \ge p_k$ (der Job muss irgendwo laufen) ergibt sich
|
|
$L = \mathrm{LS}(I) \le (2 - \frac1m)\,\OPT$.
|
|
\end{satz}
|
|
|
|
\begin{intuition}
|
|
\textbf{Der schlimmste Fall:} $m(m-1)$ Jobs der Größe 1, danach \emph{ein} Job
|
|
der Größe $m$. List Scheduling verteilt die Einsen gleichmäßig (je $m-1$) und
|
|
setzt den großen Job obendrauf: Last $2m-1$. Optimal wäre $m$ (großer Job
|
|
allein). Das Verhältnis $\frac{2m-1}{m} = 2 - \frac1m$ erreicht die Schranke
|
|
exakt.
|
|
\end{intuition}
|
|
|
|
% ==================================================================
|
|
\section{Scheduling: LPT}
|
|
% ==================================================================
|
|
|
|
\begin{idee}{LPT (Longest Processing Time first)}
|
|
Sortiere die Jobs zuerst \emph{absteigend} nach Laufzeit -- die längsten zuerst
|
|
-- und wende darauf List Scheduling an.
|
|
\end{idee}
|
|
|
|
Der einzige Unterschied zu List Scheduling ist die Sortierung. Sie sorgt dafür,
|
|
dass die großen Jobs früh verteilt werden, solange die Maschinen noch leer sind.
|
|
|
|
\begin{satz}{LPT hat Güte $\tfrac43 - \tfrac1{3m}$ (scharf)}
|
|
\emph{Die Idee (minimales Gegenbeispiel):} Man betrachtet ein kleinstes
|
|
Gegenbeispiel -- eine Instanz mit möglichst wenigen Jobs, bei der LPT die
|
|
Schranke verletzt. In so einer minimalen Instanz muss der \emph{letzte} (also
|
|
kleinste) Job $J_n$ den Makespan bestimmen; täte er es nicht, könnte man ihn
|
|
weglassen und hätte ein noch kleineres Gegenbeispiel.
|
|
\end{satz}
|
|
|
|
Aus der Annahme, dass LPT die Schranke $\tfrac43 - \tfrac1{3m}$ verletzt, rechnet
|
|
man dann $p_n > \OPT/3$ heraus. Das ist eine starke Aussage: Wenn schon der
|
|
kleinste Job größer als ein Drittel des Optimums ist, kann im \emph{optimalen}
|
|
Schedule keine Maschine mehr als zwei Jobs tragen (drei Jobs à $> \OPT/3$ ergäben
|
|
$> \OPT$).
|
|
|
|
Nun formt man den optimalen Schedule schrittweise in den LPT-Schedule um. Jeder
|
|
Schritt ist ein \emph{Austausch} zweier Jobs zwischen zwei Maschinen -- man
|
|
tauscht so, dass die Reihenfolge Stück für Stück der von LPT gleicht. Man weist
|
|
für jeden solchen Austausch nach, dass der Makespan dabei \emph{nie steigt}
|
|
(weil bei höchstens zwei Jobs pro Maschine ein Tausch die stärker belastete
|
|
Maschine nur entlasten kann). Am Ende steht ein LPT-Schedule mit dem Makespan des
|
|
Optimums, also $\mathrm{LPT} = \OPT$ -- im Widerspruch dazu, dass die Instanz ein
|
|
Gegenbeispiel war. Damit kann es kein Gegenbeispiel geben, und die Schranke gilt.
|
|
|
|
% ==================================================================
|
|
\section{MAX-3-SAT: Güte 2 mit zwei Belegungen}
|
|
% ==================================================================
|
|
|
|
\begin{idee}{Zwei komplementäre Belegungen}
|
|
Beim Optimierungsproblem MAX-3-SAT will man möglichst viele Klauseln erfüllen.
|
|
Der Algorithmus wertet die Formel nur \emph{zweimal} aus -- einmal mit \glqq alle
|
|
Variablen falsch\grqq{} ($\beta_0$), einmal mit \glqq alle wahr\grqq{}
|
|
($\beta_1$) -- und gibt die bessere zurück.
|
|
\end{idee}
|
|
|
|
\begin{satz}{Der Algorithmus hat Güte 2}
|
|
$v(A(\varphi)) \ge \tfrac12\, v(\OPT(\varphi))$.\\[0.3em]
|
|
\emph{Die zentrale Beobachtung:} Jede Klausel enthält mindestens ein Literal --
|
|
ist es positiv, wird die Klausel von $\beta_1$ erfüllt; ist es negativ, von
|
|
$\beta_0$. Jede Klausel wird also von \emph{mindestens einer} der beiden
|
|
Belegungen erfüllt, folglich $v(\beta_0) + v(\beta_1) \ge m$. Die bessere von
|
|
beiden erfüllt somit $\ge m/2$ Klauseln. Da eine optimale Belegung höchstens alle
|
|
$m$ Klauseln erfüllt ($\OPT \le m$), ist $v(A) \ge m/2 \ge \OPT/2$.
|
|
\end{satz}
|
|
|
|
\begin{intuition}
|
|
\textbf{Der schlimmste Fall} baut man aus komplementären Klauseln, etwa
|
|
$\varphi = (x_1 \vee x_2 \vee x_3) \wedge (\neg x_0 \vee \neg x_2 \vee \neg x_3)$.
|
|
Beide Klauseln sind gemeinsam erfüllbar ($\OPT = 2$), aber $\beta_1$ erfüllt nur
|
|
die erste und $\beta_0$ nur die zweite -- der Algorithmus erreicht also nur
|
|
$1 = \OPT/2$.
|
|
\end{intuition}
|
|
|
|
% ==================================================================
|
|
\section{2-Approximation für Vertex Cover}
|
|
% ==================================================================
|
|
|
|
\begin{idee}{Unüberdeckte Kanten voll aufnehmen}
|
|
Solange es eine noch unüberdeckte Kante gibt, nimm \emph{beide} ihre Endpunkte
|
|
ins Vertex Cover auf.
|
|
\end{idee}
|
|
|
|
\begin{satz}{Der Algorithmus hat Güte 2}
|
|
$|C| \le 2\,|C^*|$, wobei $C^*$ ein optimales Vertex Cover ist.\\[0.3em]
|
|
\emph{Die Idee (Optimum von unten über ein Matching):} Sei $A$ die Menge der
|
|
Kanten, für die der Algorithmus beide Endpunkte genommen hat; dann ist
|
|
$|C| = 2|A|$. Die Kanten in $A$ sind paarweise \emph{knotendisjunkt} -- sobald
|
|
eine Kante genommen wurde, waren ihre Endpunkte überdeckt, eine spätere Kante aus
|
|
$A$ kann sie also nicht berühren. $A$ ist damit ein \emph{Matching}. Jedes Vertex
|
|
Cover muss für jede Matching-Kante einen \emph{eigenen} Knoten stellen, also
|
|
$|C^*| \ge |A|$. Zusammen: $|C| = 2|A| \le 2|C^*|$.
|
|
\end{satz}
|
|
|
|
\begin{intuition}
|
|
Das Muster \glqq Optimum von unten durch ein Matching abschätzen\grqq{} ist eines
|
|
der drei Standard-Argumente für Güte-Beweise. Die anderen beiden sind
|
|
\glqq Widerspruch und Zählen\grqq{} (wie bei MAX-3-SAT) und \glqq die zwei
|
|
Universalschranken\grqq{} (wie beim Scheduling).
|
|
\end{intuition}
|
|
|
|
% ==================================================================
|
|
\section{Zum Schluss}
|
|
% ==================================================================
|
|
|
|
Du hast jetzt das gesamte Fundament der Vorlesung beisammen -- und zwar
|
|
vollständig, nicht in Stichworten. Für jedes Problem des Katalogs weißt du, wie
|
|
es definiert ist, warum es in $\NP$ liegt, woher seine Schwere kommt und welche
|
|
Reduktionen von ihm ausgehen. Du kennst die ETH und das Schema, mit dem man
|
|
untere Schranken herleitet. Und du kennst jeden Approximationsalgorithmus mit
|
|
seiner Güte und der Idee des Güte-Beweises.
|
|
|
|
\begin{aha}
|
|
Der rote Faden war die \emph{Reduktion}. Sie verbindet alle Probleme zu einer
|
|
einzigen Familie: Von \problem{SAT} aus fließt die Schwere über die ganze
|
|
Landkarte, und dieselbe Idee -- \glqq bekannt $\redp$ neu\grqq{} -- trägt in der
|
|
ETH sogar konkrete untere Schranken. Wo exakte Lösungen zu teuer werden, springt
|
|
die Approximation ein und rettet mit beweisbaren Garantien, was zu retten ist.
|
|
Das ist die ganze Geschichte des Kurses.
|
|
\end{aha}
|
|
|
|
\noindent\textbf{Der nächste Schritt.} Dieses Heft gibt dir das Verständnis. Um
|
|
es in Können zu verwandeln, rechne die Präsenz-, Haus- und Klausuraufgaben und
|
|
führe dort selbst aus, was hier als Idee steht: Reduktionen vollständig beweisen
|
|
(beide Richtungen!), Güte-Schranken herleiten, Worst-Case-Instanzen bauen. Viel
|
|
Erfolg.
|
|
|
|
\end{document}
|