2846 lines
131 KiB
TeX
2846 lines
131 KiB
TeX
\documentclass[11pt]{article}
|
|
\input{style_guide.tex}
|
|
|
|
\linespread{1.06}
|
|
\setlength{\parskip}{0.5em}
|
|
|
|
\title{\textbf{\Huge Komplexität von Grund auf}\\[0.5em]
|
|
\large Alle Probleme, alle Reduktionen, alle Ideen -- ausführlich\\
|
|
\normalsize \textit{Analyse von Algorithmen und Komplexität} -- CAU Kiel, SS 2026}
|
|
\author{}
|
|
\date{}
|
|
|
|
\begin{document}
|
|
\maketitle
|
|
\thispagestyle{empty}
|
|
|
|
\begin{center}\itshape\large
|
|
Jedes Problem für sich. Jede Reduktion mit ihrer Idee.\\
|
|
Nichts abgekürzt, nichts zusammengelegt.
|
|
\end{center}
|
|
|
|
\vfill
|
|
|
|
\noindent\textbf{Worum es geht.}
|
|
Dieses Heft enthält das komplette Fundament der Vorlesung. Sein Kernstück ist
|
|
ein Katalog, der jedes Problem des Kurses in vier Schritten behandelt:
|
|
\begin{enumerate}
|
|
\item \textbf{Was gefragt ist} -- die Definition, mit einem kleinen Beispiel;
|
|
\item \textbf{warum das Problem in $\NP$ liegt} -- als ausgeschriebene
|
|
Erklärung: welches Zertifikat, wie geprüft wird, warum das in beide Richtungen
|
|
stimmt, wie lange es dauert;
|
|
\item \textbf{wo die Schwere herkommt} -- die Reduktion, die das Problem hart
|
|
macht, samt der Idee ihrer Konstruktion;
|
|
\item \textbf{wohin die Schwere weiterfließt} -- jede Reduktion, die vom Problem
|
|
ausgeht, mit ihrer eigenen Idee.
|
|
\end{enumerate}
|
|
Danach folgen die unteren Schranken (ETH) und die Approximationsalgorithmen --
|
|
beides ebenfalls mit den Beweis-Ideen, Problem für Problem und Algorithmus für
|
|
Algorithmus.
|
|
|
|
\medskip
|
|
\noindent\textbf{Zwei Grundsätze.}
|
|
Ähnliche Dinge werden hier trotzdem \emph{getrennt} behandelt -- jedes Problem
|
|
hat seinen eigenen Abschnitt, jeder Nachweis wird eigenständig geführt. Und
|
|
nichts wird mit \glqq das sieht man leicht\grqq{} übergangen: Wo eine Idee
|
|
gebraucht wird, steht sie auch da.
|
|
|
|
\medskip
|
|
\noindent\textbf{Die Kästen im Heft.}
|
|
\begin{center}\small
|
|
\begin{tabular}{ll}
|
|
\ding{72}~Intuition & der Gedanke hinter dem Formalen\\
|
|
\ding{43}~Analogie & ein Alltagsbild\\
|
|
\ding{110}~Definition & die präzise Fassung\\
|
|
\ding{115}~Satz & ein Ergebnis samt erklärter Beweisidee\\
|
|
\ding{108}~Beispiel & konkret durchgerechnet\\
|
|
\ding{43}~Idee & die Konstruktion hinter einer Reduktion oder einem Beweis\\
|
|
\ding{73}~Aha & die Pointe\\
|
|
\ding{55}~Stolperstein & wo Fehler passieren\\
|
|
\ding{228}~Zusammenhang & die Verbindung zum Rest\\
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
\vfill
|
|
\newpage
|
|
\tableofcontents
|
|
\newpage
|
|
|
|
% ##################################################################
|
|
\part*{Teil A -- Die Grundlagen}
|
|
\addcontentsline{toc}{section}{\textbf{Teil A -- Die Grundlagen}}
|
|
% ##################################################################
|
|
|
|
% ==================================================================
|
|
\section{Der Ausgangspunkt: ein widerspenstiges Problem}
|
|
% ==================================================================
|
|
|
|
Jede Theorie braucht einen Anlass. Unserer ist ein Problem, das sich mit einem
|
|
Satz erklären lässt und trotzdem seit Jahrzehnten jedem schnellen Algorithmus
|
|
widersteht.
|
|
|
|
Ein \emph{Graph} besteht aus Punkten -- den \emph{Knoten} -- und
|
|
Verbindungslinien dazwischen, den \emph{Kanten}. Eine \emph{Clique} ist eine
|
|
Gruppe von Knoten, in der jeder mit jedem verbunden ist. Die Frage \glqq Gibt es
|
|
im Graphen eine Clique aus $k$ Knoten?\grqq{} ist das \emph{Cliquenproblem}.
|
|
|
|
\begin{bsp}{Cliquen in einem kleinen Graphen}
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{center}
|
|
\begin{picture}(5,2.9)(-0.6,-0.5)
|
|
\put(0,0.9){\circle*{0.15}}\put(-0.5,0.85){\small $a$}
|
|
\put(1.3,2.2){\circle*{0.15}}\put(1.2,2.4){\small $b$}
|
|
\put(2.6,0.9){\circle*{0.15}}\put(2.75,0.85){\small $c$}
|
|
\put(1.3,-0.2){\circle*{0.15}}\put(1.2,-0.55){\small $d$}
|
|
\put(3.9,1.8){\circle*{0.15}}\put(4.05,1.75){\small $e$}
|
|
\qbezier(0,0.9)(0.65,1.55)(1.3,2.2)
|
|
\put(0,0.9){\line(1,0){2.6}}
|
|
\qbezier(1.3,2.2)(1.95,1.55)(2.6,0.9)
|
|
\qbezier(0,0.9)(0.65,0.35)(1.3,-0.2)
|
|
\qbezier(2.6,0.9)(3.25,1.35)(3.9,1.8)
|
|
\end{picture}
|
|
\end{center}
|
|
Die Knoten $a$, $b$, $c$ sind paarweise verbunden -- eine Clique der Größe 3.
|
|
Die Gruppe $\{a, c, d\}$ dagegen nicht: Zwischen $c$ und $d$ fehlt die
|
|
Verbindung. Eine Clique aus vier Knoten gibt es in diesem Graphen nicht.
|
|
\end{bsp}
|
|
|
|
Wie findet ein Computer eine $k$-Clique? Der offensichtliche Weg: alle
|
|
Knotengruppen der Größe $k$ durchgehen und jede prüfen. Das funktioniert -- aber
|
|
die Anzahl der Gruppen explodiert. Bei $n$ Knoten und $k = n/2$ sind es
|
|
mindestens $2^{n/2}$ Stück. Jeder weitere Knoten \emph{verdoppelt} den Aufwand
|
|
ungefähr. Diese Wachstumsart heißt \emph{exponentiell}, und sie ist durch keine
|
|
Hardware der Welt einzuholen: Ein doppelt so schneller Rechner schafft genau
|
|
\emph{einen} Knoten mehr.
|
|
|
|
\begin{bsp}{Was exponentiell bedeutet}
|
|
\begin{center}
|
|
\begin{tabular}{rrl}
|
|
\toprule
|
|
Knoten $n$ & Gruppen (mind.) & Einordnung\\
|
|
\midrule
|
|
$20$ & rund tausend & sofort fertig\\
|
|
$40$ & rund eine Million & unter einer Sekunde\\
|
|
$100$ & rund $10^{15}$ & Wochen bis Monate\\
|
|
$200$ & rund $10^{30}$ & länger als das Alter des Universums\\
|
|
\bottomrule
|
|
\end{tabular}
|
|
\end{center}
|
|
Zwischen $n = 100$ und $n = 200$ liegt kein Faktor 2, sondern ein Faktor
|
|
$10^{15}$.
|
|
\end{bsp}
|
|
|
|
\begin{aha}
|
|
Niemand hat je einen schnellen Algorithmus für die Clique gefunden -- aber
|
|
niemand hat bewiesen, dass es keinen gibt. Die Komplexitätstheorie macht aus
|
|
dieser Verlegenheit ein Programm. Sie fragt nicht \glqq wie knackt man dieses
|
|
eine Problem?\grqq, sondern \glqq welche Probleme hängen so zusammen, dass sie
|
|
alle gemeinsam stehen oder fallen?\grqq{} Auf diese Frage gibt es präzise
|
|
Antworten, und sie füllen diesen Kurs.
|
|
\end{aha}
|
|
|
|
% ==================================================================
|
|
\section{Die Klasse P: was \glqq schnell\grqq{} heißen soll}
|
|
% ==================================================================
|
|
|
|
Bevor man über schwere Probleme redet, muss man festlegen, was \glqq leicht\grqq{}
|
|
ist. Zwei Vereinbarungen tragen alles Weitere.
|
|
|
|
\emph{Erstens:} Laufzeit misst man in Abhängigkeit von der Eingabegröße $n$ --
|
|
zehn Zahlen sortieren ist etwas anderes als zehn Millionen. Und man nimmt den
|
|
\emph{schlimmsten Fall} über alle Eingaben einer Größe, denn eine Garantie, die
|
|
nur \glqq meistens\grqq{} hält, ist keine.
|
|
|
|
\emph{Zweitens:} Als \glqq schnell\grqq{} gilt eine Laufzeit, die höchstens wie
|
|
eine feste Potenz von $n$ wächst.
|
|
|
|
\begin{defn}{Die Klasse P}
|
|
$\Pclass$ ist die Menge aller Entscheidungsprobleme, die sich durch einen
|
|
Algorithmus mit \emph{polynomieller} Laufzeit lösen lassen -- also $O(n^d)$ für
|
|
eine Konstante $d$.
|
|
\end{defn}
|
|
|
|
\begin{intuition}
|
|
Warum ausgerechnet \glqq polynomiell\grqq? Weil an dieser Grenze der
|
|
qualitative Sprung passiert. Polynome wachsen zahm: $n^2$ bei doppelter Eingabe
|
|
vervierfacht sich nur. Exponentialfunktionen wie $2^n$ \emph{verdoppeln} sich
|
|
bei jedem einzelnen Schritt von $n$. Außerdem ist die Grenze robust -- sie
|
|
bleibt dieselbe, egal ob man einen realen Rechner, eine Turingmaschine oder ein
|
|
anderes vernünftiges Maschinenmodell zugrunde legt.
|
|
\end{intuition}
|
|
|
|
Ein \emph{Entscheidungsproblem} verlangt als Antwort nur Ja oder Nein. Aus
|
|
\glqq finde die größte Clique\grqq{} wird \glqq gibt es eine Clique mit
|
|
mindestens $k$ Knoten?\grqq{} -- wer diese Frage für jedes $k$ beantworten kann,
|
|
kennt auch das Maximum. Formal ist ein Problem einfach die Menge seiner
|
|
Ja-Eingaben. In $\Pclass$ liegen zum Beispiel: Sortieren, kürzeste Wege,
|
|
minimale Spannbäume, Matchings.
|
|
|
|
\begin{stolper}
|
|
\textbf{Vorsicht bei Zahlen in der Eingabe.} Eine Zahl $K$ belegt als Eingabe
|
|
nur etwa $\log K$ Zeichen -- ihre Ziffern. Ihr \emph{Wert} ist demgegenüber
|
|
exponentiell groß. Ein Verfahren, das $K$-mal iteriert, braucht also
|
|
exponentiell viele Schritte \emph{gemessen an der Eingabelänge}. Dieser
|
|
unscheinbare Punkt erklärt später, warum Probleme über Zahlen (SubSet Sum,
|
|
Partition, Knapsack) schwer sein können, obwohl man dort \glqq nur addiert\grqq.
|
|
\end{stolper}
|
|
|
|
% ==================================================================
|
|
\section{Die Klasse NP: Lösungen prüfen statt finden}
|
|
% ==================================================================
|
|
|
|
Die zweite Klasse entsteht aus einer Alltagsbeobachtung: Es ist etwas völlig
|
|
anderes, eine Lösung zu \emph{suchen}, als eine vorgelegte Lösung zu
|
|
\emph{kontrollieren}.
|
|
|
|
\begin{analogie}
|
|
Denk an ein Kreuzworträtsel. Es auszufüllen kann einen Abend dauern. Aber wenn
|
|
dir jemand ein fertig ausgefülltes Gitter zeigt, siehst du in zwei Minuten, ob
|
|
alles passt -- du liest jede Zeile und vergleichst mit den Fragen. Suchen ist
|
|
teuer, Kontrollieren ist billig. $\NP$ ist die Klasse der Probleme, bei denen
|
|
wenigstens das \emph{Kontrollieren} billig ist.
|
|
\end{analogie}
|
|
|
|
\subsection{Zertifikate und Verifizierer}
|
|
|
|
Die vorgelegte Lösung heißt in der Theorie \emph{Zertifikat}; der Kontrolleur
|
|
heißt \emph{Verifizierer}.
|
|
|
|
\begin{defn}{Verifizierer und Zertifikat}
|
|
Ein \emph{Verifizierer} für ein Problem $L$ ist ein Algorithmus $A$ mit zwei
|
|
Eingaben -- der Instanz $x$ und einem Vorschlag $c$ --, für den gilt:
|
|
\[
|
|
x \in L \iff \text{es existiert ein } c \text{ mit } A(x,c) = 1.
|
|
\]
|
|
Ein solches $c$ heißt \emph{Zertifikat} für $x$.
|
|
\end{defn}
|
|
|
|
Beide Richtungen dieser Gleichwertigkeit tragen Gewicht. Für eine Ja-Instanz
|
|
\emph{muss es} einen Vorschlag geben, den $A$ gutheißt. Für eine Nein-Instanz
|
|
darf $A$ sich von \emph{keinem} Vorschlag überzeugen lassen -- sonst würde er
|
|
falsche Ja-Antworten produzieren.
|
|
|
|
\begin{defn}{Die Klasse NP}
|
|
$\NP$ enthält genau die Probleme mit einem \emph{polynomiellen} Verifizierer:
|
|
Für jede Ja-Instanz $x$ gibt es ein Zertifikat, mit dem der Verifizierer in
|
|
polynomieller Zeit -- gemessen an $|x|$ -- akzeptiert.
|
|
\end{defn}
|
|
|
|
\subsection{Dieselbe Klasse über das Raten}
|
|
|
|
Es gibt eine zweite Beschreibung von $\NP$, die in Beweisen oft bequemer ist.
|
|
Man stellt sich eine Maschine vor, die an jeder Weggabelung \emph{beide} Wege
|
|
gleichzeitig weiterverfolgt -- eine \emph{nichtdeterministische} Maschine. Sie
|
|
akzeptiert eine Eingabe, sobald auch nur \emph{einer} ihrer vielen parallelen
|
|
Rechenwege akzeptiert; bei einer Nein-Instanz scheitern alle Wege.
|
|
|
|
Der Zusammenhang zur ersten Sicht ist eng: Das Protokoll der Rate-Entscheidungen
|
|
eines akzeptierenden Weges \emph{ist} ein Zertifikat, und umgekehrt kann die
|
|
Maschine ein Zertifikat einfach \glqq erraten\grqq{} und danach deterministisch
|
|
prüfen. \glqq Rate die Lösung, prüfe sie\grqq{} -- nach diesem Muster laufen alle
|
|
NP-Nachweise über Maschinen. Beide Sichtweisen beschreiben exakt dieselbe
|
|
Klasse.
|
|
|
|
\subsection{Das Verhältnis von P und NP}
|
|
|
|
\begin{satz}{$\Pclass \subseteq \NP$}
|
|
Jedes Problem aus $\Pclass$ liegt auch in $\NP$.\\[0.3em]
|
|
\emph{Warum:} Ein Algorithmus, der das Problem selbst löst, kann als
|
|
Verifizierer arbeiten, der seinen Vorschlag gar nicht ansieht -- er berechnet
|
|
die Antwort einfach selbst. Schneller prüfen als lösen kann man immer.
|
|
\end{satz}
|
|
|
|
Ob umgekehrt $\NP \subseteq \Pclass$ gilt -- ob also alles effizient
|
|
Kontrollierbare auch effizient lösbar ist -- ist die berühmteste offene Frage
|
|
der Informatik: das $\Pclass$-gegen-$\NP$-Problem, eines der sieben
|
|
Millennium-Probleme. Die verbreitete Vermutung lautet $\Pclass \ne \NP$. Der
|
|
gesamte restliche Kurs ist eine Antwort auf die Frage, wie man \emph{trotz}
|
|
dieser Ungewissheit belastbare Aussagen über schwere Probleme trifft.
|
|
|
|
% ==================================================================
|
|
\section{Reduktionen: das Vergleichswerkzeug}
|
|
% ==================================================================
|
|
|
|
Wie vergleicht man zwei Probleme, für die man beide keinen schnellen
|
|
Algorithmus kennt? Man zeigt, dass das eine im anderen \emph{steckt}.
|
|
|
|
\begin{analogie}
|
|
Wer Temperaturen nur in Fahrenheit messen kann, beantwortet trotzdem jede
|
|
Celsius-Frage: erst umrechnen, dann messen. Die Umrechnung ist billig; die
|
|
eigentliche Arbeit macht das Fahrenheit-Thermometer. Wenn sich \emph{jede} Frage
|
|
vom Typ $A$ billig in eine Frage vom Typ $B$ umrechnen lässt, dann ist $B$
|
|
mindestens so mächtig -- und mindestens so schwer -- wie $A$.
|
|
\end{analogie}
|
|
|
|
\begin{defn}{Polynomielle Reduktion $A \redp B$}
|
|
Eine \emph{Reduktion} von $A$ auf $B$ ist eine in Polynomialzeit berechenbare
|
|
Übersetzung $f$, die jede $A$-Instanz $w$ in eine $B$-Instanz $f(w)$ verwandelt
|
|
und dabei die Antwort erhält:
|
|
\[
|
|
w \in A \iff f(w) \in B.
|
|
\]
|
|
Man schreibt $A \redp B$.
|
|
\end{defn}
|
|
|
|
Die Erhaltung der Antwort umfasst beide Richtungen: Ja wird zu Ja \emph{und}
|
|
Nein wird zu Nein. Nur dann kann man einen $B$-Löser als $A$-Löser
|
|
weiterverwenden.
|
|
|
|
\begin{intuition}
|
|
Lies $A \redp B$ als \glqq $B$ ist mindestens so schwer wie $A$\grqq. Denn ein
|
|
schneller Algorithmus für $B$ ergäbe sofort einen für $A$ (Übersetzung
|
|
vorschalten). Die Härte wandert \emph{in Pfeilrichtung}: Ist $A$ hart, kann $B$
|
|
nicht leicht sein.
|
|
\end{intuition}
|
|
|
|
\begin{stolper}
|
|
\textbf{Die Richtung entscheidet über alles.} Willst du zeigen, dass ein neues
|
|
Problem $Y$ hart ist, dann übersetzt du ein \emph{bekannt hartes} Problem $X$
|
|
\emph{in} $Y$: $X \redp Y$. Merksatz: \emph{vom Bekannten zum Neuen}. Die
|
|
umgekehrte Richtung $Y \redp X$ würde nur belegen, dass $Y$ höchstens so schwer
|
|
wie $X$ ist -- eine wertlose Aussage über $Y$. Dieser Richtungsfehler ist der
|
|
häufigste Fehler in Klausuren.
|
|
\end{stolper}
|
|
|
|
\begin{satz}{Reduktionen verketten sich}
|
|
Aus $A \redp B$ und $B \redp C$ folgt $A \redp C$.\\[0.3em]
|
|
\emph{Warum:} Die Hintereinanderausführung zweier polynomieller Übersetzungen
|
|
ist wieder polynomiell -- die erste Übersetzung liefert eine polynomiell große
|
|
Zwischeninstanz, auf die die zweite polynomiell viel Zeit verwendet.
|
|
\end{satz}
|
|
|
|
Diese Verkettung ist der Grund, warum wir gleich eine ganze \emph{Kette} von
|
|
Problemen aufbauen können: Die Härte des ersten Glieds erreicht über die Pfeile
|
|
jedes spätere Glied.
|
|
|
|
% ==================================================================
|
|
\section{NP-Vollständigkeit: die härtesten Probleme in NP}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{NP-schwer}
|
|
Ein Problem $H$ heißt \emph{NP-schwer}, wenn sich \emph{jedes} Problem aus
|
|
$\NP$ auf $H$ reduzieren lässt: $L \redp H$ für alle $L \in \NP$.
|
|
\end{defn}
|
|
|
|
\begin{defn}{NP-vollständig}
|
|
Ein Problem heißt \emph{NP-vollständig}, wenn es NP-schwer ist \emph{und} selbst
|
|
in $\NP$ liegt.
|
|
\end{defn}
|
|
|
|
\begin{intuition}
|
|
NP-schwer ist die \emph{Mindest}härte -- so schwer wie alles in $\NP$ zusammen.
|
|
Die Mitgliedschaft in $\NP$ ist die \emph{Höchst}härte -- nicht schwerer als
|
|
prüfbar. NP-vollständige Probleme erfüllen beides zugleich: Sie markieren exakt
|
|
die Spitze innerhalb von $\NP$. Es gibt übrigens NP-schwere Probleme, die gar
|
|
nicht in $\NP$ liegen -- das Halteproblem am Ende des Katalogs ist so eines.
|
|
\end{intuition}
|
|
|
|
\begin{satz}{Alles hängt an einem Faden}
|
|
Sei $H$ NP-vollständig. Dann gilt: $H \in \Pclass$ genau dann, wenn
|
|
$\Pclass = \NP$.\\[0.3em]
|
|
\emph{Warum:} Hätte $H$ einen polynomiellen Algorithmus, könnte jedes
|
|
$L \in \NP$ zuerst nach $H$ übersetzt und dann dort gelöst werden -- ganz $\NP$
|
|
fiele in $\Pclass$. Die Gegenrichtung ist unmittelbar, da $H \in \NP$.
|
|
\end{satz}
|
|
|
|
Ein einziges NP-vollständiges Problem mit schnellem Algorithmus würde also die
|
|
gesamte Klasse kollabieren lassen. Solange das niemandem gelingt, ist
|
|
\glqq NP-vollständig\grqq{} das stärkste verfügbare Indiz für \glqq praktisch
|
|
nicht exakt lösbar\grqq.
|
|
|
|
\subsection{Cook--Levin: das erste harte Problem}
|
|
|
|
Die Definition von NP-schwer verlangt Reduktionen von \emph{allen} Problemen in
|
|
$\NP$ -- unendlich vielen. Für das allererste harte Problem muss man diese Hürde
|
|
direkt nehmen. Cook und Levin haben es für \problem{SAT} getan, das
|
|
Erfüllbarkeitsproblem der Aussagenlogik.
|
|
|
|
\begin{satz}{Satz von Cook und Levin}
|
|
\problem{SAT} ist NP-vollständig.\\[0.3em]
|
|
\emph{Die Idee:} Sei $L$ ein beliebiges Problem aus $\NP$, akzeptiert von einer
|
|
ratenden Maschine $M$ in Polynomialzeit. Die gesamte Arbeit von $M$ auf einer
|
|
Eingabe $u$ -- Band, Kopf, Zustand, zu jedem Zeitpunkt -- lässt sich durch
|
|
endlich viele Wahrheitswerte beschreiben: \glqq zum Zeitpunkt $t$ steht die
|
|
Maschine im Zustand $q$\grqq, \glqq zum Zeitpunkt $t$ trägt Feld $i$ das Zeichen
|
|
$a$\grqq. Aus diesen Aussagen baut man eine Formel, deren Klauseln erzwingen,
|
|
dass der Start korrekt ist, jeder Schritt einer echten Maschinenregel folgt und
|
|
das Ende akzeptierend ist. Eine erfüllende Belegung dieser Formel ist dann
|
|
nichts anderes als ein \emph{Protokoll eines akzeptierenden Rechenwegs}. Die
|
|
Formel ist erfüllbar genau dann, wenn $M$ die Eingabe akzeptiert -- und sie ist
|
|
in Polynomialzeit konstruierbar. Da $L$ beliebig war, reduziert ganz $\NP$ auf
|
|
\problem{SAT}.
|
|
\end{satz}
|
|
|
|
\subsection{Der Dominoeffekt}
|
|
|
|
\begin{idee}{Das Vererbungsprinzip}
|
|
Sobald \emph{ein} NP-vollständiges Problem existiert, wird der Nachweis für
|
|
jedes weitere Problem $Y$ dramatisch einfacher. Es genügen zwei Schritte:
|
|
\begin{enumerate}
|
|
\item Zeige $X \redp Y$ für irgendein \emph{bereits} NP-vollständiges $X$.
|
|
\item Zeige $Y \in \NP$ (Zertifikat und Verifizierer angeben).
|
|
\end{enumerate}
|
|
Dann reduziert jedes $L \in \NP$ über die Kette $L \redp X \redp Y$ auch auf
|
|
$Y$ -- also ist $Y$ NP-schwer, und mit $Y \in \NP$ NP-vollständig.
|
|
\end{idee}
|
|
|
|
Genau nach diesem Prinzip ist der folgende Katalog organisiert: \problem{SAT}
|
|
steht am Anfang, und jedes weitere Problem wird über eine Reduktion an ein schon
|
|
behandeltes angeschlossen. Die Landkarte zeigt, wer an wem hängt.
|
|
|
|
\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(3.0,0.7){\problem{TSP}; \problem{Hitting Set}}}
|
|
\put(5.4,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 Katalog aller Probleme}
|
|
\addcontentsline{toc}{section}{\textbf{Teil B -- Der Katalog aller Probleme}}
|
|
% ##################################################################
|
|
|
|
\noindent Jetzt zum Herzstück. Jedes Problem bekommt einen eigenen Abschnitt mit
|
|
denselben vier Stationen: \textbf{Definition und Beispiel} -- \textbf{warum in
|
|
NP} -- \textbf{woher die Härte} -- \textbf{wohin die Härte weiterfließt}. Die
|
|
Reihenfolge folgt der Landkarte, sodass jede eingehende Reduktion von einem
|
|
Problem kommt, das du bereits kennst.
|
|
|
|
% ==================================================================
|
|
\section{SAT}
|
|
% ==================================================================
|
|
|
|
Am Anfang steht die Logik. \problem{SAT} fragt, ob eine logische Formel
|
|
überhaupt wahr werden \emph{kann}.
|
|
|
|
\begin{defn}{SAT}
|
|
Eine Formel in \emph{konjunktiver Normalform} (KNF) ist ein UND über
|
|
\emph{Klauseln}; jede Klausel ist ein ODER über \emph{Literale}, und ein Literal
|
|
ist eine Variable $x_j$ oder ihre Negation $\neg x_j$. Gefragt ist: Existiert
|
|
eine Belegung der Variablen mit wahr und falsch, unter der \emph{jede} Klausel
|
|
wahr wird?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Eine Formel entscheiden}
|
|
Betrachte $\alpha = (x_1 \vee x_2) \wedge (\neg x_1 \vee x_2) \wedge (\neg x_2
|
|
\vee x_3)$. Wähle $x_2 = \true$: Damit sind die ersten beiden Klauseln erfüllt.
|
|
Die dritte verlangt nun $x_3 = \true$ (denn $\neg x_2$ ist falsch). Mit
|
|
$x_2 = x_3 = \true$ und beliebigem $x_1$ sind alle drei Klauseln wahr -- die
|
|
Formel ist erfüllbar.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum SAT in NP liegt}
|
|
|
|
Wir gehen den Nachweis in Ruhe durch.
|
|
|
|
\emph{Was das Zertifikat ist.} Der natürliche Beleg für \glqq erfüllbar\grqq{}
|
|
ist eine erfüllende Belegung: für jede der $v$ Variablen ein Wahrheitswert.
|
|
|
|
\emph{Wie geprüft wird.} Der Verifizierer erhält die Formel und die Belegung.
|
|
Er ersetzt jede Variable durch ihren Wert und geht dann Klausel für Klausel
|
|
durch: Eine Klausel gilt als erfüllt, sobald mindestens eines ihrer Literale
|
|
wahr ist. Findet er eine unerfüllte Klausel, lehnt er ab; andernfalls, wenn alle
|
|
Klauseln bestanden haben, akzeptiert er.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Wenn die Formel erfüllbar ist,
|
|
existiert eine Belegung, die jede Klausel wahr macht -- reicht man genau diese
|
|
ein, akzeptiert der Verifizierer. Wenn die Formel dagegen unerfüllbar ist, lässt
|
|
\emph{jede} denkbare Belegung mindestens eine Klausel falsch, und der
|
|
Verifizierer lehnt jeden Vorschlag ab. Er sagt also nie fälschlich Ja und nie
|
|
fälschlich Nein.
|
|
|
|
\emph{Wie lange es dauert.} Einsetzen und Auswerten berühren jedes Literal der
|
|
Formel einmal -- lineare Zeit. Der Verifizierer ist polynomiell, folglich
|
|
$\problem{SAT} \in \NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{Cook--Levin: Rechenwege werden Formeln}
|
|
\problem{SAT} bezieht seine Härte nicht aus einer Reduktion von einem anderen
|
|
Katalogproblem -- es ist der Ursprung. Der Satz von Cook und Levin (Teil A)
|
|
zeigt direkt: Die Rechnung \emph{jeder} ratenden Polynomialzeit-Maschine lässt
|
|
sich als KNF-Formel kodieren, sodass erfüllende Belegungen exakt den
|
|
akzeptierenden Rechenwegen entsprechen. Jedes Problem aus $\NP$ reduziert
|
|
dadurch auf \problem{SAT}.
|
|
\end{idee}
|
|
|
|
\subsection*{Wohin die Härte weiterfließt}
|
|
|
|
Vier Reduktionen gehen von \problem{SAT} aus; jede wird beim jeweiligen
|
|
Zielproblem vollständig ausgeführt, hier steht ihre Grundidee.
|
|
|
|
\begin{idee}{$\problem{SAT} \redp \problem{3-SAT}$: Ketten aus Hilfsvariablen}
|
|
Lange Klauseln werden in Ketten kurzer Klauseln zerlegt, die über frische
|
|
Hilfsvariablen aneinandergekoppelt sind. Die Kopplung ist so gebaut, dass die
|
|
Kette genau dann komplett erfüllbar ist, wenn die Originalklausel ein wahres
|
|
Literal enthält.
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{SAT} \redp \problem{$k$-Clique}$: Literale als Knoten}
|
|
Jedes Literalvorkommen wird ein Knoten; verbunden werden nur Knoten aus
|
|
verschiedenen Klauseln, deren Literale einander nicht widersprechen. Eine Clique
|
|
der Größe \glqq Klauselzahl\grqq{} pickt dann aus jeder Klausel ein Literal, und
|
|
alle gepickten vertragen sich -- eine erfüllende Belegung.
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{SAT} \redp \problem{3-DM}$: Zahnräder und Aufräumtripel}
|
|
Pro Variable entsteht ein ringförmiges \glqq Zahnrad\grqq{} aus Tripeln, das
|
|
sich nur auf zwei Arten abdecken lässt -- wahr oder falsch. Klausel-Tripel
|
|
docken an wahre Literale an, und Aufräumtripel (\glqq Garbage Collection\grqq)
|
|
entsorgen die unbenutzten Literale, damit die Zählung exakt aufgeht.
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{SAT} \redp \problem{Halteproblem}$: Suchen bis zum Erfolg}
|
|
Zu jeder Formel lässt sich ein Programm bauen, das stur alle Belegungen
|
|
durchprobiert und exakt dann stoppt, wenn es eine erfüllende findet. Ob dieses
|
|
Programm jemals hält, ist damit dieselbe Frage wie die Erfüllbarkeit.
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{3-SAT}
|
|
% ==================================================================
|
|
|
|
\problem{3-SAT} ist \problem{SAT} mit einer Formatvorschrift. Diese kleine
|
|
Einschränkung macht es zum beliebtesten Startpunkt für weitere Reduktionen:
|
|
Klauseln mit höchstens drei Literalen lassen sich viel leichter in Gadgets
|
|
verbauen als beliebig lange.
|
|
|
|
\begin{defn}{3-SAT}
|
|
Gegeben eine KNF-Formel, in der jede Klausel \emph{höchstens drei} Literale
|
|
enthält. Gefragt ist: Ist die Formel erfüllbar?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Eine 3-SAT-Formel}
|
|
$(x_1 \vee \neg x_2 \vee x_3) \wedge (x_2 \vee \neg x_3)$: Mit $x_1 = \true$ und
|
|
$x_2 = \true$ sind beide Klauseln wahr, egal wie $x_3$ steht. Erfüllbar.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum 3-SAT in NP liegt}
|
|
|
|
Auch wenn der Nachweis dem für \problem{SAT} ähnelt, führen wir ihn hier für
|
|
sich durch.
|
|
|
|
\emph{Was das Zertifikat ist.} Eine Belegung der Variablen -- ein Wahrheitswert
|
|
pro Variable.
|
|
|
|
\emph{Wie geprüft wird.} Der Verifizierer setzt die Belegung ein und
|
|
kontrolliert die Klauseln nacheinander. Da jede Klausel höchstens drei Literale
|
|
hat, ist der Test einer einzelnen Klausel eine Sache konstanter Zeit; insgesamt
|
|
läuft er einmal über die Formel. Findet er eine falsche Klausel, lehnt er ab,
|
|
sonst akzeptiert er.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Für eine erfüllbare Formel führt
|
|
die erfüllende Belegung zur Annahme. Für eine unerfüllbare bleibt unter jeder
|
|
Belegung eine Klausel falsch, und jeder Vorschlag wird abgelehnt.
|
|
|
|
\emph{Wie lange es dauert.} Ein Durchgang über die Formel, linear. Also
|
|
$\problem{3-SAT} \in \NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{$\problem{SAT} \redp \problem{3-SAT}$: die Kettenkonstruktion im Detail}
|
|
Eine Klausel mit vielen Literalen, etwa $(y_1 \vee y_2 \vee y_3 \vee y_4 \vee
|
|
y_5)$, wird durch eine Kette ersetzt:
|
|
\[
|
|
(y_1 \vee y_2 \vee h_1) \wedge (\neg h_1 \vee y_3 \vee h_2) \wedge
|
|
(\neg h_2 \vee y_4 \vee y_5),
|
|
\]
|
|
mit neuen Hilfsvariablen $h_1, h_2$, die nur in dieser Kette vorkommen. Kurze
|
|
Klauseln bleiben unverändert.
|
|
\end{idee}
|
|
|
|
Warum die Kette die Erfüllbarkeit bewahrt, sieht man an beiden Richtungen. Ist
|
|
in der Originalklausel ein $y_i$ wahr, dann setzt man alle Hilfsvariablen
|
|
\emph{vor} der Position von $y_i$ auf wahr und alle danach auf falsch: Jedes
|
|
Kettenglied vor $y_i$ wird durch sein $h$-Literal wahr, das Glied mit $y_i$
|
|
durch $y_i$ selbst, und jedes Glied danach durch sein negiertes $h$-Literal. Ist
|
|
dagegen \emph{kein} $y_i$ wahr, dann zwingt das erste Glied $h_1$ auf wahr, das
|
|
zweite daraufhin $h_2$ auf wahr, und so weiter -- bis das letzte Glied nur noch
|
|
falsche Literale enthält. Die Kette ist dann unerfüllbar, genau wie die
|
|
Originalklausel. Die Umformung vergrößert die Formel nur linear und ist damit
|
|
polynomiell. Zusammen mit $\problem{3-SAT} \in \NP$ folgt: \problem{3-SAT} ist
|
|
NP-vollständig.
|
|
|
|
\subsection*{Wohin die Härte weiterfließt}
|
|
|
|
\begin{idee}{$\problem{3-SAT} \redp \problem{$k$-Color}$: Farben als Wahrheitswerte}
|
|
Ein Gadget aus Variablen-, Klausel- und Hilfsknoten erzwingt, dass jede
|
|
Variable eine von zwei Rollen-Farben (\glqq wahr\grqq/\glqq falsch\grqq) trägt
|
|
und jeder Klauselknoten nur dann färbbar ist, wenn seine Klausel ein wahres
|
|
Literal hat. Details beim Färbungsproblem.
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{3-SAT}' \redp \problem{Hamiltonkreis}$: Touren als Belegungen}
|
|
Spezielle Bausteine übersetzen \glqq Variable wahr oder falsch\grqq{} in
|
|
\glqq Baustein links- oder rechtsherum durchlaufen\grqq{} und blockieren jede
|
|
Tour, die eine Klausel komplett falsch ließe. Details beim Hamiltonkreis.
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{3-SAT} \redp \problem{Hitting Set}$: Literale treffen}
|
|
Die Literale bilden das Universum. Paar-Mengen $\{x_i, \bar x_i\}$ erzwingen
|
|
eine Belegung, Klausel-Mengen verlangen ein getroffenes wahres Literal. Details
|
|
beim Hitting Set.
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{3-SAT} \redp \problem{SubSet Sum}$ (streng): Dezimalstellen}
|
|
Eine besonders sparsame Kodierung über Ziffern zur Basis 10 erzeugt nur $O(m)$
|
|
Zahlen -- wichtig für die unteren Schranken. Details beim SubSet Sum.
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{$k$-Clique}
|
|
% ==================================================================
|
|
|
|
Das Problem aus der Einleitung bekommt jetzt seine vollständige Behandlung.
|
|
|
|
\begin{defn}{$k$-Clique}
|
|
Gegeben ein ungerichteter Graph $G = (V,E)$ und eine Zahl $k$. Eine
|
|
\emph{Clique} ist eine Menge von Knoten, zwischen denen \emph{sämtliche} Kanten
|
|
vorhanden sind. Gefragt ist: Enthält $G$ eine Clique mit mindestens $k$ Knoten?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Clique ja, Clique nein}
|
|
Nimm die Knoten $p, q, r, s$ mit den Kanten $\{p,q\}$, $\{q,r\}$, $\{p,r\}$ und
|
|
$\{r,s\}$. Die Menge $\{p,q,r\}$ ist eine Clique der Größe 3 -- alle drei
|
|
möglichen Kanten sind da. Die Menge $\{q,r,s\}$ ist keine Clique, denn $q$ und
|
|
$s$ sind nicht verbunden.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum $k$-Clique in NP liegt}
|
|
|
|
\emph{Was das Zertifikat ist.} Der Beleg für eine Ja-Antwort ist die
|
|
Knotenmenge $C$ selbst.
|
|
|
|
\emph{Wie geprüft wird.} Der Verifizierer nimmt sich alle Paare von Knoten aus
|
|
$C$ vor. Für jedes Paar schlägt er nach, ob die Kante im Graphen existiert.
|
|
Fehlt auch nur eine, lehnt er ab. Bestehen alle Paare den Test, zählt er noch
|
|
$|C|$ und vergleicht mit $k$; ist $|C| \ge k$, akzeptiert er.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Besitzt der Graph eine Clique mit
|
|
$k$ Knoten, dann besteht genau diese Menge alle Paartests und die Größenprüfung
|
|
-- der Verifizierer akzeptiert sie. Besitzt er keine, dann hat jede eingereichte
|
|
Menge mit $\ge k$ Knoten irgendwo ein unverbundenes Paar, und der Verifizierer
|
|
weist sie zurück. Falsche Ja-Antworten sind ausgeschlossen.
|
|
|
|
\emph{Wie lange es dauert.} Bei $|C| \le |V|$ Knoten sind es höchstens
|
|
$O(|V|^2)$ Paare, jeder Nachschlag in einer Adjazenzmatrix kostet konstante
|
|
Zeit; die Größenprüfung ist billig. Insgesamt $O(|V|^2)$ -- polynomiell, also
|
|
$\problem{$k$-Clique} \in \NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{$\problem{SAT} \redp \problem{$k$-Clique}$: ein Knoten je Literalvorkommen}
|
|
Gegeben eine KNF $F$ mit Klauseln $F_1, \dots, F_m$. Der Graph entsteht so:
|
|
Für das $j$-te Literal der Klausel $i$ gibt es einen Knoten $[i,j]$. Eine Kante
|
|
verbindet $[i,j]$ und $[i',j']$ genau dann, wenn erstens $i \ne i'$ (verschiedene
|
|
Klauseln) und zweitens die beiden Literale \emph{nicht} komplementär sind (nicht
|
|
$x$ und $\neg x$ derselben Variablen). Gesucht wird eine Clique der Größe
|
|
$k = m$.
|
|
\end{idee}
|
|
|
|
Weshalb die Übersetzung funktioniert: Innerhalb einer Klausel gibt es keine
|
|
Kanten, also kann eine Clique aus jeder Klausel höchstens einen Knoten enthalten
|
|
-- eine $m$-Clique enthält demnach aus jeder Klausel \emph{genau} einen. Ihre
|
|
Literale vertragen sich paarweise (sonst fehlte eine Kante), man kann sie also
|
|
alle zugleich wahr machen; das erfüllt jede Klausel. Umgekehrt: Erfüllt eine
|
|
Belegung die Formel, wählt man aus jeder Klausel ein wahres Literal -- die
|
|
zugehörigen $m$ Knoten stammen aus verschiedenen Klauseln und widersprechen sich
|
|
nicht, sind also paarweise verbunden: eine $m$-Clique. Der Graphaufbau berührt
|
|
jedes Literalpaar einmal und ist polynomiell.
|
|
|
|
\begin{bsp}{Die Übersetzung an einer Formel}
|
|
$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)$ mit $m = 3$ Klauseln, gesucht also eine
|
|
3-Clique. Der Graph hat acht Knoten in drei Spalten. Fett hervorgehoben: die
|
|
Clique aus $x_1$ (Klausel 1), $\neg x_2$ (Klausel 2) und $x_1$ (Klausel 3).
|
|
\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.45,2.55){\small $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 $\neg x_2$}
|
|
\put(7.6,3.3){\small Klausel 3}
|
|
\put(8.5,2.6){\circle*{0.17}}\put(8.7,2.55){\small $x_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 fette 3-Clique liefert die Belegung $x_1 = \true$, $x_2 = \false$ ($x_3$
|
|
frei) -- und die erfüllt tatsächlich alle drei Klauseln. Dünne Kanten zwischen
|
|
anderen verträglichen Paaren sind zur Übersicht weggelassen.
|
|
\end{bsp}
|
|
|
|
\subsection*{Wohin die Härte weiterfließt}
|
|
|
|
\begin{idee}{$\problem{Clique} \redp \problem{Independent Set}$: Kanten umklappen}
|
|
Man ersetzt den Graphen durch sein \emph{Komplement} -- vorhandene Kanten
|
|
verschwinden, fehlende erscheinen -- und behält $k$. Aus \glqq alle
|
|
verbunden\grqq{} wird \glqq keiner verbunden\grqq. Details beim Independent Set.
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{Clique} \redp \problem{Vertex Cover}$: Komplement plus Restmenge}
|
|
Ebenfalls über den Komplementgraphen, aber mit Schranke $n - k$: Das
|
|
\emph{Komplement der Cliquenmenge} wird dort zum Vertex Cover. Details beim
|
|
Vertex Cover.
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{Clique} \redp$ Varianten: Dummy- und Universalknoten}
|
|
Für \problem{Clique-Nomember} (Clique ohne einen bestimmten Knoten) fügt man
|
|
einen \emph{isolierten} Knoten hinzu -- er kann ohnehin in keiner Clique liegen.
|
|
Für \problem{Clique-Universal} (Instanz muss einen mit allen verbundenen Knoten
|
|
haben) fügt man einen \emph{universellen} Knoten hinzu und erhöht $k$ um eins --
|
|
er vergrößert jede Clique um genau ein Mitglied.
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{Independent Set}
|
|
% ==================================================================
|
|
|
|
Die Clique verlangt maximale Nähe -- das Independent Set verlangt maximale
|
|
Distanz.
|
|
|
|
\begin{defn}{Independent Set (IS)}
|
|
Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Ein \emph{Independent Set} ist
|
|
eine Knotenmenge, innerhalb derer \emph{keine einzige} Kante verläuft. Gefragt
|
|
ist: Enthält $G$ ein Independent Set mit mindestens $k$ Knoten?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Unabhängige Knoten finden}
|
|
Ein Pfad $p - q - r - s$ (drei Kanten). Die Menge $\{p, r\}$ ist unabhängig --
|
|
$p$ und $r$ sind nicht direkt verbunden. Auch $\{p, s\}$ und $\{q, s\}$ sind
|
|
unabhängig. $\{q, r\}$ ist es nicht, denn die Kante $\{q,r\}$ verläuft mitten
|
|
durch die Menge.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Independent Set in NP liegt}
|
|
|
|
\emph{Was das Zertifikat ist.} Die Knotenmenge $I$.
|
|
|
|
\emph{Wie geprüft wird.} Der Verifizierer betrachtet jedes Knotenpaar aus $I$
|
|
und schlägt nach, ob es im Graphen verbunden ist. Findet er auch nur eine Kante
|
|
innerhalb von $I$, lehnt er ab. Andernfalls zählt er $|I|$; bei $|I| \ge k$
|
|
akzeptiert er.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Existiert ein Independent Set der
|
|
verlangten Größe, dann übersteht genau diese Menge alle Paartests -- Annahme.
|
|
Existiert keines, dann trägt jede eingereichte Menge dieser Größe mindestens
|
|
eine innere Kante -- Ablehnung. Der Verifizierer irrt sich in keiner Richtung.
|
|
|
|
\emph{Wie lange es dauert.} Höchstens $O(|V|^2)$ Paare mit konstantem
|
|
Nachschlag, dazu die Größenprüfung: insgesamt $O(|V|^2)$. Also
|
|
$\problem{IS} \in \NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{$\problem{Clique} \redp \problem{IS}$: der Komplementgraph}
|
|
Aus der Clique-Instanz $(G, k)$ wird die IS-Instanz $(\bar G, k)$, wobei
|
|
$\bar G$ dieselben Knoten hat und \emph{genau die} Kanten, die in $G$ fehlen.
|
|
\end{idee}
|
|
|
|
Die Übersetzung ist ein reiner Perspektivwechsel: Eine Menge $C$ ist Clique in
|
|
$G$ genau dann, wenn zwischen ihren Knoten in $G$ alle Kanten liegen -- also in
|
|
$\bar G$ \emph{gar keine}. Das ist wortwörtlich die Definition eines Independent
|
|
Set in $\bar G$. Ja-Instanzen entsprechen sich eins zu eins, ebenso
|
|
Nein-Instanzen. Das Komplement zu bilden kostet $O(|V|^2)$ und ist polynomiell.
|
|
Da \problem{Clique} NP-vollständig ist und $\problem{IS} \in \NP$, ist
|
|
\problem{IS} NP-vollständig.
|
|
|
|
\subsection*{Wohin die Härte weiterfließt}
|
|
|
|
Im Kursmaterial tritt \problem{Independent Set} vor allem als Zwischenstation
|
|
der Dualität auf: Eine Menge ist genau dann unabhängig, wenn ihr Komplement alle
|
|
Kanten berührt -- also ein Vertex Cover ist. Diese Beziehung nutzt die nächste
|
|
Reduktion. Eine eigene ausgehende Reduktion auf ein weiteres Problem führt der
|
|
Kurs nicht ein.
|
|
|
|
% ==================================================================
|
|
\section{Vertex Cover}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{Vertex Cover (VC)}
|
|
Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Ein \emph{Vertex Cover} ist
|
|
eine Knotenmenge, die von \emph{jeder} Kante mindestens einen Endpunkt enthält.
|
|
Gefragt ist: Besitzt $G$ ein Vertex Cover mit höchstens $k$ Knoten?
|
|
\end{defn}
|
|
|
|
\begin{analogie}
|
|
Stell dir die Kanten als Flure eines Museums vor und die Knoten als Ecken, an
|
|
denen Wächter stehen können. Ein Vertex Cover ist eine Wächteraufstellung, bei
|
|
der jeder Flur von mindestens einem Ende aus eingesehen wird -- und gefragt ist,
|
|
ob $k$ Wächter reichen.
|
|
\end{analogie}
|
|
|
|
\begin{bsp}{Wächter platzieren}
|
|
Wieder der Pfad $p - q - r - s$. Die Aufstellung $\{q, r\}$ deckt alle drei
|
|
Flure: $\{p,q\}$ über $q$, $\{q,r\}$ über beide, $\{r,s\}$ über $r$. Mit nur
|
|
einem Wächter geht es nicht -- egal wo er steht, bleibt ein Flur an beiden Enden
|
|
unbewacht.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Vertex Cover in NP liegt}
|
|
|
|
\emph{Was das Zertifikat ist.} Die Wächtermenge $C$.
|
|
|
|
\emph{Wie geprüft wird.} Der Verifizierer geht die Kantenliste durch. Bei jeder
|
|
Kante $\{u,v\}$ fragt er: Liegt $u$ in $C$ oder $v$ in $C$? Sobald eine Kante
|
|
beide Male Nein liefert, lehnt er ab. Am Ende zählt er $|C|$; bei $|C| \le k$
|
|
akzeptiert er.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Ein echtes Vertex Cover der Größe
|
|
$\le k$ besteht jeden Kantentest und die Zählung -- es wird akzeptiert. Gibt es
|
|
keines, dann lässt jede Menge mit $\le k$ Knoten mindestens eine Kante
|
|
unbedeckt, und der Test schlägt fehl. Beide Richtungen halten.
|
|
|
|
\emph{Wie lange es dauert.} Ein Durchlauf über alle Kanten mit konstanten
|
|
Nachschlägen: $O(|E|)$, dazu $O(|V|)$ fürs Zählen. Also $\problem{VC} \in \NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{$\problem{Clique} \redp \problem{VC}$: Komplement und Gegenmenge}
|
|
Aus $(G, k)$ mit $n$ Knoten wird $(\bar G,\, n-k)$: derselbe Komplementgraph wie
|
|
bei der IS-Reduktion, aber als Schranke die \emph{Restgröße} $n - k$.
|
|
\end{idee}
|
|
|
|
Der Weg führt über zwei Beobachtungen. Erstens: $C$ ist Clique in $G$ genau
|
|
dann, wenn $C$ Independent Set in $\bar G$ ist (Kanten umgeklappt). Zweitens:
|
|
$I$ ist Independent Set genau dann, wenn $V \setminus I$ Vertex Cover ist --
|
|
denn \glqq keine Kante verläuft innerhalb von $I$\grqq{} heißt \glqq jede Kante
|
|
hat ein Ende außerhalb von $I$\grqq. Setzt man beides zusammen: $G$ hat eine
|
|
$k$-Clique genau dann, wenn $\bar G$ ein Vertex Cover der Größe $n - k$ hat.
|
|
Beide Richtungen der Antwortgleichheit stecken in diesen beiden Äquivalenzen.
|
|
Der Aufbau ist mit $O(|V|^2)$ polynomiell, also ist \problem{VC} NP-vollständig.
|
|
|
|
\begin{aha}
|
|
Damit schließt sich ein Dreieck aus drei Sichtweisen auf dieselbe Struktur:
|
|
\[
|
|
C \text{ Clique in } G
|
|
\iff C \text{ Independent Set in } \bar G
|
|
\iff V \setminus C \text{ Vertex Cover in } \bar G.
|
|
\]
|
|
Die drei Probleme bleiben eigenständig -- aber wer eine der drei Übersetzungen
|
|
verstanden hat, kann die anderen beiden selbst herleiten.
|
|
\end{aha}
|
|
|
|
\begin{bsp}{Das Dreieck in einem Bild}
|
|
Links $G$ mit der Clique $\{1,2,3\}$; rechts das Komplement $\bar G$, in dem
|
|
$\{1,2,3\}$ unabhängig ist und der übrig gebliebene Knoten 4 alle Kanten
|
|
abdeckt.
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{center}
|
|
\begin{picture}(12,3.2)(0,-0.5)
|
|
\put(1.3,2.6){\small $G$: $\{1,2,3\}$ 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\}$ IS, $\{4\}$ 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*{Wohin die Härte weiterfließt}
|
|
|
|
\begin{idee}{$\problem{VC} \redp \problem{FVS}$: Kanten zu Mini-Kreisen}
|
|
Jede ungerichtete Kante wird durch ein Paar entgegengesetzter Pfeile ersetzt --
|
|
ein gerichteter 2-Kreis, den nur seine beiden Endknoten zerstören können.
|
|
Details beim Feedback Vertex Set.
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{VC} \redp \Delta$-\problem{Cover}: Kanten zu Dreiecken}
|
|
Jede Kante bekommt einen neuen Spitzknoten und wird so zu einem Dreieck
|
|
aufgepumpt; Kanten decken heißt dann Dreiecke treffen. Details beim
|
|
$\Delta$-Cover.
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{Feedback Vertex Set}
|
|
% ==================================================================
|
|
|
|
Zum ersten Mal wechseln wir zu \emph{gerichteten} Graphen -- die Kanten sind
|
|
jetzt Pfeile.
|
|
|
|
\begin{defn}{Feedback Vertex Set (FVS)}
|
|
Gegeben ein gerichteter Graph $G = (V,E)$ und eine Zahl $k$. Gesucht ist eine
|
|
Menge $X$ von höchstens $k$ Knoten, deren Entfernung \emph{alle gerichteten
|
|
Kreise} zerstört -- sodass der Restgraph kreisfrei ist. Gefragt: Existiert ein
|
|
solches $X$?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Kreise brechen}
|
|
Ein Graph enthalte die Pfeile $a \to b$, $b \to a$, $b \to c$ und $c \to b$. Es
|
|
gibt zwei Kreise: $a \to b \to a$ und $b \to c \to b$. Beide laufen durch $b$ --
|
|
entfernt man $b$, ist der Rest kreisfrei. $X = \{b\}$ ist ein FVS der Größe 1.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Feedback Vertex Set in NP liegt}
|
|
|
|
\emph{Was das Zertifikat ist.} Die zu entfernende Knotenmenge $X$.
|
|
|
|
\emph{Wie geprüft wird.} Zwei Kontrollen. Erstens zählt der Verifizierer
|
|
$|X|$ und vergleicht mit $k$. Zweitens muss er entscheiden, ob der Graph ohne
|
|
$X$ kreisfrei ist -- dafür steht ihm ein klassischer Polynomialzeit-Algorithmus
|
|
zur Verfügung: die \emph{topologische Sortierung}. Sie ordnet die Knoten so an,
|
|
dass alle Pfeile vorwärts zeigen, und gelingt \emph{genau dann}, wenn kein Kreis
|
|
existiert. Gelingt die Sortierung von $G \setminus X$ und stimmt die Größe,
|
|
akzeptiert der Verifizierer.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Ist $X$ ein echtes FVS der Größe
|
|
$\le k$, dann ist der Restgraph kreisfrei, die Sortierung klappt, und der
|
|
Vorschlag wird angenommen. Gibt es kein solches FVS, dann hinterlässt jede Menge
|
|
dieser Größe einen Kreis, die Sortierung scheitert, der Vorschlag wird
|
|
abgelehnt.
|
|
|
|
\emph{Wie lange es dauert.} Topologische Sortierung läuft in $O(|V| + |E|)$,
|
|
die Zählung in $O(|V|)$. Also $\problem{FVS} \in \NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{$\problem{VC} \redp \problem{FVS}$: antiparallele Bögen}
|
|
Aus einer ungerichteten VC-Instanz $(G, k)$ wird eine gerichtete FVS-Instanz
|
|
$(G', k)$: Jede Kante $\{u,v\}$ von $G$ wird durch die \emph{beiden} Pfeile
|
|
$u \to v$ und $v \to u$ ersetzt. Sonst ändert sich nichts, auch $k$ bleibt.
|
|
\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(0.9,-0.05){\small 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(4.9,-0.05){\small 2-Kreis in $G'$}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
Der Kern des Arguments: Jedes Pfeilpaar bildet einen Kreis der Länge zwei, und
|
|
\emph{andere} Kreise gibt es in $G'$ nicht in neuer Qualität -- jeder Kreis
|
|
durchläuft solche Pfeilpaare. Einen 2-Kreis $u \to v \to u$ zerstört man nur,
|
|
indem man $u$ oder $v$ entfernt. \glqq Alle Kreise zerstören\grqq{} übersetzt
|
|
sich damit in \glqq von jeder Original-Kante einen Endpunkt entfernen\grqq{} --
|
|
das ist wörtlich die Vertex-Cover-Bedingung. Konkret: Ist $C$ ein Vertex Cover
|
|
von $G$, dann bleibt nach Entfernen von $C$ kein Pfeilpaar vollständig übrig,
|
|
also kein Kreis -- $C$ ist ein FVS. Ist umgekehrt $X$ ein FVS von $G'$, dann
|
|
muss $X$ jeden 2-Kreis anfassen, deckt also jede Kante von $G$ ab -- $X$ ist ein
|
|
Vertex Cover. Der Umbau kostet $O(|E|)$. \problem{FVS} ist damit NP-vollständig.
|
|
|
|
\subsection*{Wohin die Härte weiterfließt}
|
|
|
|
\problem{Feedback Vertex Set} ist im Kurs ein Endpunkt -- es dient nicht als
|
|
Quelle einer weiteren Reduktion.
|
|
|
|
% ==================================================================
|
|
\section{$\Delta$-Cover}
|
|
% ==================================================================
|
|
|
|
Noch einmal Vertex Cover als Quelle, diesmal mit einem anderen Gadget: Statt um
|
|
Kanten geht es um Dreiecke.
|
|
|
|
\begin{defn}{$\Delta$-Cover}
|
|
Gegeben ein ungerichteter Graph $G = (V,E)$ und eine Zahl $k$. Ein
|
|
\emph{$\Delta$-Cover} ist eine Knotenmenge, die jedes \emph{Dreieck} des Graphen
|
|
(jede 3-Clique) in mindestens einem Knoten trifft. Gefragt: Gibt es eines mit
|
|
höchstens $k$ Knoten?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Dreiecke treffen}
|
|
Zwei Dreiecke $\{a,b,c\}$ und $\{c,d,e\}$, die sich den Knoten $c$ teilen. Die
|
|
Menge $\{c\}$ trifft beide -- ein $\Delta$-Cover der Größe 1. Die Menge
|
|
$\{a,d\}$ trifft ebenfalls beide, braucht aber zwei Knoten.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum $\Delta$-Cover in NP liegt}
|
|
|
|
\emph{Was das Zertifikat ist.} Die Knotenmenge $C_\Delta$.
|
|
|
|
\emph{Wie geprüft wird.} Der Verifizierer zählt zunächst $|C_\Delta|$ und
|
|
vergleicht mit $k$. Dann sucht er systematisch alle Dreiecke: Er läuft über
|
|
sämtliche Knotentripel, prüft für jedes, ob alle drei Verbindungskanten
|
|
existieren, und wenn ja, ob wenigstens einer der drei Knoten in $C_\Delta$
|
|
liegt. Ein ungetroffenes Dreieck führt zur Ablehnung; sonst wird akzeptiert.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Ein echtes $\Delta$-Cover der
|
|
verlangten Größe übersteht die Suche -- kein Dreieck bleibt ungetroffen -- und
|
|
wird angenommen. Existiert keines, findet die Suche bei jedem Vorschlag dieser
|
|
Größe ein verfehltes Dreieck und lehnt ab.
|
|
|
|
\emph{Wie lange es dauert.} Es gibt $O(|V|^3)$ Tripel; Kanten- und
|
|
Mitgliedschaftstests pro Tripel sind konstant bis linear. Insgesamt höchstens
|
|
$O(|V|^4)$ -- polynomiell, also $\Delta\text{-}\problem{Cover} \in \NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{$\problem{VC} \redp \Delta$-\problem{Cover}: Kanten aufpumpen}
|
|
Zur VC-Instanz $(G, k)$ baut man $G'$: Für jede Kante $e = \{u,v\}$ kommt ein
|
|
frischer Knoten $t_e$ hinzu, verbunden mit $u$ und mit $v$. Jede Kante wird so
|
|
zur Spitze eines eigenen Dreiecks $\{t_e, u, v\}$. Die Schranke $k$ bleibt.
|
|
\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.1,-0.1){\small Kante $e$}
|
|
\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 $t_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.8,-0.35){\small Dreieck $\{t_e,u,v\}$}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
Die Hinrichtung ist unkompliziert: Deckt $C$ jede Kante von $G$, dann enthält
|
|
$C$ von jedem Gadget-Dreieck $\{t_e, u, v\}$ den Knoten $u$ oder $v$ -- das
|
|
Dreieck ist getroffen.
|
|
|
|
\begin{stolper}
|
|
\textbf{Hier liegt eine Falle, die echte Punkte gekostet hat.} $G'$ enthält
|
|
neben den Gadget-Dreiecken auch alle Dreiecke, die \emph{schon in $G$ standen} --
|
|
denn die Originalkanten bleiben ja erhalten. Ein Beweis, der behauptet,
|
|
\emph{jedes} Dreieck von $G'$ habe die Form $\{t_e, u, v\}$, ist falsch. Die
|
|
geerbten Dreiecke muss man eigens behandeln: Ihre drei Seiten sind
|
|
Originalkanten, jede davon wird vom Vertex Cover gedeckt, also liegt einer ihrer
|
|
Eckknoten in $C$ -- auch sie sind getroffen. Erst mit diesem Fall ist die
|
|
Hinrichtung vollständig.
|
|
\end{stolper}
|
|
|
|
Für die Rückrichtung nimmt man ein $\Delta$-Cover $C_\Delta$ der Größe $\le k$
|
|
und säubert es: Enthält es einen Gadget-Knoten $t_e$, ersetzt man ihn durch
|
|
einen der beiden Endpunkte von $e$ -- das einzige Dreieck durch $t_e$ ist sein
|
|
eigenes, und das bleibt getroffen; die Menge wächst dabei nicht. Danach liegt
|
|
$C_\Delta$ ganz in $V$, und weil es jedes Gadget-Dreieck $\{t_e, u, v\}$ treffen
|
|
muss, enthält es $u$ oder $v$ -- von \emph{jeder} Kante $e$ einen Endpunkt. Das
|
|
ist ein Vertex Cover. Der Aufbau kostet $O(|E|)$; $\Delta$-\problem{Cover} ist
|
|
NP-vollständig.
|
|
|
|
\subsection*{Wohin die Härte weiterfließt}
|
|
|
|
Auch das $\Delta$-Cover ist im Kurs ein Endpunkt ohne ausgehende Reduktion.
|
|
|
|
% ==================================================================
|
|
\section{$k$-Color}
|
|
% ==================================================================
|
|
|
|
Zurück zur 3-SAT-Linie der Landkarte. Das Färbungsproblem ist ein Klassiker mit
|
|
anschaulicher Deutung.
|
|
|
|
\begin{defn}{$k$-Color}
|
|
Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Eine gültige \emph{$k$-Färbung}
|
|
weist jedem Knoten eine von $k$ Farben zu, wobei benachbarte Knoten nie dieselbe
|
|
Farbe tragen dürfen. Gefragt: Lässt sich $G$ so färben?
|
|
\end{defn}
|
|
|
|
Die klassische Deutung: Länder einer Landkarte färben, sodass Nachbarländer
|
|
verschieden aussehen. Schon mit drei Farben ist die Frage NP-vollständig.
|
|
|
|
\begin{bsp}{Drei Farben im Einsatz}
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{center}
|
|
\begin{picture}(4.5,2.6)(-0.3,-0.3)
|
|
\put(0,0){\circle*{0.18}}\put(-0.4,-0.05){\small $1$}
|
|
\put(2,0){\circle*{0.18}}\put(2.1,-0.3){\small $2$}
|
|
\put(1,1.7){\circle*{0.18}}\put(1.1,1.85){\small $3$}
|
|
\put(3.4,0.85){\circle*{0.18}}\put(3.55,0.8){\small $1$}
|
|
\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}
|
|
Die Zahlen sind Farben. Das Dreieck links verbraucht zwingend drei verschiedene
|
|
Farben. Der rechte Knoten hat nur einen Nachbarn (Farbe 2) und darf deshalb
|
|
Farbe 1 wiederverwenden.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum $k$-Color in NP liegt}
|
|
|
|
\emph{Was das Zertifikat ist.} Die Farbzuweisung -- pro Knoten eine Zahl
|
|
zwischen 1 und $k$.
|
|
|
|
\emph{Wie geprüft wird.} Der Verifizierer wandert über die Kantenliste. Für
|
|
jede Kante vergleicht er die Farben ihrer beiden Endpunkte; sind sie irgendwo
|
|
gleich, lehnt er ab. Übersteht die Färbung alle Kanten, akzeptiert er.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Eine gültige Färbung passiert
|
|
jeden Vergleich und wird angenommen. Ist der Graph nicht $k$-färbbar, enthält
|
|
jede eingereichte Zuweisung mindestens eine gleichfarbige Kante -- der Vergleich
|
|
schlägt dort fehl, Ablehnung.
|
|
|
|
\emph{Wie lange es dauert.} Ein Lauf über $|E|$ Kanten mit konstantem Vergleich:
|
|
$O(|E|)$. Also $\problem{$k$-Color} \in \NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{$\problem{3-SAT} \redp \problem{$k$-Color}$: Färben heißt Belegen}
|
|
Zur Formel mit $n$ Variablen und $m$ Klauseln baut man einen Graphen mit drei
|
|
Sorten von Knoten: für jede Variable ein Paar $x_i$, $\bar x_i$ und ein
|
|
Hilfsknoten $v_i$; für jede Klausel ein Knoten $F_j$; dazu ein zentraler Knoten
|
|
$z$. Die Hilfsknoten $v_1, \dots, v_n$ und $z$ sind untereinander komplett
|
|
verbunden -- sie bilden eine Clique und schlucken dadurch $n+1$ paarweise
|
|
verschiedene Farben. Jedes Paar $x_i$, $\bar x_i$ ist verbunden und zusätzlich
|
|
so mit den Hilfsknoten verdrahtet, dass für die beiden nur noch zwei Farben in
|
|
Frage kommen -- eine spielt \glqq wahr\grqq, die andere \glqq falsch\grqq. Die
|
|
Färbung der Literalknoten \emph{ist} damit eine Belegung. Jeder Klauselknoten
|
|
$F_j$ schließlich ist genau mit den Literalknoten verbunden, die \emph{nicht} in
|
|
seiner Klausel vorkommen; dadurch findet er genau dann noch eine erlaubte Farbe,
|
|
wenn eines seiner eigenen Literale die \glqq wahr\grqq-Farbe trägt. Insgesamt:
|
|
Der Graph ist mit $n+1$ Farben färbbar genau dann, wenn die Formel erfüllbar
|
|
ist.
|
|
\end{idee}
|
|
|
|
\subsection*{Wohin die Härte weiterfließt}
|
|
|
|
Das Färbungsproblem gibt seine Härte im Kurs nicht weiter; es kehrt aber bei den
|
|
unteren Schranken in Teil C zurück, wo seine besonders knappe
|
|
$O(n+m)$-Konstruktion den Ausschlag gibt.
|
|
|
|
% ==================================================================
|
|
\section{Hamiltonkreis}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{Hamiltonkreis (HK)}
|
|
Gegeben ein Graph $G$. Gefragt ist, ob es eine geschlossene Tour gibt, die
|
|
\emph{jeden Knoten genau einmal} besucht. (Das Problem ist für gerichtete wie
|
|
ungerichtete Graphen NP-vollständig.)
|
|
\end{defn}
|
|
|
|
Nicht verwechseln mit dem Eulerkreis, der jede \emph{Kante} genau einmal nutzt
|
|
-- der ist leicht zu finden. Beim Hamiltonkreis geht es um die \emph{Knoten},
|
|
und das ändert alles.
|
|
|
|
\begin{bsp}{Eine Rundtour durch alle Knoten}
|
|
\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}
|
|
Die fette Route berührt jeden der fünf Knoten exakt einmal und kehrt zum Start
|
|
zurück -- ein Hamiltonkreis.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Hamiltonkreis in NP liegt}
|
|
|
|
\emph{Was das Zertifikat ist.} Die Besuchsreihenfolge -- eine Auflistung aller
|
|
Knoten in Tourfolge.
|
|
|
|
\emph{Wie geprüft wird.} Zwei Kontrollen. Der Verifizierer hakt erstens ab, dass
|
|
in der Liste jeder Knoten genau einmal auftaucht (etwa mit einer
|
|
Markierungstabelle). Zweitens läuft er die Liste entlang und schlägt für jedes
|
|
Nachbarpaar -- einschließlich des Schlusses von letzter zu erster Position --
|
|
nach, ob die Kante existiert. Beide Kontrollen bestanden: Annahme; sonst
|
|
Ablehnung.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Ein echter Hamiltonkreis liefert
|
|
als Liste genau ein Zertifikat, das beide Kontrollen besteht. Und jede Liste,
|
|
die beide Kontrollen besteht, beschreibt ihrerseits eine geschlossene Tour über
|
|
lauter echte Kanten durch alle Knoten -- einen Hamiltonkreis. Es gibt keine
|
|
Lücke zwischen \glqq wird akzeptiert\grqq{} und \glqq ist wirklich einer\grqq.
|
|
|
|
\emph{Wie lange es dauert.} Markieren in $O(|V|)$, Kantenchecks in $O(|V|)$
|
|
Nachschlägen: zusammen linear bis $O(|V|+|E|)$. Also $\problem{HK} \in \NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{$\problem{3-SAT}' \redp \problem{HK}$: Bausteine mit zwei Durchgängen}
|
|
Für die Variante mit \emph{genau} drei Literalen pro Klausel baut man den
|
|
Graphen aus zwei Bausteintypen. Die \emph{A-Bausteine} -- leiterförmige
|
|
Komponenten, eine je Literalvorkommen -- lassen sich von einer Tour nur auf
|
|
genau zwei Weisen durchqueren; die Wahl der Weise kodiert, ob die zugehörige
|
|
Variable wahr oder falsch ist. Die \emph{B-Bausteine} -- einer je Klausel --
|
|
sind so verdrahtet, dass eine Tour sie für jede \emph{nichtleere} Teilmenge
|
|
ihrer drei Anschlusskanten passieren kann, für die leere aber nicht. Die leere
|
|
Teilmenge entspricht dem Fall \glqq alle drei Literale falsch\grqq. Eine
|
|
Hamiltontour durch das Gesamtgebilde existiert deshalb genau dann, wenn man die
|
|
Variablen so setzen kann, dass keine Klausel leer ausgeht -- wenn die Formel
|
|
erfüllbar ist.
|
|
\end{idee}
|
|
|
|
\subsection*{Wohin die Härte weiterfließt}
|
|
|
|
\begin{idee}{$\problem{HK} \redp \problem{TSP}$: Distanzen als Filter}
|
|
Man macht aus dem Graphen eine Distanztabelle: echte Kanten kosten 1, fehlende
|
|
Verbindungen kosten $|V| + 1$, und als Budget setzt man $L = |V|$. Eine
|
|
Rundreise im Budget kann sich keine einzige teure Nicht-Kante leisten -- sie
|
|
existiert also genau dann, wenn der Graph eine reine Kanten-Tour durch alle
|
|
Knoten besitzt: einen Hamiltonkreis. Details beim TSP.
|
|
\end{idee}
|
|
|
|
\begin{idee}{Kreis und Pfad ineinander überführen}
|
|
Vom \emph{Pfad} zum \emph{Kreis}: Ein zusätzlicher Knoten, der mit allen
|
|
verbunden ist, schließt jeden Hamiltonpfad zu einem Kreis. Vom Kreis zum Pfad:
|
|
Man verdoppelt einen Knoten $v$ zu einem Zwilling $v^*$ mit denselben Nachbarn
|
|
und klemmt an $v$ und $v^*$ je einen neuen Endknoten vom Grad 1 -- ein
|
|
Hamiltonpfad zwischen den beiden Endknoten entspricht dann genau einem
|
|
Hamiltonkreis durch $v$.
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{TSP}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{TSP (Entscheidungsvariante)}
|
|
Gegeben $n$ Städte, eine Distanz $d(i,j)$ für jedes Städtepaar und ein Budget
|
|
$L$. Gefragt: Gibt es eine Rundreise, die jede Stadt genau einmal besucht und
|
|
insgesamt höchstens $L$ kostet?
|
|
\end{defn}
|
|
|
|
Gegenüber dem Hamiltonkreis kommen Zahlen ins Spiel: Nicht \emph{ob} eine
|
|
Rundtour existiert, sondern ob eine \emph{billige} existiert. In der
|
|
Optimierungsfassung -- kürzeste Rundreise -- ist das TSP das Paradebeispiel des
|
|
Approximationsteils.
|
|
|
|
\begin{bsp}{Ein Budget einhalten}
|
|
Vier Städte an den Ecken eines Quadrats, Seitenlänge 1, Diagonalen 2. Die Tour
|
|
einmal außen herum kostet 4. Bei Budget $L = 4$ lautet die Antwort Ja; bei
|
|
$L = 3$ Nein, denn jede Rundreise über vier Städte braucht vier Teilstrecken
|
|
der Länge $\ge 1$.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum TSP in NP liegt}
|
|
|
|
\emph{Was das Zertifikat ist.} Die Stadtreihenfolge der behaupteten Rundreise.
|
|
|
|
\emph{Wie geprüft wird.} Der Verifizierer bestätigt zuerst, dass jede Stadt
|
|
genau einmal in der Reihenfolge steht. Dann summiert er die Distanzen von
|
|
Station zu Station, die Rückfahrt zum Start eingeschlossen, und vergleicht die
|
|
Gesamtsumme mit $L$. Summe im Budget und Reihenfolge vollständig: Annahme.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Existiert eine Rundreise im
|
|
Budget, dann wird ihre Reihenfolge eingereicht und angenommen. Existiert keine,
|
|
dann sprengt jede vollständige Reihenfolge das Budget -- der Summenvergleich
|
|
lehnt sie ab. Beide Richtungen greifen.
|
|
|
|
\emph{Wie lange es dauert.} $n$ Additionen und ein Vergleich: $O(n)$. Also
|
|
$\problem{TSP} \in \NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{$\problem{HK} \redp \problem{TSP}$: teuer machen, was verboten ist}
|
|
Aus dem HK-Graphen $G$ mit Knotenmenge $V$ wird die TSP-Instanz: Städte sind die
|
|
Knoten; $d(u,v) = 1$ für jede Kante von $G$, $d(u,v) = |V| + 1$ für jedes
|
|
Nicht-Kanten-Paar; Budget $L = |V|$. Eine Rundreise besteht aus genau $|V|$
|
|
Teilstrecken. Bleibt sie im Budget $|V|$, muss jede Teilstrecke den Preis 1
|
|
haben -- schon eine einzige Nicht-Kante spränge mit $|V|+1$ allein über das
|
|
Budget. Die Rundreise benutzt also nur echte Kanten und ist ein Hamiltonkreis.
|
|
Hat $G$ umgekehrt einen Hamiltonkreis, kostet dieser als Rundreise exakt $|V|$
|
|
und hält das Budget ein. Bemerkenswert: Das TSP bleibt sogar dann
|
|
NP-vollständig, wenn die Distanzen symmetrisch sind und die Dreiecksungleichung
|
|
erfüllen.
|
|
\end{idee}
|
|
|
|
\subsection*{Wohin die Härte weiterfließt}
|
|
|
|
Das TSP reicht seine Härte im Kurs nicht weiter. Es wird stattdessen zur
|
|
Hauptbühne des Approximationsteils: Dort zeigen wir, dass es ohne
|
|
Zusatzannahmen nicht einmal näherungsweise lösbar ist -- und mit
|
|
Dreiecksungleichung erstaunlich gut.
|
|
|
|
% ==================================================================
|
|
\section{3-dimensionales Matching}
|
|
% ==================================================================
|
|
|
|
Der dritte Ast der Landkarte führt weg von den Graphen, hinein in Mengen und
|
|
schließlich Zahlen. Sein erstes Glied handelt von Dreier-Zuordnungen.
|
|
|
|
\begin{defn}{3-dimensionales Matching (3-DM)}
|
|
Gegeben drei gleich große, disjunkte Mengen $U$, $V$, $W$ sowie eine Liste $T$
|
|
von Tripeln der Form $(u, v, w)$ mit $u \in U$, $v \in V$, $w \in W$. Gefragt:
|
|
Kann man Tripel aus $T$ so auswählen, dass jedes Element aller drei Mengen in
|
|
\emph{genau einem} gewählten Tripel vorkommt?
|
|
\end{defn}
|
|
|
|
\begin{analogie}
|
|
Drei gleich große Gruppen -- etwa Piloten, Flugzeuge und Zeitfenster -- sollen
|
|
zu kompletten Einsätzen kombiniert werden. Die Liste $T$ enthält die
|
|
\emph{zulässigen} Kombinationen. Gesucht ist ein Einsatzplan, in dem jeder
|
|
Pilot, jedes Flugzeug und jedes Zeitfenster genau einmal verplant ist.
|
|
\end{analogie}
|
|
|
|
\begin{bsp}{Ein gültiger Plan}
|
|
$U = \{u_1, u_2\}$, $V = \{v_1, v_2\}$, $W = \{w_1, w_2\}$;
|
|
$T$ enthalte $(u_1, v_1, w_2)$, $(u_2, v_2, w_1)$ und $(u_1, v_2, w_1)$. Die
|
|
Auswahl der ersten beiden Tripel verplant jedes der sechs Elemente genau einmal
|
|
-- ein 3-dimensionales Matching. Nimmt man stattdessen das dritte Tripel, lässt
|
|
sich kein zweites mehr ergänzen, ohne $u_1$, $v_2$ oder $w_1$ doppelt zu
|
|
verwenden.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum 3-DM in NP liegt}
|
|
|
|
\emph{Was das Zertifikat ist.} Die getroffene Tripelauswahl $M \subseteq T$.
|
|
|
|
\emph{Wie geprüft wird.} Der Verifizierer legt für jedes Element aller drei
|
|
Mengen einen Zähler an und geht die gewählten Tripel durch, wobei er für jede
|
|
der drei Komponenten den Zähler erhöht. Am Ende kontrolliert er: Steht jeder
|
|
Zähler auf genau 1? Zusätzlich prüft er $|M| = |U|$. Beides erfüllt: Annahme;
|
|
irgendein Zähler auf 0 oder $\ge 2$: Ablehnung.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Ein echtes Matching bringt
|
|
konstruktionsgemäß jeden Zähler auf exakt 1 und wird angenommen. Gibt es keines,
|
|
dann verfehlt jede Auswahl das Zählerbild -- irgendwo entsteht eine Doppelung
|
|
oder eine Lücke -- und sie wird abgelehnt.
|
|
|
|
\emph{Wie lange es dauert.} Einmal über die Auswahl laufen und Zähler pflegen:
|
|
$O(|T|)$ plus $O(|U|+|V|+|W|)$ fürs Kontrollieren. Also $\problem{3-DM} \in \NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{$\problem{SAT} \redp \problem{3-DM}$: Zahnräder, Andockstellen, Aufräumer}
|
|
Drei Baustein-Sorten übersetzen eine Formel in Tripel. \emph{Zahnräder:} Für
|
|
jede Variable ordnet man Tripel ringförmig an; ein Matching kann den Ring nur
|
|
in einer von zwei Verzahnungen abdecken -- die eine heißt \glqq wahr\grqq, die
|
|
andere \glqq falsch\grqq. Je nach Verzahnung bleiben genau die Literal-Elemente
|
|
der einen oder der anderen Sorte unbedeckt zurück. \emph{Andockstellen:} Für
|
|
jede Klausel gibt es ein Elementpaar, dessen Tripel nur an ein
|
|
\emph{freigebliebenes} Literal der Klausel andocken können -- das erzwingt, dass
|
|
jede Klausel ein wahres Literal hat. \emph{Aufräumer:} Zusätzliche Tripel
|
|
(\glqq Garbage Collection\grqq) sammeln alle danach noch unbedeckten
|
|
Literal-Elemente ein, damit die Bilanz \glqq jedes Element genau einmal\grqq{}
|
|
exakt aufgeht. Ein Matching existiert genau dann, wenn die Formel erfüllbar ist.
|
|
\end{idee}
|
|
|
|
\subsection*{Wohin die Härte weiterfließt}
|
|
|
|
\begin{idee}{$\problem{3-DM} \redp \problem{3-EC}$: nur die Brille wechseln}
|
|
Ein Tripel $(u,v,w)$ ist nichts anderes als eine dreielementige Menge
|
|
$\{u,v,w\}$ über dem Gesamtuniversum $U \cup V \cup W$. Mehr braucht die
|
|
Reduktion nicht -- ausgeführt wird sie beim 3-Exact Cover.
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{3-Exact Cover}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{3-Exact Cover (3-EC)}
|
|
Gegeben ein Universum $U$ mit $3m$ Elementen und eine Familie dreielementiger
|
|
Teilmengen $S_1, \dots, S_n \subseteq U$. Gefragt: Lassen sich Mengen so
|
|
auswählen, dass jedes Element von $U$ in \emph{genau einer} gewählten Menge
|
|
liegt -- eine lückenlose Überdeckung ohne Überlappung?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Exakt oder nicht}
|
|
$U = \{1, \dots, 6\}$ mit $S_1 = \{1,3,5\}$, $S_2 = \{2,4,6\}$,
|
|
$S_3 = \{1,2,3\}$. Die Wahl $\{S_1, S_2\}$ deckt jedes Element genau einmal --
|
|
exakt. Die Wahl $\{S_2, S_3\}$ deckt die 2 doppelt und lässt die 5 aus -- keine
|
|
exakte Überdeckung.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum 3-EC in NP liegt}
|
|
|
|
\emph{Was das Zertifikat ist.} Die Auswahl der Mengen. Eine exakte Überdeckung
|
|
von $3m$ Elementen durch Dreiermengen umfasst genau $m$ Mengen.
|
|
|
|
\emph{Wie geprüft wird.} Der Verifizierer führt eine Strichliste über die
|
|
Elemente von $U$: Für jede gewählte Menge macht er bei ihren drei Elementen
|
|
einen Strich. Danach kontrolliert er, dass jedes Element genau einen Strich
|
|
trägt -- keiner fehlt, keiner ist doppelt. Bestanden: Annahme; sonst Ablehnung.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Eine exakte Überdeckung erzeugt
|
|
per Definition genau das Strichbild \glqq überall eins\grqq{} und wird
|
|
angenommen. Existiert keine, produziert jede Auswahl entweder eine Lücke oder
|
|
eine Doppelung und fällt durch.
|
|
|
|
\emph{Wie lange es dauert.} Strichliste führen und ablesen: linear in der
|
|
Eingabe. Also $\problem{3-EC} \in \NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{$\problem{3-DM} \redp \problem{3-EC}$: dieselben Daten, neue Lesart}
|
|
Man nimmt die 3-DM-Instanz und liest sie um: Das Universum ist
|
|
$U \cup V \cup W$ (Größe $3 \cdot |U|$), und jedes Tripel $(u,v,w)$ wird zur
|
|
Menge $\{u,v,w\}$. Es wird nichts hinzugefügt und nichts verändert.
|
|
\end{idee}
|
|
|
|
Dass die Antwort erhalten bleibt, liegt daran, dass beide Bedingungen dasselbe
|
|
sagen: \glqq Jedes Element kommt in genau einem gewählten Tripel vor\grqq{}
|
|
(3-DM) und \glqq jedes Element liegt in genau einer gewählten Menge\grqq{}
|
|
(3-EC) sind identische Forderungen, nur einmal über Tripel und einmal über
|
|
Mengen formuliert. Eine Auswahl erfüllt die eine genau dann, wenn sie die andere
|
|
erfüllt -- in beide Richtungen. Die Umformung ist reine Notation und damit
|
|
trivial polynomiell berechenbar in einem Durchlauf. Da \problem{3-DM}
|
|
NP-vollständig ist und $\problem{3-EC} \in \NP$, ist \problem{3-EC}
|
|
NP-vollständig.
|
|
|
|
\subsection*{Wohin die Härte weiterfließt}
|
|
|
|
\begin{idee}{$\problem{3-EC} \redp \problem{SubSet Sum}$: Überdecken wird Addieren}
|
|
Jede Menge wird als Zahl in einem Stellensystem mit riesiger Basis kodiert;
|
|
exakt überdecken heißt dann, die Zahl \glqq lauter Einsen\grqq{} als Summe zu
|
|
treffen. Vollständig ausgeführt beim SubSet Sum.
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{SubSet Sum}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{SubSet Sum}
|
|
Gegeben ganze Zahlen $c_1, \dots, c_n$ und ein Ziel $K$. Gefragt: Existiert eine
|
|
Auswahl dieser Zahlen, deren Summe \emph{exakt} $K$ ergibt?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Ein Ziel treffen}
|
|
Zahlen $5, 9, 11, 2$ und Ziel $K = 16$. Die Auswahl $\{5, 9, 2\}$ summiert auf
|
|
16 -- getroffen. $\{5, 11\}$ ergibt dagegen 16 ebenfalls! Beide sind gültige
|
|
Zertifikate; eines genügt. Für $K = 8$ hingegen trifft keine Auswahl.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum SubSet Sum in NP liegt}
|
|
|
|
\emph{Was das Zertifikat ist.} Die Auswahl -- pro Zahl ein Bit
|
|
(\glqq dabei / nicht dabei\grqq).
|
|
|
|
\emph{Wie geprüft wird.} Der Verifizierer addiert die ausgewählten Zahlen und
|
|
vergleicht das Ergebnis mit $K$. Bei Gleichheit akzeptiert er, sonst nicht.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Gibt es eine treffende Auswahl,
|
|
liefert genau sie die Summe $K$ und wird angenommen. Gibt es keine, weicht jede
|
|
eingereichte Auswahl von $K$ ab und wird abgewiesen -- der Vergleich lässt
|
|
keinen Spielraum.
|
|
|
|
\emph{Wie lange es dauert.} Höchstens $n$ Additionen und ein Vergleich (auf
|
|
langen Zahlen, deren Länge Teil der Eingabe ist): polynomiell. Also
|
|
$\problem{SubSet Sum} \in \NP$. Die Schwere steckt nicht im Nachrechnen, sondern
|
|
darin, unter $2^n$ Auswahlmöglichkeiten die richtige zu \emph{finden}.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{$\problem{3-EC} \redp \problem{SubSet Sum}$: Stellenwertsystem ohne Übertrag}
|
|
Nummeriere die Universums-Elemente $1$ bis $3m$ und gib jedem eine
|
|
\emph{Ziffernposition} in einem Stellensystem zur Basis $n+1$ ($n$ = Anzahl der
|
|
Mengen). Jede Menge $S_j$ wird zur Zahl mit Ziffer 1 an den Positionen ihrer
|
|
drei Elemente:
|
|
\[
|
|
c_j = \sum_{u_i \in S_j} (n+1)^{\,i-1}.
|
|
\]
|
|
Das Ziel $K$ ist die Zahl mit Ziffer 1 an \emph{allen} $3m$ Positionen.
|
|
\end{idee}
|
|
|
|
Der entscheidende Kunstgriff ist die Basiswahl. Addiert man beliebig viele der
|
|
$c_j$, dann sammeln sich an jeder Ziffernposition höchstens $n$ Einsen -- weniger
|
|
als die Basis $n+1$. Es entsteht also \emph{nie ein Übertrag}, und die Addition
|
|
wirkt an jeder Position unabhängig. \glqq Summe $= K$\grqq{} zerfällt dadurch in
|
|
$3m$ separate Bedingungen: \emph{jede} Position wird von \emph{genau einer}
|
|
gewählten Menge bedient. Das ist Wort für Wort die exakte Überdeckung. Bei Basis
|
|
2 wäre das falsch -- Überträge könnten Lücken und Doppelungen gegeneinander
|
|
verrechnen.
|
|
|
|
\begin{bsp}{Die Kodierung nachgerechnet}
|
|
$U = \{1,\dots,6\}$, also $m = 2$; Mengen $S_1 = \{1,2,3\}$, $S_2 = \{4,5,6\}$,
|
|
$S_3 = \{1,2,4\}$, $S_4 = \{3,5,6\}$; damit $n = 4$ und Basis 5.
|
|
\begin{center}\small
|
|
\begin{tabular}{lll}
|
|
\toprule
|
|
Menge & Positionen & Wert zur Basis 5\\
|
|
\midrule
|
|
$S_1$ & $1,2,3$ & $5^0 + 5^1 + 5^2 = 31$\\
|
|
$S_2$ & $4,5,6$ & $5^3 + 5^4 + 5^5 = 3875$\\
|
|
$S_3$ & $1,2,4$ & $5^0 + 5^1 + 5^3 = 131$\\
|
|
$S_4$ & $3,5,6$ & $5^2 + 5^4 + 5^5 = 3775$\\
|
|
\midrule
|
|
Ziel $K$ & $1,\dots,6$ & $5^0 + \dots + 5^5 = 3906$\\
|
|
\bottomrule
|
|
\end{tabular}
|
|
\end{center}
|
|
Probe: $31 + 3875 = 3906$ -- und $\{S_1, S_2\}$ überdeckt $U$ exakt. Genauso
|
|
$131 + 3775 = 3906$ mit der exakten Überdeckung $\{S_3, S_4\}$. Auswahlen, die
|
|
nicht exakt überdecken, verfehlen die Zielzahl.
|
|
\end{bsp}
|
|
|
|
Neben dieser Kette gibt es eine zweite, gezielt sparsame Härte-Quelle, die
|
|
direkt bei \problem{3-SAT} ansetzt. Sie wird in Teil C gebraucht.
|
|
|
|
\begin{idee}{$\problem{3-SAT} \redp \problem{SubSet Sum}$ (streng): Dezimalziffern}
|
|
Man spendiert jeder Variablen und jeder Klausel eine eigene Dezimalstelle --
|
|
die Zahlen haben $n + m$ Ziffern zur Basis 10. Für jede Variable $x_i$ gibt es
|
|
\emph{zwei} Zahlen: eine für \glqq wahr\grqq, eine für \glqq falsch\grqq. Beide
|
|
tragen an der Variablenstelle $i$ eine 1 -- das Ziel verlangt dort genau 1,
|
|
erzwingt also die Wahl \emph{einer} der beiden. An den Klauselstellen trägt die
|
|
\glqq wahr\grqq-Zahl Einsen bei den Klauseln, in denen $x_i$ positiv vorkommt,
|
|
die \glqq falsch\grqq-Zahl bei denen mit $\neg x_i$. Das Ziel verlangt an jeder
|
|
Klauselstelle eine 3; da eine erfüllte Klausel ein bis drei wahre Literale
|
|
liefert, gleichen \emph{zwei Ausgleichszahlen} pro Klausel (Wert 1 an genau
|
|
dieser Stelle) die Differenz aus. Erfüllbarkeit und Zielsumme entsprechen sich
|
|
exakt. Die Konstruktion erzeugt nur $2n + 2m$ Zahlen -- diese Sparsamkeit macht
|
|
sie für die unteren Schranken wertvoll.
|
|
\end{idee}
|
|
|
|
\subsection*{Wohin die Härte weiterfließt}
|
|
|
|
\begin{idee}{$\problem{SubSet Sum} \redp \problem{Partition}$: das Gleichgewicht erzwingen}
|
|
Zwei zusätzliche, geschickt dimensionierte Zahlen verwandeln \glqq triff
|
|
$K$\grqq{} in \glqq teile alles in zwei gleiche Hälften\grqq. Ausgeführt bei
|
|
Partition.
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{SubSet Sum} \redp \problem{Knapsack}$: ein Spezialfall}
|
|
Setzt man im Rucksack Gewicht $=$ Profit und Kapazität $=$ Zielprofit $= K$,
|
|
kollabieren beide Rucksack-Bedingungen zu \glqq Summe exakt $K$\grqq. Ausgeführt
|
|
beim Knapsack.
|
|
\end{idee}
|
|
|
|
\begin{idee}{$\problem{SubSet Sum} \redp$ Kardinalitäts-Variante: Verschieben und Auffüllen}
|
|
Verlangt die Variante zusätzlich \glqq nimm genau $n$ Zahlen\grqq, erhöht man
|
|
jede Originalzahl um 1 und legt $n$ Füll-Einsen dazu; das Ziel wächst auf
|
|
$K + n$. Die Füllzahlen gleichen die Anzahl aus, ohne die Substanz der Summe zu
|
|
verändern.
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{Partition}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{Partition}
|
|
Gegeben ganze Zahlen $c_1, \dots, c_n$. Gefragt: Kann man sie in zwei Gruppen
|
|
mit \emph{gleicher Summe} aufteilen -- gibt es also eine Auswahl, deren Summe
|
|
exakt die Hälfte der Gesamtsumme beträgt?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Ja-Instanz und Nein-Instanz}
|
|
Die Zahlen $1, 5, 6, 2$ haben Gesamtsumme 14, Hälfte 7. Die Auswahl $\{1, 6\}$
|
|
trifft die 7, der Rest $\{5, 2\}$ ebenso -- eine gültige Halbierung, Antwort
|
|
Ja. Anders die Zahlen $4, 7, 3, 2$: Gesamtsumme 16, Hälfte 8. Probiert man alle
|
|
Teilsummen durch, erreicht man 6, 7 und 9, aber nie genau 8 -- keine Halbierung
|
|
möglich, Antwort Nein.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Partition in NP liegt}
|
|
|
|
\emph{Was das Zertifikat ist.} Die Auswahl einer Seite der Aufteilung -- pro
|
|
Zahl ein Bit.
|
|
|
|
\emph{Wie geprüft wird.} Der Verifizierer berechnet zweierlei: die Gesamtsumme
|
|
$N$ aller Zahlen und die Summe der ausgewählten. Er akzeptiert genau dann, wenn
|
|
die Auswahl-Summe exakt $N/2$ beträgt.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Lässt sich die Menge halbieren,
|
|
dann erreicht die passende Auswahl exakt $N/2$ und wird angenommen. Lässt sie
|
|
sich nicht halbieren, dann liegt jede Auswahl über oder unter $N/2$, und der
|
|
Vergleich weist sie ab.
|
|
|
|
\emph{Wie lange es dauert.} Zwei Summationen über $n$ Zahlen: $O(n)$
|
|
Arithmetikschritte. Also $\problem{Partition} \in \NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{$\problem{SubSet Sum} \redp \problem{Partition}$: zwei Ausgleichsgewichte}
|
|
Gegeben Zahlen $c_1, \dots, c_n$ mit Ziel $K$. Setze $N = \bigl(\sum_j c_j\bigr)
|
|
+ 1$ und lege \emph{zwei neue Zahlen} dazu: $a = N - K$ und $b = K + 1$.
|
|
\end{idee}
|
|
|
|
Die Rechnung dahinter: Die erweiterte Menge hat die Gesamtsumme
|
|
$\sum_j c_j + (N-K) + (K+1) = (N-1) + N + 1 = 2N$; eine gültige Halbierung muss
|
|
also je Seite exakt $N$ erreichen. Nun das zentrale Detail: $a + b = N + 1 > N$
|
|
-- die beiden neuen Zahlen \emph{zusammen} sprengen jede Hälfte. In jeder
|
|
Halbierung liegen sie deshalb zwangsläufig auf \emph{verschiedenen} Seiten.
|
|
Betrachte die Seite mit $a = N - K$: Ihre übrigen Mitglieder sind Originalzahlen
|
|
und müssen zusammen $N - (N-K) = K$ ergeben -- eine Ziel-treffende Auswahl im
|
|
Sinne von SubSet Sum. Umgekehrt: Trifft eine Original-Auswahl $S$ das Ziel $K$,
|
|
dann bildet $S \cup \{a\}$ eine Seite mit Summe $K + (N-K) = N$ -- eine gültige
|
|
Halbierung. Ja- und Nein-Antworten stimmen also überein. Zwei Zahlen anhängen
|
|
kostet nichts; die Reduktion ist polynomiell, \problem{Partition}
|
|
NP-vollständig.
|
|
|
|
\begin{bsp}{Die Ausgleichsgewichte in Aktion}
|
|
Zahlen $3, 5, 8, 4$ (Summe 20), Ziel $K = 12$. Dann $N = 21$, und die neuen
|
|
Zahlen sind $a = 9$ und $b = 13$. Erweiterte Menge: $\{3,5,8,4,9,13\}$ mit
|
|
Gesamtsumme 42, Halbierungswert 21. Die Original-Auswahl $\{8,4\}$ trifft
|
|
$K = 12$; zusammen mit $a = 9$ entsteht die Seite $\{8,4,9\}$ mit Summe 21 --
|
|
die andere Seite $\{3,5,13\}$ hat ebenfalls 21. Es geht auf.
|
|
\end{bsp}
|
|
|
|
\subsection*{Wohin die Härte weiterfließt}
|
|
|
|
\begin{idee}{$\problem{Partition} \redp P2\|\Cmax$: Halbieren heißt Balancieren}
|
|
Deutet man die Zahlen als Job-Laufzeiten auf zwei Maschinen, dann heißt
|
|
\glqq beide Maschinen gleichzeitig fertig\grqq{} genau \glqq Zahlen
|
|
halbiert\grqq. Ausgeführt beim Scheduling.
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{Knapsack}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{Knapsack (Rucksackproblem)}
|
|
Gegeben $n$ Gegenstände -- der $i$-te mit Gewicht $w_i$ und Profit $p_i$ --
|
|
sowie eine Tragkraft $B$ und ein Profitziel $P$. Gefragt: Gibt es eine Auswahl,
|
|
deren Gesamtgewicht höchstens $B$ und deren Gesamtprofit mindestens $P$ ist?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Packen mit zwei Bedingungen}
|
|
Gegenstände $(w, p)$: $(2, 3)$, $(3, 4)$, $(4, 6)$; Tragkraft $B = 6$, Ziel
|
|
$P = 9$. Die Auswahl $\{(2,3), (4,6)\}$ wiegt 6 und bringt Profit 9 -- beide
|
|
Bedingungen erfüllt, Antwort Ja. Die Auswahl aller drei wöge 9 und ist verboten.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Knapsack in NP liegt}
|
|
|
|
\emph{Was das Zertifikat ist.} Die Packliste -- pro Gegenstand ein Bit.
|
|
|
|
\emph{Wie geprüft wird.} Der Verifizierer bildet zwei Summen über die
|
|
ausgewählten Gegenstände: das Gesamtgewicht und den Gesamtprofit. Er akzeptiert
|
|
genau dann, wenn das Gewicht $\le B$ \emph{und} der Profit $\ge P$ ist.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Eine zulässige, profitable Auswahl
|
|
besteht beide Vergleiche und wird angenommen. Existiert keine, dann reißt jede
|
|
Auswahl mindestens eine der beiden Schranken, und einer der Vergleiche schlägt
|
|
fehl.
|
|
|
|
\emph{Wie lange es dauert.} Zwei Summen, zwei Vergleiche: $O(n)$. Also
|
|
$\problem{Knapsack} \in \NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{$\problem{SubSet Sum} \redp \problem{Knapsack}$: beide Schranken zusammenziehen}
|
|
Aus der SubSet-Sum-Instanz $(c_1, \dots, c_n; K)$ macht man Gegenstände mit
|
|
$w_i = p_i = c_i$ und setzt $B = P = K$. Die Rucksackfrage verlangt nun eine
|
|
Auswahl mit Summe $\le K$ (Gewicht) \emph{und} Summe $\ge K$ (Profit) -- da
|
|
beide Summen identisch sind, geht das nur mit Summe \emph{exakt} $K$. Damit sind
|
|
die Ja-Instanzen beider Probleme dieselben, in beiden Richtungen. Die Umformung
|
|
ist ein einfacher Durchlauf. \problem{Knapsack} ist NP-vollständig.
|
|
\end{idee}
|
|
|
|
\subsection*{Wohin die Härte weiterfließt}
|
|
|
|
Keine weitere Reduktion geht vom Rucksack aus. Dafür ist er im
|
|
Approximationsteil das Vorzeigebeispiel für die ganze Palette: vom scheiternden
|
|
Greedy bis zum FPTAS.
|
|
|
|
% ==================================================================
|
|
\section{$P\|\Cmax$ (Scheduling)}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{$P\|\Cmax$}
|
|
Gegeben $n$ Jobs mit Laufzeiten $p_1, \dots, p_n$ und $m$ baugleiche Maschinen.
|
|
Jeder Job läuft komplett auf einer Maschine. Der \emph{Makespan} eines Plans ist
|
|
die Fertigstellungszeit der am längsten laufenden Maschine. Optimierungsziel:
|
|
den Makespan minimieren; Entscheidungsfrage: Geht Makespan $\le T$?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Lasten verteilen}
|
|
Jobs $5, 4, 3, 2$ auf zwei Maschinen. Verteilt man $\{5, 2\}$ und $\{4, 3\}$,
|
|
sind beide Maschinen nach 7 Zeiteinheiten fertig -- Makespan 7. Schlechter wäre
|
|
$\{5, 4\}$ gegen $\{3, 2\}$: Makespan 9. Unter 7 geht es nicht, denn die
|
|
Gesamtarbeit 14 verteilt auf 2 Maschinen erzwingt mindestens 7.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum $P\|\Cmax$ in NP liegt}
|
|
|
|
\emph{Was das Zertifikat ist.} Der Plan -- für jeden Job die Nummer seiner
|
|
Maschine.
|
|
|
|
\emph{Wie geprüft wird.} Der Verifizierer summiert je Maschine die Laufzeiten
|
|
der dort eingeplanten Jobs, bestimmt das Maximum dieser Summen und vergleicht
|
|
es mit $T$. Liegt es darunter oder darauf, akzeptiert er.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Ein Plan mit Makespan $\le T$
|
|
besteht den Vergleich. Existiert keiner, dann hat jeder eingereichte Plan eine
|
|
Maschine über $T$, und das Maximum verrät sie.
|
|
|
|
\emph{Wie lange es dauert.} Jeden Job einmal anfassen: $O(n)$. Also liegt die
|
|
Entscheidungsvariante von $P\|\Cmax$ in $\NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{$\problem{Partition} \redp P2\|\Cmax$: perfekte Balance}
|
|
Die Partition-Zahlen werden Jobs, die Maschinenzahl ist 2, und als
|
|
Makespan-Schranke wählt man $T = \frac12 \sum_j c_j$. Die Gesamtarbeit beider
|
|
Maschinen ist fix $\sum_j c_j$; ein Makespan von höchstens $T$ heißt also, dass
|
|
\emph{keine} Maschine über die Hälfte kommt -- und weil beide zusammen das Ganze
|
|
stemmen, tragen dann \emph{beide exakt} die Hälfte. Ein solcher Plan ist
|
|
wörtlich eine Halbierung der Zahlen, und jede Halbierung ist umgekehrt so ein
|
|
Plan. Damit ist das Scheduling bereits mit \emph{zwei} Maschinen NP-vollständig
|
|
-- mehr Maschinen machen es nicht leichter.
|
|
\end{idee}
|
|
|
|
\subsection*{Wohin die Härte weiterfließt}
|
|
|
|
Keine ausgehende Reduktion; im Approximationsteil liefert das Scheduling die
|
|
Bühne für List Scheduling und LPT.
|
|
|
|
% ==================================================================
|
|
\section{Hitting Set}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{Hitting Set}
|
|
Gegeben ein Universum $U$, Mengen $F_1, \dots, F_r \subseteq U$ und eine Zahl
|
|
$k$. Eine Menge $H \subseteq U$ \glqq trifft\grqq{} $F_i$, wenn
|
|
$H \cap F_i \ne \emptyset$. Gefragt: Gibt es ein $H$ mit höchstens $k$
|
|
Elementen, das \emph{alle} $F_i$ trifft?
|
|
\end{defn}
|
|
|
|
\begin{analogie}
|
|
Die Mengen $F_i$ sind Kundenwünsche -- jeder Kunde nennt einige akzeptable
|
|
Produkte. Gesucht ist ein Sortiment aus höchstens $k$ Produkten, das
|
|
\emph{jeden} Kunden zufriedenstellt: Von jedem Wunschzettel muss mindestens ein
|
|
Produkt im Sortiment sein.
|
|
\end{analogie}
|
|
|
|
\begin{bsp}{Ein kleines Sortiment}
|
|
$U = \{1,2,3,4,5\}$; Wünsche $F_1 = \{1,2\}$, $F_2 = \{2,3\}$, $F_3 = \{4,5\}$.
|
|
Das Sortiment $\{2, 4\}$ trifft alle drei Wünsche -- Größe 2. Mit einem einzigen
|
|
Produkt geht es nicht, denn $F_1 \cup F_2$ und $F_3$ sind disjunkt.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Hitting Set in NP liegt}
|
|
|
|
\emph{Was das Zertifikat ist.} Die Treffermenge $H$.
|
|
|
|
\emph{Wie geprüft wird.} Der Verifizierer zählt $|H|$ gegen $k$. Danach nimmt er
|
|
sich jede Menge $F_i$ vor und sucht ein gemeinsames Element mit $H$. Wird er bei
|
|
jeder fündig und stimmt die Größe, akzeptiert er; eine verfehlte Menge genügt
|
|
zur Ablehnung.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Ein echtes Hitting Set der Größe
|
|
$\le k$ übersteht alle Suchen. Existiert keines, lässt jede Menge $H$ dieser
|
|
Größe mindestens ein $F_i$ unberührt, und die Suche dort scheitert.
|
|
|
|
\emph{Wie lange es dauert.} Für jede der $r$ Mengen ein Abgleich mit $H$:
|
|
$O(r \cdot |U|)$. Also $\problem{Hitting Set} \in \NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{$\problem{3-SAT} \redp \problem{Hitting Set}$: Belegung als Auswahl}
|
|
Das Universum besteht aus allen $2n$ Literalen. Es gibt zwei Sorten von Mengen:
|
|
Für jede Variable die \emph{Paarmenge} $\{x_i, \bar x_i\}$ und für jede Klausel
|
|
die Menge ihrer (höchstens drei) Literale. Die Schranke ist $k = n$. Die $n$
|
|
disjunkten Paarmengen zwingen jede Lösung, aus \emph{jedem} Paar mindestens ein
|
|
Literal zu nehmen -- bei Budget $n$ also \emph{genau} eines: Das ist eine
|
|
Belegung. Die Klauselmengen verlangen zusätzlich, dass diese Belegung in jeder
|
|
Klausel ein Literal trifft -- die Klausel also erfüllt. Ein Hitting Set der
|
|
Größe $n$ existiert demnach genau dann, wenn die Formel erfüllbar ist; beide
|
|
Richtungen stecken in dieser Entsprechung. Der Aufbau ist ein Durchlauf über die
|
|
Formel. \problem{Hitting Set} ist NP-vollständig.
|
|
\end{idee}
|
|
|
|
\subsection*{Wohin die Härte weiterfließt}
|
|
|
|
\begin{idee}{$\problem{Hitting Set} \redp \problem{Set Cover}$: Seiten wechseln}
|
|
Elemente und Mengen tauschen die Plätze -- was vorher traf, überdeckt nachher.
|
|
Ausgeführt beim Set Cover.
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{Set Cover}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{Set Cover}
|
|
Gegeben ein Universum $U$, Mengen $S_1, \dots, S_r \subseteq U$ und eine Zahl
|
|
$k$. Gefragt: Gibt es höchstens $k$ dieser Mengen, deren Vereinigung ganz $U$
|
|
ergibt?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Alles abdecken}
|
|
$U = \{1,2,3,4,5\}$; $S_1 = \{1,2,3\}$, $S_2 = \{3,4\}$, $S_3 = \{4,5\}$. Die
|
|
Wahl $\{S_1, S_3\}$ vereinigt sich zu $\{1,2,3,4,5\} = U$ -- ein Set Cover der
|
|
Größe 2.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Set Cover in NP liegt}
|
|
|
|
\emph{Was das Zertifikat ist.} Die Liste der gewählten Mengen-Indizes.
|
|
|
|
\emph{Wie geprüft wird.} Der Verifizierer zählt die gewählten Mengen gegen $k$.
|
|
Dann markiert er alle Elemente, die in irgendeiner gewählten Menge vorkommen,
|
|
und kontrolliert, ob ganz $U$ markiert ist. Vollständig markiert und Anzahl im
|
|
Rahmen: Annahme.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Ein echtes Set Cover markiert
|
|
alles und wird angenommen. Gibt es keines mit $\le k$ Mengen, bleibt bei jeder
|
|
solchen Wahl ein Element unmarkiert -- Ablehnung.
|
|
|
|
\emph{Wie lange es dauert.} Markieren über alle gewählten Mengen:
|
|
$O(r \cdot |U|)$. Also $\problem{Set Cover} \in \NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{$\problem{Hitting Set} \redp \problem{Set Cover}$: der Seitenwechsel}
|
|
Aus der Hitting-Set-Instanz (Universum $U$, Mengen $F_1, \dots, F_r$, Schranke
|
|
$k$) wird eine Set-Cover-Instanz mit \emph{vertauschten Rollen}: Das neue
|
|
Universum sind die Mengen-Nummern $\{1, \dots, r\}$; für jedes alte Element
|
|
$u \in U$ entsteht die neue Menge $D_u = \{\, i \mid u \in F_i \,\}$ -- die
|
|
Nummern aller alten Mengen, die $u$ enthalten. Die Schranke bleibt $k$.
|
|
\end{idee}
|
|
|
|
Die Entsprechung: Wählt man im Original die Treffermenge $H = \{u_1, \dots\}$,
|
|
dann überdecken die neuen Mengen $D_{u_1}, \dots$ genau die Nummern aller
|
|
$F_i$, die von $H$ getroffen werden. \glqq$H$ trifft alle $F_i$\grqq{} übersetzt
|
|
sich also in \glqq die gewählten $D_u$ überdecken alle Nummern\grqq{} -- ein Set
|
|
Cover derselben Größe. Und rückwärts genauso: Ein Set Cover aus $D$-Mengen
|
|
benennt eine gleich große Trefferauswahl. Beide Richtungen sind ein reiner
|
|
Blickwechsel. Bemerkenswert: Wendet man den Seitenwechsel zweimal an, steht die
|
|
ursprüngliche Instanz wieder da -- die Übersetzung ist ihre eigene Umkehrung.
|
|
Deshalb sind Hitting Set und Set Cover exakt gleich schwer.
|
|
\problem{Set Cover} ist NP-vollständig.
|
|
|
|
\subsection*{Wohin die Härte weiterfließt}
|
|
|
|
\begin{idee}{$\problem{Set Cover} \redp \problem{Hitting Set}$: derselbe Wechsel zurück}
|
|
Weil der Seitenwechsel seine eigene Umkehrung ist, funktioniert er wörtlich auch
|
|
von Set Cover nach Hitting Set: Neue Elemente sind die Set-Cover-Mengennummern,
|
|
neue Mengen entstehen pro Element $u$ als Nummernliste seiner Überdecker, $k$
|
|
bleibt. Die Antwort bleibt erhalten -- mit derselben Begründung wie eben, nur
|
|
mit vertauschten Namen. Im Kurs wird dieses Paar vor allem bei den unteren
|
|
Schranken in Teil C gebraucht.
|
|
\end{idee}
|
|
|
|
% ==================================================================
|
|
\section{Dominating Set}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{Dominating Set}
|
|
Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Eine Menge $D \subseteq V$
|
|
\emph{dominiert} den Graphen, wenn jeder Knoten entweder selbst zu $D$ gehört
|
|
oder mit einem Knoten aus $D$ benachbart ist. Gefragt: Gibt es ein solches $D$
|
|
mit höchstens $k$ Knoten?
|
|
\end{defn}
|
|
|
|
\begin{analogie}
|
|
Denk an Funkmasten in Dörfern: Ein Mast versorgt sein eigenes Dorf und alle
|
|
direkt verbundenen Nachbardörfer. Ein Dominating Set ist ein Mastenplan, bei dem
|
|
jedes Dorf Empfang hat.
|
|
\end{analogie}
|
|
|
|
\begin{bsp}{Ein Mast genügt}
|
|
Ein sternförmiges Netz: Zentrum $z$, außen $a, b, c, d$, jede Außenstelle nur
|
|
mit $z$ verbunden. Der Plan $D = \{z\}$ dominiert alles -- $z$ versorgt sich
|
|
selbst und alle vier Nachbarn. Größe 1.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Dominating Set in NP liegt}
|
|
|
|
\emph{Was das Zertifikat ist.} Die Auswahl $D$ -- ein Bit pro Knoten.
|
|
|
|
\emph{Wie geprüft wird.} Zwei Schritte. Erstens zählt der Verifizierer $|D|$
|
|
gegen $k$. Zweitens prüft er die Versorgung: Für jeden Knoten $v$ des Graphen
|
|
fragt er, ob $v \in D$ gilt -- und falls nicht, geht er die Nachbarn von $v$
|
|
durch (eine Zeile der Adjazenzmatrix) und sucht dort ein Mitglied von $D$.
|
|
Bleibt ein Knoten unversorgt, lehnt er ab; sonst akzeptiert er.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Ein dominierendes $D$ der Größe
|
|
$\le k$ lässt keinen Knoten unversorgt und besteht beide Schritte. Existiert
|
|
keines, hat jede Auswahl dieser Größe irgendwo einen unversorgten Knoten, und
|
|
die Versorgungsprüfung findet ihn.
|
|
|
|
\emph{Wie lange es dauert.} Pro Knoten eine Matrixzeile durchsehen: $O(|V|^2)$
|
|
insgesamt, dazu $O(|V|)$ fürs Zählen. Also $\problem{Dominating Set} \in \NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{zushang}
|
|
Für \problem{Dominating Set} enthält das Kursmaterial \emph{nur} den
|
|
NP-Zugehörigkeits-Nachweis -- er war eine Klausuraufgabe. Eine Härte-Reduktion
|
|
wird im Kurs nicht geführt. Das Problem ist in der Literatur als NP-vollständig
|
|
bekannt, aber der zugehörige Beweis gehört nicht zum gesicherten Stoff dieses
|
|
Kurses, und deshalb steht er auch nicht in diesem Heft.
|
|
\end{zushang}
|
|
|
|
% ==================================================================
|
|
\section{Longest Path}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{Longest Path}
|
|
Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Ein Pfad heißt \emph{einfach},
|
|
wenn er keinen Knoten wiederholt; seine Länge ist die Zahl seiner Kanten.
|
|
Gefragt: Enthält $G$ einen einfachen Pfad der Länge mindestens $k$?
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Pfadlängen}
|
|
Im Kreis aus fünf Knoten $1 - 2 - 3 - 4 - 5 - 1$ ist $1,2,3,4,5$ ein einfacher
|
|
Pfad der Länge 4. Länger geht es nicht -- ein sechster Schritt müsste einen
|
|
besuchten Knoten wiederholen.
|
|
\end{bsp}
|
|
|
|
\subsection*{Warum Longest Path in NP liegt}
|
|
|
|
\emph{Was das Zertifikat ist.} Die Knotenfolge $(v_0, v_1, \dots, v_k)$ des
|
|
behaupteten Pfades.
|
|
|
|
\emph{Wie geprüft wird.} Der Verifizierer kontrolliert zweierlei: dass in der
|
|
Folge kein Knoten doppelt vorkommt (paarweise Vergleiche oder eine
|
|
Markierungstabelle), und dass jedes aufeinanderfolgende Paar $(v_i, v_{i+1})$
|
|
durch eine Kante verbunden ist (ein Nachschlag pro Schritt). Beides bestanden:
|
|
Annahme.
|
|
|
|
\emph{Warum das in beide Richtungen stimmt.} Hat der Graph einen einfachen Pfad
|
|
der Länge $\ge k$, dann bilden dessen erste $k+1$ Knoten ein Zertifikat, das
|
|
beide Kontrollen besteht. Und jede Folge, die beide Kontrollen besteht, ist
|
|
selbst ein einfacher Pfad der Länge $k$ -- der Graph hat dann einen. Kein
|
|
Vorschlag kann den Verifizierer täuschen.
|
|
|
|
\emph{Wie lange es dauert.} Verschiedenheit in $O(k^2)$, Kanten in $O(k)$:
|
|
zusammen $O(k^2) \subseteq O(|V|^2)$. Also $\problem{Longest Path} \in \NP$.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{zushang}
|
|
Auch beim \problem{Longest Path} behandelt der Kurs ausschließlich die
|
|
NP-Zugehörigkeit -- ebenfalls als Klausuraufgabe. Eine Härte-Reduktion (etwa
|
|
über den Hamiltonpfad, den Longest Path verallgemeinert) kommt im Kursmaterial
|
|
nicht vor und wird hier deshalb nicht als Kursstoff ausgegeben.
|
|
\end{zushang}
|
|
|
|
% ==================================================================
|
|
\section{Das Halteproblem}
|
|
% ==================================================================
|
|
|
|
Der Katalog schließt mit einem Ausreißer -- einem Problem, das NP-schwer ist,
|
|
ohne in $\NP$ zu liegen. Es markiert die Außengrenze der bisherigen Begriffe.
|
|
|
|
\begin{defn}{Halteproblem}
|
|
Gegeben der Quelltext eines Programms $M$ und eine Eingabe $w$. Gefragt: Stoppt
|
|
$M$, wenn man es auf $w$ laufen lässt -- oder läuft es endlos?
|
|
\end{defn}
|
|
|
|
Turing hat bewiesen, dass \emph{kein} Algorithmus diese Frage für alle
|
|
Programme beantwortet -- das Halteproblem ist \emph{unentscheidbar}. Daraus
|
|
folgt sofort: Es liegt nicht in $\NP$. Denn jedes NP-Problem ist entscheidbar --
|
|
zur Not probiert man alle Zertifikate durch, die der Verifizierer innerhalb
|
|
seiner Laufzeitschranke überhaupt lesen kann; das dauert exponentiell lange,
|
|
terminiert aber.
|
|
|
|
\subsection*{Woher die Härte kommt}
|
|
|
|
\begin{idee}{$\problem{SAT} \redp \problem{Halteproblem}$: die Suchschleife}
|
|
Zu einer Formel $\varphi$ konstruiert man ein Programm $M_\varphi$ nach festem
|
|
Muster: Es zählt alle Belegungen der Variablen von $\varphi$ der Reihe nach auf,
|
|
testet jede, und \emph{stoppt}, sobald eine die Formel erfüllt -- findet es
|
|
keine, läuft die Schleife für immer weiter. Als Reduktionsausgabe dient das
|
|
Paar $\langle M_\varphi, \text{leere Eingabe} \rangle$.
|
|
\end{idee}
|
|
|
|
Die Antwort-Erhaltung: Ist $\varphi$ erfüllbar, erreicht die Schleife irgendwann
|
|
die erste erfüllende Belegung und $M_\varphi$ hält -- Ja bleibt Ja. Ist
|
|
$\varphi$ unerfüllbar, findet die Schleife nie einen Grund zu stoppen und läuft
|
|
ewig -- Nein bleibt Nein. Entscheidend ist die Trennung zweier Zeitbegriffe:
|
|
$M_\varphi$ selbst darf beliebig lange laufen, denn \emph{ausgeführt} wird es in
|
|
der Reduktion nie. Polynomiell sein muss nur das \emph{Aufschreiben} seines
|
|
Quelltexts aus $\varphi$ -- und der ist kaum mehr als die Formel plus eine
|
|
Schleifenschablone. Damit reduziert \problem{SAT} auf das Halteproblem, und das
|
|
Halteproblem ist NP-schwer.
|
|
|
|
\begin{aha}
|
|
Hier trennen sich die Begriffe sichtbar: Das Halteproblem ist NP-\emph{schwer},
|
|
aber mangels Entscheidbarkeit nicht in $\NP$ -- also nicht NP-\emph{vollständig}.
|
|
Die beiden Hälften der Vollständigkeit sind wirklich unabhängige Bedingungen,
|
|
und dieses Problem erfüllt nur eine davon.
|
|
\end{aha}
|
|
|
|
\subsection*{Wohin die Härte weiterfließt}
|
|
|
|
Nirgendwohin -- als unentscheidbares Problem ist das Halteproblem im Kurs die
|
|
Endstation.
|
|
|
|
% ##################################################################
|
|
\part*{Teil C -- Untere Schranken mit der ETH}
|
|
\addcontentsline{toc}{section}{\textbf{Teil C -- Untere Schranken mit der ETH}}
|
|
% ##################################################################
|
|
|
|
\noindent \glqq NP-vollständig\grqq{} bedeutet nur: vermutlich kein
|
|
Polynomialzeit-Algorithmus. Offen bleibt, \emph{wie langsam} es wirklich sein
|
|
muss -- $2^n$? $2^{\sqrt n}$? $n^{\log n}$? Die Exponentialzeit-Hypothese
|
|
verschärft die Annahme so weit, dass sich konkrete Untergrenzen ausrechnen
|
|
lassen.
|
|
|
|
% ==================================================================
|
|
\section{Das Handwerkszeug}
|
|
% ==================================================================
|
|
|
|
\subsection*{Echt langsamer wachsen: klein-o}
|
|
|
|
\begin{defn}{Klein-o-Notation}
|
|
$f(n) = o(g(n))$ bedeutet, dass der Quotient $f(n)/g(n)$ gegen null geht -- $f$
|
|
wird von $g$ auf lange Sicht beliebig weit abgehängt. Wichtig: Ein konstanter
|
|
Faktor rettet nichts, $\delta n$ ist \emph{nicht} $o(n)$.
|
|
\end{defn}
|
|
|
|
Ein Algorithmus mit Laufzeit $2^{o(n)}$ hat einen Exponenten, der langsamer als
|
|
jede Gerade wächst -- man nennt das \emph{subexponentiell}. $2^{\sqrt n}$ ist so
|
|
ein Fall: enorm schneller als $2^{n}$, aber immer noch weit von polynomiell
|
|
entfernt.
|
|
|
|
\subsection*{Die Hypothese selbst}
|
|
|
|
\begin{defn}{Exponentialzeit-Hypothese (ETH)}
|
|
Es existiert eine Konstante $\delta > 0$, sodass kein Algorithmus \problem{3-SAT}
|
|
mit $n$ Variablen in Zeit $2^{\delta n} \cdot \poly$ löst. Gleichwertig
|
|
formuliert: \problem{3-SAT} hat keinen $2^{o(n)}$-Algorithmus.
|
|
\end{defn}
|
|
|
|
Bewiesen ist die ETH nicht -- sie ist eine Arbeitshypothese, stärker als
|
|
$\Pclass \ne \NP$. Sie passt aber zum Forschungsstand: Trotz Jahrzehnten der
|
|
Suche liegen die besten 3-SAT-Löser bei $c^n$ mit $c$ knapp über $1{,}3$.
|
|
|
|
\subsection*{Von Variablen zu Klauseln: das Sparsification-Lemma}
|
|
|
|
\begin{satz}{Sparsification-Lemma}
|
|
Unter der ETH hat \problem{3-SAT} auch keinen Algorithmus mit Laufzeit
|
|
$2^{o(m)} \cdot \poly$, wobei $m$ die \emph{Klauselzahl} bezeichnet.
|
|
\end{satz}
|
|
|
|
\begin{intuition}
|
|
Wozu ein eigenes Lemma? Die ETH spricht von der \emph{Variablenzahl} $n$.
|
|
Reduktionen bemessen ihre Ausgabegröße aber meist an der \emph{Klauselzahl} $m$
|
|
-- und $m$ kann kubisch größer sein als $n$. Aus \glqq kein $2^{o(n)}$\grqq{}
|
|
folgt darum noch lange nicht \glqq kein $2^{o(m)}$\grqq. Das Lemma schließt
|
|
diese Lücke und macht die Klauselzahl zur gleichwertigen Härte-Währung. Als
|
|
Rückweg merkt man sich $n \le 3m$: Mehr Variablen als Literale kann es nicht
|
|
geben.
|
|
\end{intuition}
|
|
|
|
\subsection*{Das Argumentationsmuster}
|
|
|
|
\begin{idee}{Kontraposition mit Größenrechnung}
|
|
Jede ETH-Schranke folgt demselben Dreischritt.
|
|
\emph{Schritt 1:} Drücke die Zielgröße der Reduktion (Knotenzahl, Mengenzahl,
|
|
Parameter $k$, \dots) durch $n$ und $m$ aus.
|
|
\emph{Schritt 2:} Unterstelle einen zu schnellen Algorithmus für das
|
|
Zielproblem und rechne nach, welche 3-SAT-Laufzeit die Kette
|
|
\glqq Reduktion + Algorithmus\grqq{} ergäbe.
|
|
\emph{Schritt 3:} Stelle den Widerspruch fest -- zur ETH direkt, wenn die
|
|
Größe nur an $n$ hängt; zum Sparsification-Lemma, wenn sie an $m$ hängt.
|
|
\end{idee}
|
|
|
|
\begin{stolper}
|
|
Ob man das Sparsification-Lemma zitieren muss, entscheidet sich allein daran,
|
|
\emph{welche} Größe in Schritt 1 auftaucht. Nur $n$: die ETH genügt. Auch $m$
|
|
(oder $n + m$, was $O(m)$ ist): ohne das Lemma bricht der Schluss zusammen. Wer
|
|
es pauschal immer oder nie erwähnt, verliert Punkte.
|
|
\end{stolper}
|
|
|
|
Eine nützliche Ergänzung ist die \emph{Wurzel-Regel}: Wächst die Zielgröße
|
|
polynomiell, etwa $p = O(m^2)$, dann verbietet die Härte nur noch
|
|
$2^{o(\sqrt p)}$ -- allgemein $2^{o(\sqrt[c]{p})}$ bei $p = O(m^c)$. Denn erst
|
|
$\sqrt[c]{p}$ ist wieder von der Ordnung $m$.
|
|
|
|
% ==================================================================
|
|
\section{Die Schranken im Einzelnen}
|
|
% ==================================================================
|
|
|
|
Jetzt das Muster in Anwendung -- für jedes Problem gesondert.
|
|
|
|
\subsection*{Untere Schranke für Clique}
|
|
|
|
Die Reduktion von \problem{3-SAT} auf \problem{$k$-Clique} baut pro
|
|
Literalvorkommen einen Knoten: Bei höchstens drei Literalen je Klausel sind das
|
|
$|V| = O(m)$ Knoten, dazu $|E| = O(m^2)$ Kanten und die Zielgröße $k = m$.
|
|
Angenommen, \problem{Clique} hätte einen $2^{o(|V|)}$-Algorithmus. Wegen
|
|
$|V| = O(m)$ wäre die Kette aus Reduktion und Algorithmus ein
|
|
3-SAT-Verfahren mit Laufzeit $2^{o(m)} \cdot \poly$ -- das verbietet das
|
|
Sparsification-Lemma. Für die Kantenzahl greift die Wurzel-Regel: Aus
|
|
$|E| = O(m^2)$ folgt, dass kein $2^{o(\sqrt{|E|})}$-Algorithmus existiert. Und
|
|
da $k = m$ direkt die Klauselzahl ist, scheidet auch ein
|
|
$2^{o(k)}$-Algorithmus aus.
|
|
|
|
\subsection*{Untere Schranke für Independent Set}
|
|
|
|
Die Reduktion von \problem{Clique} auf \problem{Independent Set} ersetzt den
|
|
Graphen durch sein Komplement und behält $k$. Dabei bleibt die Knotenzahl
|
|
identisch, die Kantenzahl bleibt durch $O(|V|^2)$ beschränkt, und $k$ ändert
|
|
sich nicht. Ein $2^{o(|V|)}$-Algorithmus für \problem{Independent Set} wäre
|
|
darum -- nach Vorschalten der Komplementbildung -- ein
|
|
$2^{o(|V|)}$-Algorithmus für \problem{Clique}, den es nach dem vorigen
|
|
Abschnitt nicht gibt. Mit derselben Übertragung scheiden
|
|
$2^{o(\sqrt{|E|})}$- und $2^{o(k)}$-Algorithmen aus.
|
|
|
|
\subsection*{Untere Schranke für Vertex Cover}
|
|
|
|
Die Reduktion von \problem{Clique} auf \problem{Vertex Cover} nutzt ebenfalls
|
|
den Komplementgraphen, diesmal mit Schranke $k' = n - k$. Auch hier wächst
|
|
nichts: Knotenzahl gleich, Kantenzahl $O(|V|^2)$, und $k' \le |V|$. Ein zu
|
|
schneller VC-Algorithmus -- sei es in $|V|$, in $\sqrt{|E|}$ oder in $k'$ --
|
|
ließe sich also in einen gleich schnellen Clique-Algorithmus verwandeln, im
|
|
Widerspruch zur Clique-Schranke. \problem{Vertex Cover} hat somit dieselben
|
|
drei Untergrenzen.
|
|
|
|
\subsection*{Untere Schranken für Hitting Set}
|
|
|
|
Die Reduktion von \problem{3-SAT} liefert $|U| = 2n$ Elemente, $r = n + m$
|
|
Mengen und die Schranke $k = n$. Die drei Parameter verhalten sich
|
|
unterschiedlich -- genau deshalb ist dieses Problem das Lehrstück des Themas.
|
|
|
|
\emph{Erstens, die Universumsgröße.} Ein Algorithmus in $2^{o(|U|)}$ wäre wegen
|
|
$|U| = 2n$ einer in $2^{o(n)}$. Vorgeschaltet an die Reduktion entstünde ein
|
|
3-SAT-Löser in $2^{o(n)} \cdot \poly$ -- das widerspricht unmittelbar der ETH.
|
|
Das Sparsification-Lemma wird hier nicht angerührt, weil $m$ in der Rechnung
|
|
nirgends vorkommt.
|
|
|
|
\emph{Zweitens, die Mengenzahl.} Ein Algorithmus in $2^{o(r)}$ trifft auf
|
|
$r = n + m \le 3m + m = 4m$, ist also einer in $2^{o(m)}$. Die Kette ergäbe
|
|
einen 3-SAT-Löser in $2^{o(m)} \cdot \poly$ -- \emph{das} verbietet erst das
|
|
Sparsification-Lemma, denn die ETH allein sagt über $m$ nichts. Hier ist das
|
|
Zitat des Lemmas Pflicht.
|
|
|
|
\emph{Drittens, die Schranke $k$.} Ein Algorithmus in $2^{o(k)}$ ist wegen
|
|
$k = n$ einer in $2^{o(n)}$ -- derselbe unmittelbare ETH-Widerspruch wie beim
|
|
ersten Parameter, wieder ohne Lemma.
|
|
|
|
\subsection*{Untere Schranke für SubSet Sum und Partition}
|
|
|
|
Hier zahlt sich die strenge Dezimal-Reduktion aus dem Katalog aus: Sie erzeugt
|
|
aus einer 3-SAT-Formel nur $2n + 2m$ Zahlen, und mit $n \le 3m$ sind das
|
|
höchstens $8m = O(m)$ Stück. Hätte \problem{SubSet Sum} einen Algorithmus in
|
|
$2^{o(\#\text{Zahlen})}$, dann liefe die Kette in $2^{o(m)} \cdot \poly$ für
|
|
\problem{3-SAT} -- vom Sparsification-Lemma ausgeschlossen. \problem{SubSet Sum}
|
|
hat also keinen subexponentiellen Algorithmus in der Anzahl seiner Zahlen. Die
|
|
Reduktion auf \problem{Partition} fügt lediglich zwei weitere Zahlen hinzu und
|
|
verschiebt die Größenordnung nicht -- dieselbe Schranke gilt daher auch für
|
|
\problem{Partition}.
|
|
|
|
\subsection*{Untere Schranke für 3-Color}
|
|
|
|
Für das Färbungsproblem existiert eine eigens sparsame Konstruktion, die aus
|
|
einer 3-SAT-Formel einen Graphen mit nur $O(n + m)$ Knoten macht. Wegen
|
|
$n \le 3m$ ist das $O(m)$. Ein $2^{o(|V|)}$-Algorithmus für \problem{3-Color}
|
|
ergäbe darum einen $2^{o(m)}$-3-SAT-Löser -- Widerspruch zum
|
|
Sparsification-Lemma. Für die Kantenzahl ($O(m^2)$) schließt die Wurzel-Regel
|
|
zusätzlich jeden $2^{o(\sqrt{|E|})}$-Algorithmus aus.
|
|
|
|
\subsection*{Untere Schranke für Set Cover}
|
|
|
|
Der Seitenwechsel zwischen \problem{Hitting Set} und \problem{Set Cover}
|
|
vertauscht die Rollen der beiden Größen: Aus dem Universum wird die
|
|
Mengenliste und umgekehrt. Die Hitting-Set-Schranken wandern dadurch mit
|
|
vertauschten Parametern hinüber: \problem{Set Cover} hat weder in der
|
|
Universumsgröße noch in der Mengenzahl einen subexponentiellen Algorithmus --
|
|
bei der $m$-abhängigen Größe wieder mit dem Sparsification-Lemma als
|
|
Schlussstein.
|
|
|
|
% ##################################################################
|
|
\part*{Teil D -- Approximation}
|
|
\addcontentsline{toc}{section}{\textbf{Teil D -- Approximation}}
|
|
% ##################################################################
|
|
|
|
\noindent Wo exakte Lösungen (vermutlich) exponentiell teuer sind, verschiebt
|
|
man den Anspruch: schnell rechnen, dafür nur \emph{nahe} ans Optimum -- aber mit
|
|
beweisbarer Garantie, wie nahe. Für jeden Algorithmus dieses Teils steht hier
|
|
seine Garantie samt der Idee, warum sie hält.
|
|
|
|
% ==================================================================
|
|
\section{Was eine Güte-Garantie ist}
|
|
% ==================================================================
|
|
|
|
\begin{defn}{Multiplikative Güte}
|
|
Bezeichne $\OPT(I)$ den optimalen Wert der Instanz $I$. Ein Algorithmus $A$
|
|
\emph{garantiert die Güte} $\alpha$, wenn für jede Instanz gilt: beim
|
|
Minimieren $A(I) \le \alpha \cdot \OPT(I)$, beim Maximieren $\OPT(I) \le
|
|
\alpha \cdot A(I)$. \emph{Scharf} heißt die Garantie, wenn es Instanzen gibt,
|
|
die den Faktor beliebig genau ausreizen.
|
|
\end{defn}
|
|
|
|
\begin{intuition}
|
|
Eine Güte ist ein Versprechen über den \emph{schlechtesten} Fall. Güte 2 beim
|
|
Minimieren: Was auch immer kommt, meine Lösung kostet höchstens das Doppelte
|
|
des Bestmöglichen. Je näher an 1, desto besser das Versprechen.
|
|
\end{intuition}
|
|
|
|
Bei manchen Problemen kann man die Genauigkeit sogar frei wählen -- gegen
|
|
entsprechende Rechenzeit. Solche Familien von Algorithmen tragen je nach
|
|
Preis-Leistungs-Verhältnis einen von drei Namen; wir definieren sie
|
|
nacheinander.
|
|
|
|
\begin{defn}{PTAS}
|
|
Ein \emph{polynomielles Approximationsschema} ist eine Familie
|
|
$(A_\varepsilon)_{\varepsilon > 0}$ mit Güte $1 + \varepsilon$, deren Laufzeit
|
|
für jedes \emph{festgehaltene} $\varepsilon$ polynomiell in $n$ ist.
|
|
\end{defn}
|
|
|
|
Die Schwäche steckt im Kleingedruckten: $\varepsilon$ darf im Exponenten von
|
|
$n$ auftauchen. Eine Laufzeit wie $n^{1/\varepsilon}$ ist für jedes feste
|
|
$\varepsilon$ polynomiell -- aber schon bei $\varepsilon = 0{,}1$ steht dort
|
|
$n^{10}$.
|
|
|
|
\begin{defn}{EPTAS}
|
|
Ein \emph{effizientes} PTAS hat Laufzeiten der Form
|
|
$f(1/\varepsilon) \cdot \poly(n)$: Die Abhängigkeit von $\varepsilon$ ist aus
|
|
dem $n$-Exponenten herausgezogen und in einen eigenen Faktor verbannt.
|
|
\end{defn}
|
|
|
|
Der Faktor $f(1/\varepsilon)$ darf groß sein -- aber die Skalierung in der
|
|
Eingabegröße bleibt ein festes Polynom, egal wie genau man es haben will.
|
|
|
|
\begin{defn}{FPTAS}
|
|
Ein \emph{voll polynomielles} PTAS läuft polynomiell in $n$ \emph{und} in
|
|
$1/\varepsilon$ zugleich -- etwa in $O(n^3/\varepsilon)$. Mehr kann man von
|
|
einem Approximationsschema nicht verlangen.
|
|
\end{defn}
|
|
|
|
Dazu ein Nachbarbegriff, den man hier braucht: \emph{pseudopolynomiell} nennt
|
|
man Laufzeiten, die polynomiell in den \emph{Werten} der Eingabezahlen sind.
|
|
Wegen der Binärkodierung (Teil A) sind solche Werte exponentiell in der
|
|
Eingabe\emph{länge} -- pseudopolynomiell ist also gerade \emph{nicht}
|
|
polynomiell im strengen Sinn.
|
|
|
|
% ==================================================================
|
|
\section{TSP ohne Zusatzannahme: hoffnungslos}
|
|
% ==================================================================
|
|
|
|
\begin{satz}{Keine Güte fürs allgemeine TSP}
|
|
Gäbe es für das TSP mit beliebigen Distanzen einen Polynomialzeit-Algorithmus
|
|
mit irgendeiner festen Güte $\alpha$, dann wäre $\Pclass = \NP$.\\[0.3em]
|
|
\emph{Die Idee:} Man präpariert die HK-Reduktion mit einem Abgrund. Echte
|
|
Kanten kosten 1, fehlende aber nicht bloß $|V|+1$, sondern einen gigantischen
|
|
Betrag -- so groß, dass selbst das $\alpha$-Fache einer reinen Kanten-Tour
|
|
billiger bleibt als eine einzige Nicht-Kante. Ein $\alpha$-approximativer
|
|
Algorithmus müsste dann bei Graphen \emph{mit} Hamiltonkreis eine Tour
|
|
unterhalb des Abgrunds abliefern und bei Graphen \emph{ohne} zwangsläufig
|
|
darüber liegen -- an seiner Ausgabe ließe sich \problem{HK} exakt ablesen. Ein
|
|
NP-vollständiges Problem wäre in Polynomialzeit gelöst.
|
|
\end{satz}
|
|
|
|
Rettung bringt die \emph{Dreiecksungleichung} $d(i,j) \le d(i,k) + d(k,j)$ --
|
|
Umwege lohnen nie. Reale Distanzen erfüllen sie ohnehin. Unter dieser Annahme
|
|
(\glqq metrisches TSP\grqq) existieren gleich zwei gute Näherungsverfahren.
|
|
|
|
% ==================================================================
|
|
\section{$\Delta$TSP$_1$: Gerüst, Rundweg, Abkürzung}
|
|
% ==================================================================
|
|
|
|
\begin{idee}{Der Bauplan}
|
|
Drei Zutaten: Ein \emph{minimaler Spannbaum} verbindet alle Städte zum
|
|
kleinstmöglichen Preis. Das \emph{Verdoppeln} seiner Kanten macht jeden Grad
|
|
gerade, sodass ein \emph{Eulerkreis} existiert -- ein Rundweg über alle Kanten.
|
|
\emph{Abkürzen} verwandelt ihn in eine echte Tour, die jede Stadt nur einmal
|
|
anläuft.
|
|
\end{idee}
|
|
|
|
\noindent Wir verfolgen den Ablauf an einem festen Beispiel mit den Städten
|
|
$A, B, C, D, E$ und den Distanzen $d(A,E) = 1$, $d(B,C) = 1$, $d(A,C) = 2$,
|
|
$d(C,D) = 2$ (alle übrigen 2 oder 3).
|
|
|
|
\medskip
|
|
\noindent\textbf{Vorab -- die optimale Tour.} Zum späteren Vergleich: Die beste
|
|
Rundreise ist $[C,B,D,E,A,C]$ mit Länge 8. Der Algorithmus kennt sie nicht.
|
|
\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 $[C,B,D,E,A,C]$ -- Länge $8 = \OPT$}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
\noindent\textbf{Erster Schritt -- der Spannbaum.} Der billigste Baum durch
|
|
alle fünf Städte besteht aus $A$--$E$ (1), $B$--$C$ (1), $A$--$C$ (2) und
|
|
$C$--$D$ (2); er wiegt 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, Gewicht $6$}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
\begin{intuition}
|
|
Der Spannbaum ist der Anker der ganzen Analyse: Er kostet \emph{höchstens}
|
|
$\OPT$. Denn streicht man aus der optimalen Tour irgendeine Kante, entsteht ein
|
|
Gerüst, das alle Städte verbindet -- und der \emph{minimale} Spannbaum
|
|
unterbietet jedes solche Gerüst.
|
|
\end{intuition}
|
|
|
|
\noindent\textbf{Zweiter und dritter Schritt -- verdoppeln, Eulerkreis.} Jede
|
|
Baumkante wird zweifach gelegt; nun hat jede Stadt geraden Grad, und ein
|
|
Rundweg über sämtliche Kantenkopien existiert. Er wiegt $2 \cdot 6 = 12$, zum
|
|
Beispiel $[C,A,E,A,C,B,C,D,C]$ -- mit Wiederholungsbesuchen bei $A$ und $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.3pt}
|
|
\qbezier(0.5,2.2)(1.55,2.6)(2.6,3.0)\put(1.2,2.75){\small $\times2$}
|
|
\qbezier(0.5,0.3)(1.55,0.8)(2.6,1.3)\put(1.2,0.5){\small $\times2$}
|
|
\qbezier(0.5,2.2)(1.55,1.75)(2.6,1.3)\put(1.3,1.9){\small $\times2$}
|
|
\put(2.6,1.3){\line(1,0){2.0}}\put(3.4,1.4){\small $\times2$}
|
|
\put(-0.3,-0.2){\small verdoppelt: Gewicht $12$, alle Grade gerade}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
\noindent\textbf{Vierter Schritt -- abkürzen.} Beim Ablaufen des Eulerkreises
|
|
überspringt man jede schon besuchte Stadt und fliegt direkt zur nächsten neuen.
|
|
Aus $[C,A,E,A,C,B,C,D,C]$ wird so die Tour $[C,A,E,B,D,C]$ der Länge 10.
|
|
\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.3,-0.2){\small Tour $[C,A,E,B,D,C]$ -- Länge $10 \le 2 \cdot 8$}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
\begin{satz}{$\Delta$TSP$_1$ garantiert Güte 2}
|
|
Drei Ungleichungen tragen den Beweis. \emph{Erstens} wiegt der Spannbaum
|
|
höchstens $\OPT$ (Tour minus Kante ist ein Gerüst). \emph{Zweitens} wiegt der
|
|
Eulerkreis exakt das Doppelte des Baums, also höchstens $2\,\OPT$.
|
|
\emph{Drittens} macht Abkürzen nichts teurer -- die Dreiecksungleichung
|
|
garantiert, dass der Direktflug zur nächsten neuen Stadt nie länger ist als der
|
|
Umweg über besuchte. Zusammen: Tourlänge $\le 2\,\OPT$. Im Beispiel: 10 bei
|
|
Optimum 8, Garantie wäre 16.
|
|
\end{satz}
|
|
|
|
\begin{intuition}
|
|
Die Garantie ist im Wesentlichen scharf: Es gibt sternförmige Instanzen mit
|
|
Optimum $n$, auf denen das Verfahren $2n - 2$ produziert -- für großes $n$
|
|
beliebig nah am Faktor 2.
|
|
\end{intuition}
|
|
|
|
% ==================================================================
|
|
\section{Christofides: das Matching statt der Verdopplung}
|
|
% ==================================================================
|
|
|
|
Das Verdoppeln \emph{aller} Kanten ist Verschwendung -- schuld an ungeraden
|
|
Graden sind nur \emph{manche} Knoten. Christofides repariert gezielt.
|
|
|
|
\begin{idee}{Gezielt reparieren}
|
|
Nur die Knoten mit ungeradem Grad im Spannbaum stören den Eulerkreis. Ihre
|
|
Anzahl ist immer gerade -- man kann sie also paaren. Christofides verbindet sie
|
|
durch das \emph{billigste perfekte Matching} und erhält so gerade Grade zum
|
|
halben Preis.
|
|
\end{idee}
|
|
|
|
\noindent\textbf{Erster Schritt -- Spannbaum wie gehabt.} Kanten $A$--$E$,
|
|
$B$--$C$, $A$--$C$, $C$--$D$; Gewicht 6.
|
|
|
|
\noindent\textbf{Zweiter Schritt -- die Störer finden.} Grade im Baum: $A$ hat
|
|
2, alle übrigen 1 oder 3 -- ungerade sind $B, C, D, E$ (im Bild 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 markiert: ungerade Grade $\{B,C,D,E\}$}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
\noindent\textbf{Dritter Schritt -- die Störer paaren.} Unter den möglichen
|
|
Paarungen von $\{B,C,D,E\}$ ist $\{B$--$C,\ D$--$E\}$ mit Kosten $1 + 2 = 3$
|
|
die billigste. Diese zwei Matchingkanten (dünn) kommen zum Baum -- jetzt sind
|
|
alle Grade gerade.
|
|
\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.4,-0.2){\small Matching $\{B$--$C, D$--$E\}$, Kosten $3$}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
\noindent\textbf{Vierter Schritt -- Eulerkreis und Abkürzung.} Aus Baum plus
|
|
Matching entsteht ein Eulerkreis; abgekürzt ergibt er die Tour
|
|
$[C,B,A,E,D,C]$ der Länge 9 -- einen Schritt näher am Optimum 8 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.0,-0.2){\small Tour $[C,B,A,E,D,C]$ -- Länge $9$}
|
|
\end{picture}
|
|
\end{center}
|
|
|
|
\begin{satz}{Christofides garantiert Güte $1{,}5$}
|
|
Die Tour kostet Baum plus Matching, also höchstens $\OPT + d(M)$. Der Kern ist
|
|
die Schranke $d(M) \le \OPT/2$: Läuft man die \emph{optimale} Tour ab und
|
|
notiert nur die ungerad-gradigen Knoten in Besuchsreihenfolge, so zerfallen
|
|
deren Verbindungsstücke in \emph{zwei} perfekte Paarungen -- die
|
|
\glqq geraden\grqq{} und die \glqq ungeraden\grqq{} Abschnitte im Wechsel. Dank
|
|
Dreiecksungleichung kosten beide zusammen höchstens $\OPT$; die billigere also
|
|
höchstens $\OPT/2$. Das \emph{minimale} Matching unterbietet auch diese. Ergebnis:
|
|
Tour $\le \OPT + \OPT/2 = 1{,}5\,\OPT$. Auch diese Schranke wird von
|
|
Beispielfamilien asymptotisch erreicht.
|
|
\end{satz}
|
|
|
|
\begin{stolper}
|
|
Zwei beliebte Fehler: Das Matching wird über den \emph{ungerad-gradigen
|
|
Baumknoten} gebildet -- nicht über allen Knoten. Und ohne Dreiecksungleichung
|
|
platzt der Abkürzungsschritt, genau wie bei $\Delta$TSP$_1$.
|
|
\end{stolper}
|
|
|
|
% ==================================================================
|
|
\section{Knapsack, Stufe 1: der pure Greedy}
|
|
% ==================================================================
|
|
|
|
Beim Optimier-Rucksack will man mit Tragkraft $B$ möglichst viel Profit
|
|
einpacken. Der erste Versuch liegt nahe.
|
|
|
|
\begin{idee}{Greedy nach Profitdichte}
|
|
Bewerte jeden Gegenstand mit seiner \emph{Dichte} $p_i / w_i$ -- Profit pro
|
|
Kilo. Sortiere absteigend danach und packe der Reihe nach ein, was noch in den
|
|
Rucksack passt.
|
|
\end{idee}
|
|
|
|
\begin{satz}{Greedy allein hat keine Güte-Garantie}
|
|
Für jede noch so große Zahl $\alpha$ gibt es Instanzen, auf denen Greedy um mehr
|
|
als den Faktor $\alpha$ am Optimum vorbeipackt.\\[0.3em]
|
|
\emph{Das Gegenbeispiel:} Zwei Gegenstände bei Tragkraft $B$ -- ein Krümel mit
|
|
Gewicht 1 und Profit 1 (Dichte 1) und ein Brocken mit Gewicht $B$ und Profit
|
|
$B - 1$ (Dichte knapp unter 1). Greedy greift zuerst zum dichteren Krümel;
|
|
danach passt der Brocken nicht mehr. Ergebnis: Profit 1 statt $B - 1$. Mit
|
|
wachsendem $B$ wird das Verhältnis beliebig schlecht -- der Fehler ist, dass
|
|
Dichte nichts über \emph{absolute} Profite sagt.
|
|
\end{satz}
|
|
|
|
% ==================================================================
|
|
\section{Knapsack, Stufe 2: Modified Greedy}
|
|
% ==================================================================
|
|
|
|
\begin{idee}{Zwei Kandidaten statt einem}
|
|
Berechne \emph{beides}: die Greedy-Packung \emph{und} den besten
|
|
Einzelgegenstand. Gib das profitablere von beiden aus.
|
|
\end{idee}
|
|
|
|
\begin{satz}{Modified Greedy garantiert Güte 2}
|
|
Der Schlüssel ist die \emph{gebrochene} Variante des Rucksacks, bei der man
|
|
Gegenstände auch anteilig einpacken darf. Ihr Optimum $\OPT_f$ ist mindestens so
|
|
groß wie das echte $\OPT$, und es hat eine einfache Gestalt: Greedy-Reihenfolge,
|
|
bis das erste Stück -- das \emph{Split-Item} -- nur noch teilweise hineinpasst.
|
|
Daraus liest man ab:
|
|
\[
|
|
\OPT \;\le\; \OPT_f \;\le\; \text{Greedy-Profit} + p_{\text{Split}}
|
|
\;\le\; \text{Greedy-Profit} + p_{\max}
|
|
\;\le\; 2 \cdot \max\{\text{Greedy}, p_{\max}\}.
|
|
\]
|
|
Der rechte Ausdruck ist genau das Doppelte der Modified-Greedy-Ausgabe. Der
|
|
Algorithmus verliert also höchstens den Profit \emph{eines} Gegenstands -- und
|
|
den sichert der zweite Kandidat ab.
|
|
\end{satz}
|
|
|
|
% ==================================================================
|
|
\section{Knapsack, Stufe 3: Sahni-Schema}
|
|
% ==================================================================
|
|
|
|
\begin{idee}{Kleine Vorauswahl raten, Rest gierig}
|
|
Für einen Parameter $k$: Probiere \emph{jede} Teilmenge von höchstens $k$
|
|
Gegenständen als festen Grundstock durch, fülle den Rest der Tragkraft mit
|
|
Greedy und behalte die beste aller so entstandenen Packungen.
|
|
\end{idee}
|
|
|
|
\begin{satz}{Sahni ist ein PTAS}
|
|
Die Güte beträgt $1 + 1/k$ bei Laufzeit $O(n^{k+1})$. Mit $k = 2$ erreicht man
|
|
Faktor $3/2$, mit $k = 3$ Faktor $4/3$ -- beliebig nah an 1, wenn man $k$
|
|
wachsen lässt. Der Preis: $k$ wandert in den Exponenten der Laufzeit. Genau das
|
|
Profil eines PTAS. (Modified Greedy steckt als Spezialfall $k = 1$ mit drin.)
|
|
\end{satz}
|
|
|
|
% ==================================================================
|
|
\section{Knapsack, Stufe 4: das FPTAS}
|
|
% ==================================================================
|
|
|
|
\begin{idee}{Profite vergröbern, dann exakt rechnen}
|
|
Es gibt ein exaktes Rucksack-Verfahren per dynamischer Programmierung, dessen
|
|
Laufzeit von der \emph{Größe der Profitwerte} abhängt -- pseudopolynomiell.
|
|
Skaliert man alle Profite um einen Faktor $K$ herunter (mit Abrunden), werden
|
|
die Werte klein und das exakte Verfahren schnell. Die Abrundung kostet
|
|
Genauigkeit -- aber kontrollierbar wenig.
|
|
\end{idee}
|
|
|
|
\begin{satz}{Das Skalierungsverfahren ist ein FPTAS}
|
|
Zwei Abschätzungen steuern den Fehler. Nach unten: Die auf den vergröberten
|
|
Profiten optimale Packung verliert gegenüber $\OPT$ höchstens $K$ pro
|
|
Gegenstand -- durch das Abrunden -- also insgesamt höchstens $K n$. Nach oben:
|
|
Ihre echte Profitsumme ist mindestens so groß wie ihr vergröberter Wert mal
|
|
$K$. Wählt man $K$ proportional zu $\varepsilon \, p_{\max} / n$, dann ist der
|
|
Verlust $Kn$ höchstens ein $\varepsilon$-Anteil von $p_{\max} \le \OPT$ -- Güte
|
|
$1 + \varepsilon$. Die Laufzeit des exakten Verfahrens auf den kleinen Werten
|
|
beträgt $O(n^3/\varepsilon)$: polynomiell in $n$ \emph{und} $1/\varepsilon$,
|
|
also ein FPTAS.
|
|
\end{satz}
|
|
|
|
% ==================================================================
|
|
\section{Scheduling, Regel 1: List Scheduling}
|
|
% ==================================================================
|
|
|
|
\begin{idee}{Immer zur leersten Maschine}
|
|
Nimm die Jobs in gegebener Reihenfolge und lege jeden auf die Maschine, die
|
|
gerade am wenigsten zu tun hat.
|
|
\end{idee}
|
|
|
|
Das Gantt-Bild zeigt die Schwäche: drei Jobs $1, 1, 2$ auf zwei Maschinen.
|
|
\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{besser}:}
|
|
\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}
|
|
Die beiden Einsen blockieren beide Maschinen, die späte Zwei stapelt sich
|
|
obendrauf. Wer die Zwei zuerst platziert, erreicht Makespan 2.
|
|
|
|
\begin{satz}{List Scheduling garantiert $2 - \frac1m$ -- scharf}
|
|
Betrachte die am Ende vollste Maschine und den \emph{letzten} Job $J_k$, der
|
|
dort landete. Im Moment seiner Zuteilung war diese Maschine die
|
|
\emph{leerste} -- alle $m$ Maschinen trugen damals also mindestens
|
|
\glqq Endlast minus $p_k$\grqq. Summiert ergibt das
|
|
$\sum_i p_i \ge m(\mathrm{LS} - p_k) + p_k$. Nun die beiden
|
|
\emph{Universalschranken} jedes Schedules: Das Optimum ist mindestens die
|
|
Durchschnittslast $\frac1m \sum_i p_i$, und mindestens so groß wie jeder
|
|
einzelne Job, insbesondere $p_k$. Beides eingesetzt liefert
|
|
$\mathrm{LS} \le (2 - \frac1m)\,\OPT$. Die Schranke wird erreicht: $m(m-1)$
|
|
Einser-Jobs, gefolgt von einem Job der Länge $m$, treiben List Scheduling auf
|
|
$2m - 1$ bei Optimum $m$.
|
|
\end{satz}
|
|
|
|
% ==================================================================
|
|
\section{Scheduling, Regel 2: LPT}
|
|
% ==================================================================
|
|
|
|
\begin{idee}{Die Großen zuerst}
|
|
Sortiere die Jobs absteigend nach Laufzeit und wende dann List Scheduling an.
|
|
Die dicken Brocken kommen so aufs leere Feld; die kleinen füllen am Ende nur
|
|
noch Lücken.
|
|
\end{idee}
|
|
|
|
\begin{satz}{LPT garantiert $\frac43 - \frac1{3m}$ -- scharf}
|
|
Der Beweis arbeitet mit einem \emph{kleinsten Gegenbeispiel}: einer Instanz mit
|
|
minimaler Jobzahl, die die Schranke verletzt. Dort muss der zuletzt platzierte
|
|
-- wegen der Sortierung kleinste -- Job den Makespan setzen; andernfalls ließe
|
|
er sich streichen und ein kleineres Gegenbeispiel bliebe übrig. Aus der
|
|
verletzten Schranke errechnet man, dass dieser kleinste Job länger als
|
|
$\OPT/3$ dauert. Dann aber passt in den \emph{optimalen} Plan höchstens ein
|
|
Job-Duo pro Maschine -- drei Jobs über $\OPT/3$ sprengten sie. Pläne mit
|
|
höchstens zwei Jobs pro Maschine lassen sich nun durch schrittweises
|
|
\emph{Tauschen} umsortieren: Je zwei Jobs wechseln so die Maschinen, dass die
|
|
Anordnung der LPT-Reihenfolge angeglichen wird, wobei bei nur zwei Jobs pro
|
|
Maschine kein Tausch die vollste Maschine voller macht. Am Ende steht der
|
|
LPT-Plan mit Optimal-Makespan -- das Gegenbeispiel widerspricht sich selbst,
|
|
also existiert keines.
|
|
\end{satz}
|
|
|
|
% ==================================================================
|
|
\section{Parallel-Task-Scheduling: Jobs, die mehrere Maschinen brauchen}
|
|
% ==================================================================
|
|
|
|
Eine Verallgemeinerung des Schedulings, die in neueren Klausuren auftaucht:
|
|
Jobs können mehrere Maschinen \emph{gleichzeitig} belegen.
|
|
|
|
\begin{defn}{Parallel-Task-Scheduling}
|
|
Gegeben $n$ Jobs und $m$ Maschinen. Jeder Job $j$ hat eine Ausführungszeit
|
|
$p_j$ und belegt während dieser Zeit \emph{gleichzeitig} $q_j \in [m]$
|
|
Maschinen. Gesucht ist ein Schedule ohne Überlappungen auf derselben Maschine
|
|
mit minimalem Makespan.
|
|
\end{defn}
|
|
|
|
Auch hier arbeitet ListScheduling: Es nimmt die Jobs der Reihe nach und
|
|
platziert jeden zum \emph{frühestmöglichen} Zeitpunkt auf den $q_j$ am
|
|
wenigsten belasteten Maschinen.
|
|
|
|
\begin{bsp}{ListScheduling mit Maschinenbedarf}
|
|
$m = 3$; Jobs als $(p_j, q_j)$: $(1,1)$, $(1,3)$, $(2,2)$, $(3,1)$. Die
|
|
Maschinenlasten $C$ entwickeln sich so: Job 1 startet bei 0 auf einer Maschine
|
|
-- $C = (1,0,0)$. Job 2 braucht alle drei Maschinen; die höchste Last ist 1,
|
|
also läuft er in $[1,2]$ -- $C = (2,2,2)$. Job 3 belegt zwei Maschinen ab
|
|
Zeit 2, läuft in $[2,4]$ -- $C = (4,4,2)$. Job 4 nimmt die leerste Maschine ab
|
|
Zeit 2, läuft in $[2,5]$ -- $C = (5,4,4)$. Makespan: 5.
|
|
\end{bsp}
|
|
|
|
Für den Sonderfall $q_j = 1$ ist das genau das klassische ListScheduling mit
|
|
seiner Güte $2 - \frac1m$. Interessant wird es, wenn alle Maschinenbedarfe in
|
|
einem festen Band liegen.
|
|
|
|
\begin{satz}{Güte im Band $\frac{m}{k+1} < q_j \le \frac{m}{k}$}
|
|
Liegen alle Bedarfe in diesem Band (für ein festes $k \ge 2$), so gilt
|
|
$\mathrm{LS}(I) \le \mathrm{OPT}(I) + \bigl(1 - \frac1k\bigr) p_{\max}
|
|
\le \bigl(2 - \frac1k\bigr)\mathrm{OPT}(I)$.\\[0.3em]
|
|
\emph{Die Idee:} Betrachte einen Job $j$, der den Makespan bestimmt, mit
|
|
Startzeit $s$. Zu jedem Zeitpunkt vor $s$ waren weniger als $q_j \le \frac mk$
|
|
Maschinen frei -- sonst hätte ListScheduling den Job früher platziert. Also
|
|
waren mehr als $\frac{(k-1)m}{k}$ Maschinen belegt. Da jeder Job höchstens
|
|
$\frac mk$ Maschinen belegt, liefen mindestens $k$ Jobs; da jeder \emph{mehr}
|
|
als $\frac{m}{k+1}$ belegt, passen keine $k+1$ nebeneinander -- es liefen also
|
|
stets \emph{genau} $k$ Jobs. Das ergibt $k \cdot s \le \sum_i p_i - p_j$. Im
|
|
Optimum laufen ebenfalls höchstens $k$ Jobs parallel, also
|
|
$\sum_i p_i \le k \cdot \mathrm{OPT}$. Zusammen folgt
|
|
$s \le \mathrm{OPT} - \frac1k p_j$ und damit
|
|
$\mathrm{LS} = s + p_j \le \mathrm{OPT} + (1 - \frac1k) p_j$.
|
|
\end{satz}
|
|
|
|
\begin{intuition}
|
|
Der wichtigste Spezialfall ist $k = 2$, also $\frac m3 < q_j \le \frac m2$:
|
|
Vor dem Start des entscheidenden Jobs laufen immer genau zwei Jobs, und es
|
|
folgt $\mathrm{LS} \le \mathrm{OPT} + \frac12 p_{\max}$. Das Argument ist eine
|
|
direkte Verallgemeinerung der beiden Universalschranken des klassischen
|
|
ListScheduling -- nur zählt man hier die \emph{parallel laufenden Jobs} statt
|
|
der Maschinen.
|
|
\end{intuition}
|
|
|
|
% ==================================================================
|
|
\section{Strip Packing: der NFDH-Algorithmus}
|
|
% ==================================================================
|
|
|
|
Ein Packungsproblem mit demselben Approximations-Geist: Rechtecke in einen
|
|
Streifen packen.
|
|
|
|
\begin{defn}{Strip Packing}
|
|
Gegeben eine Folge von Rechtecken $r_1, \dots, r_n$ mit Breiten
|
|
$w(r_i) \le 1$ und Höhen $h(r_i)$, absteigend nach Höhe sortiert
|
|
($h(r_i) \ge h(r_{i+1})$), sowie ein Streifen der Breite 1 mit unbeschränkter
|
|
Höhe. Gesucht ist eine überlappungsfreie Packung mit minimaler Gesamthöhe.
|
|
\end{defn}
|
|
|
|
\begin{idee}{NFDH (Next Fit Decreasing Height)}
|
|
NFDH packt \emph{stufenweise}: Die Rechtecke werden der Reihe nach
|
|
links-bündig auf die aktuelle Stufe gelegt. Passt eines nicht mehr in die
|
|
Breite, wird eine neue Stufe eröffnet -- auf Höhe des \emph{ersten} Rechtecks
|
|
der alten Stufe (das wegen der Sortierung das höchste ist).
|
|
\end{idee}
|
|
|
|
\begin{bsp}{NFDH gegen die optimale Packung}
|
|
Fünf Rechtecke der Höhe 1 mit Breiten $\frac12, \frac14, \frac12, \frac14,
|
|
\frac12$. NFDH links: Stufe 1 fasst $\frac12 + \frac14$; das nächste
|
|
$\frac12$ passt nicht mehr -- Stufe 2 mit $\frac12 + \frac14$; das letzte
|
|
$\frac12$ eröffnet Stufe 3. Höhe 3. Optimal rechts: $\frac12 + \frac12$ und
|
|
$\frac12 + \frac14 + \frac14$ -- Höhe 2.
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{center}
|
|
\begin{picture}(11,3.6)(-0.4,-0.5)
|
|
% NFDH links (Streifenbreite 4cm = Breite 1)
|
|
\put(0.8,3.25){\small NFDH: Höhe 3}
|
|
\put(0,0){\framebox(2,1){\small $\frac12$}}\put(2,0){\framebox(1,1){\small $\frac14$}}
|
|
\put(0,1){\framebox(2,1){\small $\frac12$}}\put(2,1){\framebox(1,1){\small $\frac14$}}
|
|
\put(0,2){\framebox(2,1){\small $\frac12$}}
|
|
\put(0,-0.15){\line(1,0){4}}\put(4,-0.15){\line(0,1){3.3}}\put(0,-0.15){\line(0,1){3.3}}
|
|
% OPT rechts
|
|
\put(7.0,2.25){\small Optimal: Höhe 2}
|
|
\put(6.2,0){\framebox(2,1){\small $\frac12$}}\put(8.2,0){\framebox(2,1){\small $\frac12$}}
|
|
\put(6.2,1){\framebox(2,1){\small $\frac12$}}\put(8.2,1){\framebox(1,1){\small $\frac14$}}\put(9.2,1){\framebox(1,1){\small $\frac14$}}
|
|
\put(6.2,-0.15){\line(1,0){4}}\put(10.2,-0.15){\line(0,1){2.3}}\put(6.2,-0.15){\line(0,1){2.3}}
|
|
\end{picture}
|
|
\end{center}
|
|
Die Rate beträgt hier $\frac32$.
|
|
\end{bsp}
|
|
|
|
\begin{intuition}
|
|
\textbf{Der schlimmste Fall} treibt die Rate gegen 2: Nimm $2t$ Rechtecke der
|
|
Höhe 1 mit Breiten abwechselnd $1$ und $\varepsilon$. Bei NFDH füllt jedes
|
|
Breite-1-Rechteck seine Stufe komplett; jedes $\varepsilon$-Rechteck eröffnet
|
|
eine neue Stufe, auf die das nächste Breite-1-Rechteck nicht mehr passt --
|
|
$2t$ Stufen. Optimal packt man alle $\varepsilon$-Rechtecke zusammen auf eine
|
|
einzige Stufe: Höhe $t + 1$. Die Rate $\frac{2t}{t+1}$ geht gegen 2.
|
|
\end{intuition}
|
|
|
|
\begin{satz}{NFDH garantiert $2 \cdot \mathrm{OPT} + 1$ (für Höhen 1)}
|
|
Seien $W_1, \dots, W_S$ die belegten Breiten der NFDH-Stufen; die Packungshöhe
|
|
ist $S$.\\[0.3em]
|
|
\emph{Die Idee:} Für benachbarte Stufen gilt $W_i + W_{i+1} > 1$ -- denn das
|
|
erste Rechteck der Stufe $i+1$ passte nicht mehr auf Stufe $i$, und seine
|
|
Breite steckt in $W_{i+1}$. Summiert man diese Ungleichungen über
|
|
$i = 1, \dots, S-1$, steht links höchstens $2 \sum_i W_i$ und rechts $S - 1$:
|
|
\[
|
|
2 \sum_i W_i \;>\; S - 1 .
|
|
\]
|
|
Die Gesamtfläche der Rechtecke ist $\sum_i W_i$ (alle Höhen 1), und sie muss
|
|
in jede Packung der Breite 1 hineinpassen: $\mathrm{OPT} \ge \sum_i W_i$.
|
|
Also $2\,\mathrm{OPT} > S - 1$, das heißt
|
|
$\mathrm{NFDH} = S \le 2\,\mathrm{OPT} + 1$.
|
|
\end{satz}
|
|
|
|
\begin{intuition}
|
|
Für gemischte Höhen $h(r_i) \le 1$ bleibt die Schranke bestehen. Die Idee:
|
|
Die Stufenhöhen $H_1 \ge H_2 \ge \dots$ sind die Höhen der jeweils ersten
|
|
Rechtecke, und jedes Rechteck der Stufe $i$ ist mindestens $H_{i+1}$ hoch --
|
|
die Fläche der Stufe $i$ ist also mindestens $W_i \cdot H_{i+1}$. Zusammen mit
|
|
$W_i + W_{i+1} > 1$ ergibt sich $\sum_{i \ge 2} H_i \le 2 \cdot \text{Fläche}
|
|
\le 2\,\mathrm{OPT}$, und die erste Stufe steuert höchstens $H_1 \le 1$ bei:
|
|
wieder $\mathrm{NFDH} \le 2\,\mathrm{OPT} + 1$.
|
|
\end{intuition}
|
|
|
|
% ==================================================================
|
|
\section{MAX-3-SAT: zwei Versuche reichen für Güte 2}
|
|
% ==================================================================
|
|
|
|
\begin{idee}{Alles an, alles aus}
|
|
Gesucht ist eine Belegung, die möglichst viele Klauseln erfüllt. Der
|
|
Algorithmus testet nur zwei Kandidaten: die Belegung, die alle Variablen auf
|
|
wahr setzt, und die, die alle auf falsch setzt. Die bessere gewinnt.
|
|
\end{idee}
|
|
|
|
\begin{satz}{Der Zwei-Versuche-Algorithmus hat Güte 2}
|
|
Jede Klausel enthält mindestens ein Literal. Ein positives Literal wird von der
|
|
Alles-wahr-Belegung erfüllt, ein negatives von der Alles-falsch-Belegung --
|
|
folglich erfüllt \emph{jede} Klausel mindestens einen der beiden Kandidaten.
|
|
Zählt man zusammen, erfüllen beide Kandidaten gemeinsam mindestens $m$
|
|
Klauseln; der bessere allein also mindestens $m/2$. Mehr als $m$ kann auch das
|
|
Optimum nicht erfüllen, also liefert der Algorithmus mindestens die Hälfte des
|
|
Optimums. Scharf ist das auch: Ein Klauselpaar, von dem eines nur positive und
|
|
eines nur negative Literale enthält, ist gemeinsam erfüllbar ($\OPT = 2$),
|
|
aber jeder der beiden Kandidaten schafft nur eine der Klauseln.
|
|
\end{satz}
|
|
|
|
% ==================================================================
|
|
\section{Vertex Cover: die Beide-Endpunkte-Regel}
|
|
% ==================================================================
|
|
|
|
\begin{idee}{Kante schnappen, beide Enden nehmen}
|
|
Solange noch eine unbedeckte Kante existiert: Nimm \emph{beide} Endpunkte in
|
|
die Lösung und streiche alle dadurch bedeckten Kanten. Wiederhole.
|
|
\end{idee}
|
|
|
|
\begin{satz}{Die Regel garantiert Güte 2}
|
|
Nenne $A$ die Menge der geschnappten Kanten; die Ausgabe hat $2|A|$ Knoten.
|
|
Zwei geschnappte Kanten können keinen Endpunkt teilen -- sonst wäre die später
|
|
geschnappte beim Schnappen der früheren schon bedeckt gewesen. $A$ ist also ein
|
|
\emph{Matching}: lauter knotenfremde Kanten. Jedes Vertex Cover -- auch das
|
|
optimale -- muss jede dieser $|A|$ Kanten mit einem \emph{jeweils eigenen}
|
|
Knoten bedecken, braucht also mindestens $|A|$ Knoten. Die Ausgabe mit $2|A|$
|
|
Knoten ist demnach höchstens doppelt so groß wie das Optimum.
|
|
\end{satz}
|
|
|
|
\begin{intuition}
|
|
Damit sind alle drei Grundmuster der Güte-Beweise versammelt: das Optimum von
|
|
unten durch eine \emph{Struktur} abschätzen (hier: das Matching), ein
|
|
\emph{Zählargument} über komplementäre Kandidaten (MAX-3-SAT), und die
|
|
\emph{Universalschranken} Durchschnittslast und Maximaljob (Scheduling). Fast
|
|
jeder Güte-Beweis des Kurses ist eine Variation eines dieser drei.
|
|
\end{intuition}
|
|
|
|
% ==================================================================
|
|
\section{Schlusswort}
|
|
% ==================================================================
|
|
|
|
Damit liegt das ganze Fundament vor dir. Du kennst für jedes Problem des Kurses
|
|
die Definition, den NP-Nachweis, die Herkunft seiner Härte und ihre
|
|
Weitergabe. Du kannst untere Schranken aus der ETH herleiten und weißt bei
|
|
jedem Parameter, ob das Sparsification-Lemma gebraucht wird. Und du kennst die
|
|
Approximationsalgorithmen samt der Ideen hinter ihren Garantien.
|
|
|
|
\begin{aha}
|
|
Wenn du ein einziges Bild mitnimmst, dann dieses: Alles hängt an der
|
|
\emph{Reduktion}. Sie trägt die Härte von \problem{SAT} durch die gesamte
|
|
Landkarte, sie macht aus der ETH konkrete Zahlen, und ihr Scheitern beim
|
|
allgemeinen TSP zeigt, wo nicht einmal Näherung hilft. Wer Reduktionen lesen
|
|
und bauen kann, hat den Kurs verstanden.
|
|
\end{aha}
|
|
|
|
\noindent\textbf{Und jetzt?} Verständnis wird durch Anwendung zu Können. Nimm
|
|
dir die Präsenz-, Haus- und Klausuraufgaben vor und führe selbst aus, was hier
|
|
als Idee steht -- Reduktionen mit beiden Richtungen, Schranken-Herleitungen,
|
|
Worst-Case-Konstruktionen. Viel Erfolg dabei.
|
|
|
|
\end{document}
|