2673 lines
104 KiB
TeX
2673 lines
104 KiB
TeX
\documentclass[11pt,a4paper]{report}
|
|
\usepackage[utf8]{inputenc}
|
|
\usepackage[T1]{fontenc}
|
|
\usepackage[ngerman]{babel}
|
|
\usepackage{amsmath,amssymb,amsthm,mathtools}
|
|
\usepackage{tikz}
|
|
\usetikzlibrary{positioning,calc}
|
|
\usepackage[margin=2.5cm]{geometry}
|
|
\usepackage{alltt}
|
|
\usepackage{array}
|
|
|
|
% =====================================================================
|
|
% 1:1-Transkription der Kapitel 6 und 7 des Vorlesungsskripts
|
|
% "Einführung in die Komplexitätstheorie" / "Approximative Algorithmen"
|
|
%
|
|
% Hinweis: Text, Formeln, Sätze und Beweise sind vollständig übernommen.
|
|
% Die Abbildungen sind in TikZ nachgebaut; sehr komplexe Abbildungen
|
|
% (Hamiltonkreis-Komponenten, 3-dim-Matching-Rad etc.) sind als
|
|
% kommentierte Platzhalter markiert.
|
|
% =====================================================================
|
|
|
|
% Gemeinsamer Zähler für alle Umgebungen wie im Original
|
|
\theoremstyle{plain}
|
|
\newtheorem{satz}{Satz}[chapter]
|
|
\newtheorem{lemma}[satz]{Lemma}
|
|
\newtheorem{korollar}[satz]{Korollar}
|
|
\theoremstyle{definition}
|
|
\newtheorem{definition}[satz]{Definition}
|
|
\newtheorem{beispiel}[satz]{Beispiel}
|
|
\newtheorem{uebung}[satz]{\"Ubung}
|
|
\theoremstyle{remark}
|
|
\newtheorem{bemerkung}[satz]{Bemerkung}
|
|
|
|
\newcommand{\OPT}{\mathrm{OPT}}
|
|
\newcommand{\true}{\mathit{true}}
|
|
\newcommand{\false}{\mathit{false}}
|
|
\newcommand{\NP}{\mathrm{NP}}
|
|
\newcommand{\PP}{\mathrm{P}}
|
|
|
|
\newcommand{\abbtext}[1]{\fbox{\parbox{0.9\textwidth}{\small\emph{Abbildung:} #1}}}
|
|
|
|
\begin{document}
|
|
|
|
\setcounter{chapter}{5}
|
|
\setcounter{page}{200}
|
|
|
|
\chapter{Einf\"uhrung in die Komplexit\"atstheorie}
|
|
|
|
In den vorherigen Kapiteln haben wir bereits einige theoretische Probleme
|
|
kennengelernt. Wir haben insbesondere gesehen, dass sich einige Probleme
|
|
schneller l\"osen (bzw.\ approximieren) lassen als andere. Au\ss erdem scheint
|
|
es Probleme zu geben, bei denen man schnell den Mut verliert, eine exakte
|
|
L\"osung in Polynomialzeit zu berechnen. Diese Probleme scheinen schwerer zu
|
|
sein als andere. Was ist die Schwere eines Problems? Die
|
|
Komplexit\"atstheorie befasst sich noch weitergehend mit der Frage nach der
|
|
Komplexit\"at von Problemen, d.h.\ man versucht zu klassifizieren wie schwer
|
|
Probleme sind.
|
|
|
|
In diesem Kapitel werden wir die Komplexit\"atsklassen $\PP$ und $\NP$
|
|
einf\"uhren und wollen dann die Begriffe der $\NP$-Schwere und
|
|
$\NP$-Vollst\"andigkeit verstehen. Im Anschluss werden wir einige Beispiele
|
|
$\NP$-vollst\"andiger Probleme studieren.
|
|
|
|
\section{Einleitung: Cliquenproblem}
|
|
|
|
Als erstes Beispiel betrachten wir das sogenannte Cliquenproblem auf Graphen.
|
|
Eine \emph{Clique} ist eine Teilmenge $C \subseteq V$, wobei
|
|
$\{u,v\} \in E$ f\"ur alle $u,v \in C$ mit $u \neq v$. Das Cliquenproblem
|
|
k\"onnen wir nun wie folgt angeben:
|
|
|
|
\begin{description}
|
|
\item[Gegeben:] Ein ungerichteter Graph $G=(V,E)$ und eine Zahl $k \geq 1$.
|
|
\item[Entscheide:] Hat der Graph $G$ eine Clique $C \subseteq V$ mit
|
|
mindestens $k$ Knoten (d.h.\ mit $|C| \geq k$)?
|
|
\end{description}
|
|
|
|
Dies ist ein sogenanntes \emph{Entscheidungsproblem}, welches also als
|
|
Antwort Ja oder Nein gibt.
|
|
|
|
\begin{beispiel}
|
|
Man betrachte den folgenden Graphen $G=(V,E)$ mit $V=\{1,2,3,4,5\}$ und
|
|
$E=\{\{1,2\},\{1,3\},\{2,3\},\{3,4\},\{3,5\}\}$:
|
|
|
|
\begin{center}
|
|
\abbtext{Graph mit den Knoten $1,\dots,5$: die Knoten $1,2,3$ bilden ein Dreieck; die Knoten $4$ und $5$ h\"angen jeweils nur an Knoten $3$.}
|
|
\end{center}
|
|
|
|
Hier ist $C=\{1,2,3\}$ eine Clique der Gr\"o\ss e 3, aber $C=\{2,3,4\}$ ist
|
|
keine Clique.
|
|
\end{beispiel}
|
|
|
|
Offensichtlich l\"ost der folgende Algorithmus das Problem exakt:
|
|
|
|
\begin{quote}
|
|
\textbf{Algorithmus:}\\
|
|
Teste f\"ur alle $V' \subseteq V$ mit $|V'| = k$, ob $V'$ eine Clique bildet.
|
|
\end{quote}
|
|
|
|
Wir bezeichnen mit $T(G,k)$ seine Laufzeit f\"ur eine Eingabe $(G,k)$.
|
|
|
|
\begin{lemma}
|
|
Der obige Algorithmus hat im schlimmsten Fall mindestens exponentielle
|
|
Laufzeit; d.h.\ $T(G,k) \geq 2^{|V|/2}$ f\"ur $k = |V|/2$.
|
|
\end{lemma}
|
|
|
|
\begin{proof}
|
|
F\"ur $|V| = n$, $k = n/2$ und $n$ gerade: Der Test f\"ur jedes $V'$
|
|
erfordert $\Omega(k^2)$ Schritte. Es gibt $\binom{n}{k}$ viele
|
|
$k$-elementige Teilmengen. Dann erhalten wir hier mit
|
|
\[
|
|
\binom{n}{n/2} = \frac{n(n-1)\cdots(n/2+1)}{n/2\,(n/2-1)\cdots 1} \geq 2^{n/2}
|
|
\]
|
|
mindestens eine exponentielle Laufzeit.
|
|
\end{proof}
|
|
|
|
\textbf{Frage:} Gibt es schnellere (bzw.\ insbesondere polynomielle)
|
|
Algorithmen?
|
|
|
|
\begin{definition}\leavevmode
|
|
\begin{enumerate}
|
|
\item[(i)] Ein \emph{Alphabet} $\Sigma$ ist eine endliche Menge an
|
|
Symbolen. $\Sigma^{*}$ ist die Menge aller endlichen W\"orter \"uber
|
|
$\Sigma$.
|
|
\item[(ii)] F\"ur jedes $x \in \Sigma^{*}$ bezeichne $|x|$ die L\"ange von
|
|
$x$.
|
|
\end{enumerate}
|
|
\end{definition}
|
|
|
|
\begin{bemerkung}
|
|
Jeder Algorithmus arbeitet auf einem Alphabet (d.h.\ seine Eingaben und
|
|
Ausgaben sind Elemente aus $\Sigma^{*}$). F\"ur einen Algorithmus $A$
|
|
bezeichnet $A(x)$ die Ausgabe zur Eingabe $x \in \Sigma^{*}$.
|
|
|
|
Die Laufzeit eines Algorithmus $A$ zur Eingabe $x$ (gegeben durch die Anzahl
|
|
der ausgef\"uhrten Operationen) wird durch $T_A(x)$ bezeichnet. Die
|
|
Worst-Case-Laufzeit zu Eingaben der Gr\"o\ss e $n$ ist
|
|
\[
|
|
T_A(n) = \max\{T_A(x) \mid x \in \Sigma^{*}, |x| = n\}.
|
|
\]
|
|
\end{bemerkung}
|
|
|
|
\begin{definition}\leavevmode
|
|
\begin{enumerate}
|
|
\item[(i)] Eine Teilmenge $L \subseteq \Sigma^{*}$ hei\ss t
|
|
\emph{Sprache}.
|
|
\item[(ii)] Ein \emph{Entscheidungsproblem} ist ein Tripel $(L,U,\Sigma)$,
|
|
wobei $L,U$ Sprachen sind und $L \subseteq U$.
|
|
\item[(iii)] Ein Algorithmus $A$ \emph{l\"ost} das Entscheidungsproblem
|
|
$(L,U,\Sigma)$ (oder auch $A$ \emph{entscheidet} die Sprache $L$
|
|
bez\"uglich $U$), wenn f\"ur alle $x \in U$ gilt:
|
|
\begin{itemize}
|
|
\item $x \in L$ impliziert $A(x) = 1$,
|
|
\item $x \notin L$ impliziert $A(x) = 0$.
|
|
\end{itemize}
|
|
\end{enumerate}
|
|
\end{definition}
|
|
|
|
H\"aufig ist $U = \Sigma^{*}$. Dann sagt man, dass $A$ die Sprache
|
|
$L \subseteq \Sigma^{*}$ entscheidet. Das Cliquenproblem etwa k\"onnen wir
|
|
als Sprache (Menge von W\"ortern) wie folgt darstellen:
|
|
\begin{align*}
|
|
\mathrm{CLIQUE} = \{\, u\#v \mid\ & u \in \{0,1\}^{*} \text{ stellt Adjazenzmatrix von } G \text{ dar},\\
|
|
& v \in \{0,1\}^{*} \text{ stellt } k \text{ dar},\\
|
|
& G \text{ hat Clique mit } k \text{ Knoten} \,\}.
|
|
\end{align*}
|
|
Hierbei ist $\Sigma^{*} = \{0,1\}^{*}$ die Menge aller endlichen W\"orter
|
|
(inklusive dem leeren Wort $\epsilon$) \"uber dem Alphabet
|
|
$\Sigma = \{0,1\}$.
|
|
|
|
\begin{bemerkung}
|
|
$u$ ist ein Wort der L\"ange $O(|V|^2)$, $v$ ist ein Wort der L\"ange
|
|
$O(\log |V|)$.
|
|
\end{bemerkung}
|
|
|
|
\section{Komplexit\"atsklassen P, NP}
|
|
|
|
\begin{definition}
|
|
Die Menge aller polynomiell entscheidbaren Sprachen bzw.\
|
|
Entscheidungsprobleme wird mit $\PP$ bezeichnet:
|
|
\[
|
|
\PP = \{L \subseteq \Sigma^{*} \mid \text{es existiert ein Algorithmus } A,
|
|
\text{ der } L \text{ in Laufzeit } T_A(n) = O(n^d) \text{ mit } d = O(1)
|
|
\text{ entscheidet}\}.
|
|
\]
|
|
\end{definition}
|
|
|
|
Neben $\PP$ gibt es unter anderem auch die Klasse $\NP$. Diese wird h\"aufig
|
|
\"uber \emph{nicht-deterministische Algorithmen} eingef\"uhrt (bei denen es
|
|
zu jeder Eingabe eine endliche Menge von Rechenwegen gibt).
|
|
|
|
\begin{definition}
|
|
Ein nicht-deterministischer Algorithmus entscheidet eine Sprache $L$,
|
|
\begin{itemize}
|
|
\item wenn es f\"ur jedes Wort $w \in L$ mindestens einen Rechenweg gibt,
|
|
der $w$ akzeptiert,
|
|
\item wenn jeder akzeptierende Rechenweg in polynomieller Zeit l\"auft und
|
|
\item wenn f\"ur jedes Wort $w \notin L$ jeder Rechenweg $w$ ablehnt.
|
|
\end{itemize}
|
|
Die Anzahl der Rechenwege kann dabei exponentiell von der Eingabe
|
|
abh\"angen.
|
|
\end{definition}
|
|
|
|
Die Klasse $\NP$ ist nun genau die Menge aller Sprachen, die durch einen
|
|
nicht-deterministischen Algorithmus in Polynomialzeit entschieden werden
|
|
k\"onnen. Wir bedienen uns hier allerdings einer alternativen Definition der
|
|
Klasse $\NP$ \"uber \emph{polynomielle Verifizierer}. Die so definierten
|
|
Klassen von Problemen sind aber gleich.
|
|
|
|
\begin{definition}
|
|
Es sei $L \subseteq \Sigma^{*}$. Ein (deterministischer) Algorithmus, der
|
|
auf $\Sigma^{*} \times \Sigma^{*}$ arbeitet, hei\ss t ein
|
|
\emph{Verifizierer} f\"ur $L$, wenn
|
|
\[
|
|
L = \{x \in \Sigma^{*} \mid \exists c \in \Sigma^{*} \text{ mit } A(x,c)=1\}.
|
|
\]
|
|
Hierbei nennt man ein Wort $c$ mit $A(x,c)=1$ ein \emph{Zertifikat} f\"ur
|
|
$x$ (bzw.\ f\"ur die Aussage $x \in L$).
|
|
\end{definition}
|
|
|
|
\begin{definition}
|
|
Ein Algorithmus $A$ ist ein \emph{polynomieller Verifizierer} f\"ur eine
|
|
Sprache $L$, wenn eine Konstante $d$ existiert, so dass es f\"ur jedes
|
|
$x \in L$ ein Zertifikat $c$ gibt mit $T_A(x,c) = O(|x|^d)$.
|
|
\end{definition}
|
|
|
|
\begin{definition}
|
|
Die Klasse aller polynomiell verifizierbaren Sprachen wird mit $\NP$
|
|
bezeichnet; d.h.
|
|
\[
|
|
\NP = \{L \subseteq \Sigma^{*} \mid \text{es existiert ein polynomieller
|
|
Verifizierer f\"ur } L\}.
|
|
\]
|
|
\end{definition}
|
|
|
|
\begin{satz}
|
|
Es gilt $\PP \subseteq \NP$.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
Zu einem Entscheidungsproblem $L$ aus $\PP$ gibt es einen Algorithmus $A$,
|
|
der $L$ entscheidet. Diesen Algorithmus kann man als Verifizierer auffassen,
|
|
der die zweite Eingabe $c$ einfach ignoriert. Damit ist $L$ auch in $\NP$.
|
|
\end{proof}
|
|
|
|
Nun k\"onnen wir auf das Cliquenproblem zur\"uckkommen und die folgende
|
|
Aussage beweisen.
|
|
|
|
\begin{lemma}\label{lem:clique-np}
|
|
Das Entscheidungsproblem $k$-\textsc{Clique} ist in $\NP$.
|
|
\end{lemma}
|
|
|
|
\begin{proof}
|
|
Durch Angabe eines polynomiellen Verifizierers f\"ur $k$-\textsc{Clique}.
|
|
Der Algorithmus bekommt neben der Eingabe (einen Graph $G=(V,E)$ und eine
|
|
Zahl $k$) ein Zertifikat (u.z.\ eine Teilmenge $C \subseteq V$). Der
|
|
Algorithmus testet dann, ob $C$ eine Clique der Gr\"o\ss e $\geq k$ ist.
|
|
Der Test geht wie folgt:
|
|
\begin{enumerate}
|
|
\item[(1)] pr\"ufe f\"ur alle zweielementigen Teilmengen
|
|
$\{u,v\} \subseteq C$, ob $\{u,v\} \in E$ liegt.
|
|
\item[(2)] gebe Ausgabe Ja aus, wenn jeder Test in (1) positiv ausfiel und
|
|
$|C| \geq k$ ist. Ansonsten Ausgabe Nein.
|
|
\end{enumerate}
|
|
Schritt (1) geht in Zeit $O(|C|^2) = O(|V|^2)$ und die
|
|
Kardinalit\"atspr\"ufung in (2) in $O(|C|) = O(|V|)$ Zeit. Da die
|
|
Eingabel\"ange $\Omega(|V| + |E|)$ ist, ist die Laufzeit des Algorithmus
|
|
polynomiell.
|
|
\end{proof}
|
|
|
|
Nachdem wir nun gesehen haben, wie die Klassen $\PP$ und $\NP$ definiert
|
|
haben, k\"onnen wir den Begriff der Schwere genauer beleuchten. Daf\"ur ist
|
|
es notwendig zu verstehen, wann ein Problem auf ein anderes Problem
|
|
reduziert werden kann. Wir ben\"otigen die folgende Definition.
|
|
|
|
\begin{definition}
|
|
Es seien $L_1 \subseteq \Sigma_1^{*}$, $L_2 \subseteq \Sigma_2^{*}$ zwei
|
|
Sprachen.
|
|
\begin{enumerate}
|
|
\item[(i)] Eine Funktion $f\colon \Sigma_1^{*} \to \Sigma_2^{*}$ mit der
|
|
Eigenschaft
|
|
\[
|
|
w \in L_1 \Leftrightarrow f(w) \in L_2 \quad \forall w \in \Sigma_1^{*}
|
|
\]
|
|
hei\ss t \emph{Transformation} von $L_1$ auf $L_2$.
|
|
\item[(ii)] Eine solche Transformation hei\ss t \emph{polynomielle
|
|
Transformation}, wenn es ein Polynom $p$ und einen Algorithmus $A$ gibt,
|
|
der f\"ur alle $w \in \Sigma_1^{*}$ die Ausgabe $f(w)$ der L\"ange
|
|
$\leq p(|w|)$ in (polynomieller) Zeit $T_A(w) \leq p(|w|)$ berechnet.
|
|
\end{enumerate}
|
|
Dann hei\ss t $L_1$ \emph{polynomiell reduzierbar} auf $L_2$. Als Notation
|
|
verwenden wir $L_1 \leq L_2$.
|
|
\end{definition}
|
|
|
|
Endlich k\"onnen wir den Begriff der $\NP$-Schwere bzw.\
|
|
$\NP$-Vollst\"andigkeit formal fassen:
|
|
|
|
\begin{definition}\leavevmode
|
|
\begin{enumerate}
|
|
\item[(i)] Eine Sprache $L_0$ hei\ss t \emph{$\NP$-schwer}, g.d.w.\
|
|
$\forall L \in \NP: L \leq L_0$.
|
|
\item[(ii)] Eine Sprache $L_0$ hei\ss t \emph{$\NP$-vollst\"andig},
|
|
g.d.w.\ $L_0 \in \NP$ und $\forall L \in \NP$ gilt: $L \leq L_0$.
|
|
\end{enumerate}
|
|
\end{definition}
|
|
|
|
Eine fundamentale Eigenschaft der $\NP$-Vollst\"andigkeit ist die folgende:
|
|
|
|
\begin{satz}\label{satz:pnp}
|
|
Es sei $L_0$ $\NP$-vollst\"andig. Dann gilt $\PP = \NP$, g.d.w.\
|
|
$L_0 \in \PP$.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
$\Rightarrow$: Es sei $\PP = \NP$. Zeige dann, dass $L_0 \in \PP$.
|
|
|
|
$L_0$ ist $\NP$-vollst\"andig. Dann gilt insbesondere $L_0 \in \NP$. Wegen
|
|
$\PP = \NP$ gilt dann $L_0 \in \PP$.
|
|
|
|
$\Leftarrow$: Es sei $L_0 \in \PP$. Zeige hier, dass $\PP = \NP$.
|
|
|
|
Da $L_0 \in \PP$ ist, gibt es einen Algorithmus $A_0$, der $L_0$ in
|
|
Polynomzeit $T_0$ entscheidet. Es sei nun $L \in \NP$ beliebig gew\"ahlt.
|
|
Zeige: $L \in \PP$.
|
|
|
|
Da $L_0$ $\NP$-vollst\"andig ist und $L \in \NP$, gilt $L \leq L_0$. Sei
|
|
also $A_f$ ein Algorithmus, der die polynomielle Transformation $f$ von $L$
|
|
auf $L_0$ in Polynomzeit $T_f$ berechnet mit
|
|
$u \in L \Leftrightarrow f(u) \in L_0$.
|
|
|
|
Wir konstruieren $A$ aus $A_0$ und $A_f$ durch Hintereinanderschalten;
|
|
siehe folgendes Bild:
|
|
|
|
\begin{center}
|
|
\abbtext{Blockdiagramm: Die Eingabe $u$ l\"auft in den Block $A_f$ (Zeit $T_f(|u|)$), dessen Ausgabe $f(u)$ in den Block $A_0$ (Zeit $T_0(|f(u)|)$); $A_0$ antwortet mit ja oder nein.}
|
|
\end{center}
|
|
|
|
Dann akzeptiert $A$ ein Wort $u$, g.d.w.\ $A_0$ das Wort $f(u)$ akzeptiert.
|
|
Dies ist \"aquivalent zu $f(u) \in L_0$ bzw.\ $u \in L$. D.h.\ Algorithmus
|
|
$A$ entscheidet $L$ mit Gesamtlaufzeit
|
|
$\leq T_f(|u|) + T_0(|f(u)|) \leq T(|u|)$ f\"ur ein Polynom $T$. Hierbei
|
|
verwende, dass $|f(u)| \leq \mathrm{poly}(|u|)$ und dass die Komposition von
|
|
Polynomen wieder ein Polynom ergibt.
|
|
\end{proof}
|
|
|
|
\textbf{Konsequenz von Satz \ref{satz:pnp}:} Wenn ein $\NP$-vollst\"andiges
|
|
Entscheidungsproblem in $\PP$ liegt, dann sind alle
|
|
$\NP$-Entscheidungsprobleme in $\PP$.
|
|
|
|
Die gleiche Aussage gilt auch f\"ur ein $\NP$-schweres Problem.
|
|
|
|
\begin{center}
|
|
\textbf{Offenes Problem der Komplexit\"atstheorie:}\\[2pt]
|
|
Gilt $\PP = \NP$ oder $\PP \neq \NP$?
|
|
\end{center}
|
|
|
|
Dies ist eines der wichtigsten offenen Probleme der Informatik. Es wurde vom
|
|
Clay Mathematics Institute in die Liste der Millennium-Probleme
|
|
aufgenommen; mit einem Preisgeld von 1~Million Dollar:
|
|
\texttt{www.claymath.org}.
|
|
|
|
\begin{bemerkung}\label{bem:transitiv}
|
|
Wenn $L_1 \leq L_2$ und $L_2 \leq L_3$, dann gilt auch $L_1 \leq L_3$.
|
|
\end{bemerkung}
|
|
|
|
\begin{proof}
|
|
siehe \"Ubung.
|
|
\end{proof}
|
|
|
|
\begin{korollar}\label{kor:np-konstruktion}
|
|
Ist $L_0$ $\NP$-vollst\"andig, $L_0 \leq L_1$ und $L_1 \in \NP$, so ist auch
|
|
$L_1$ $\NP$-vollst\"andig.
|
|
\end{korollar}
|
|
|
|
\begin{proof}
|
|
Zeige die folgende Behauptung: $\forall L \in \NP$ gilt $L \leq L_1$.
|
|
|
|
Sei dazu $L \in \NP$ beliebig gew\"ahlt. Zeige dann die Aussage
|
|
$L \leq L_1$. Wegen der $\NP$-Vollst\"andigkeit von $L_0$ und da
|
|
$L \in \NP$ ist, gilt $L \leq L_0$. Nach Voraussetzung gilt zus\"atzlich
|
|
$L_0 \leq L_1$. Da die Relation $\leq$ transitiv ist (siehe Bemerkung
|
|
\ref{bem:transitiv}), gilt dann: $L \leq L_1$.
|
|
|
|
Da $L_1 \in \NP$ wegen der Voraussetzung, ist daher $L_1$ auch
|
|
$\NP$-vollst\"andig.
|
|
\end{proof}
|
|
|
|
Das obige Ergebnis in Korollar \ref{kor:np-konstruktion} erm\"oglicht uns,
|
|
$\NP$-vollst\"andige Probleme aus bekannten $\NP$-vollst\"andigen Problemen
|
|
zu konstruieren (bzw.\ deren $\NP$-Vollst\"andigkeit zu beweisen). F\"ur
|
|
diese Entscheidungsprobleme gibt es keine polynomiellen Algorithmen, au\ss er
|
|
$\PP = \NP$.
|
|
|
|
\section{Definition von P und NP per Turingmaschine}
|
|
|
|
Eine \emph{nicht-deterministische Turingmaschine} (NDTM) hat die Form:
|
|
\[
|
|
M = (Q, \Gamma, q_0, \delta, F).
|
|
\]
|
|
Hierbei beschreibt $Q$ die nicht-leere endliche Zustandsmenge, $\Gamma$ das
|
|
Arbeitsalphabet, wobei $\Gamma \supset \Sigma$ gilt (dabei ist $\Sigma$ das
|
|
Eingabealphabet). Die Zustandsmenge enth\"alt den Anfangszustand
|
|
$q_0 \in Q$ und die Endzustandsmenge $F \subset Q$. Zuletzt beschreibt
|
|
$\delta$ die \"Ubergangsfunktion:
|
|
\[
|
|
\delta\colon Q \times \Gamma \longrightarrow 2^{\,Q \times \Gamma \times \{-1,0,1\}}.
|
|
\]
|
|
Es gilt, dass $|\delta(q,a)| = 0,1,2,\dots$ sein kann, man also mehrere
|
|
m\"ogliche Folgezust\"ande haben kann.
|
|
|
|
\begin{center}
|
|
\abbtext{Bandskizze einer Turingmaschine: horizontales Band mit Inschrift $u\,a\,u'$; das Feld mit $a$ ist als Arbeitsfeld hervorgehoben, ein Pfeil vom Zustand $q$ zeigt darauf.}
|
|
\end{center}
|
|
|
|
Ein \"Ubergang $\delta(q,a) \to (q', a', -1/1/0)$ besagt: im Zustand $q$
|
|
mit $a$ auf dem Arbeitsfeld (AF) drucke $a'$ auf AF, bewege den
|
|
Schreiblesekopf (bzw.\ das AF) nach links, rechts oder bleibe stehen und
|
|
gehe danach in Zustand $q'$ \"uber.
|
|
|
|
Die m\"oglichen Berechnungen einer NDTM wird \"uber \emph{Konfigurationen}
|
|
(die die Bandinschrift plus den Zustand enthalten) beschrieben, wobei eine
|
|
Konfiguration $c$ wie folgt definiert ist:
|
|
\[
|
|
c \in \Gamma^{*} \times Q \times \Gamma \times \Gamma^{*}
|
|
\qquad u\, q\, a\, v,
|
|
\]
|
|
wobei $u$ und $v$ W\"orter sind, $q$ ein Zustand und $a$ der Buchstabe auf
|
|
dem AF ist.
|
|
|
|
F\"ur $u = u'b$, $v$ sei die \emph{Folgekonfiguration} von $uqav$ definiert
|
|
durch:
|
|
\[
|
|
\begin{array}{ll}
|
|
u'\,q'\,b\,a'\,v & \text{falls } \delta(q,a) = (a', 1, q')\\[2pt]
|
|
u'\,b\,a'\,q'\,v & \text{falls } \delta(q,a) = (a', -1, q')\\[2pt]
|
|
u'\,b\,q'\,a'\,v & \text{falls } \delta(q,a) = (a', 0, q')
|
|
\end{array}
|
|
\]
|
|
Als Notation verwenden wir $C \vdash C'$; dabei ist $C'$ die
|
|
Folgekonfiguration von $C$.
|
|
|
|
\textbf{Berechnung zu W\"ortern bzw.\ Eingaben:} Hierbei ist die
|
|
Startkonfiguration durch $q_0 \flat w$ gegeben, wobei $\flat$ ein
|
|
Sonderzeichen ,,Blank`` (bzw.\ ein Leerzeichen) darstellt mit
|
|
$\flat \in \Gamma \setminus \Sigma$. Eine Konfiguration $C$ nennt man
|
|
\emph{Stopkonfiguration}, falls keine Folgekonfiguration von $C$ existiert.
|
|
Eine Berechnung zu einer Eingabe $w \in \Sigma^{*}$ kann dann durch eine
|
|
Folge $C_0, \dots, C_k$ von Konfigurationen dargestellt werden, wobei $C_0$
|
|
die Startkonfiguration zu einer Eingabe $w$ ist, $C_i \vdash C_{i+1}$ f\"ur
|
|
alle $i < k$ gilt und $C_k$ eine Stopkonfiguration ist. Eine Berechnung
|
|
hei\ss t genau dann \emph{akzeptierend}, wenn der Zustand von $C_k$ in $F$
|
|
liegt.
|
|
|
|
Sei $L \subseteq \Sigma^{*}$ und $T\colon \mathbb{N} \to \mathbb{N}$. $M$
|
|
akzeptiert $L$ [in nicht deterministischer Zeit $T$] genau dann wenn
|
|
$\forall w \in \Sigma^{*}$: ($w \in L \iff \exists$ akzeptierende Berechnung
|
|
von $M$ zu $w$ [mit L\"ange $\leq T(|w|)$]).
|
|
|
|
Damit k\"onnen wir die Zugeh\"origkeit zu der Komplexit\"atsklasse $\NP$
|
|
nun definieren.
|
|
|
|
\begin{definition}
|
|
Eine Sprache $L \subset \Sigma^{*}$ ist in $\NP$ $\iff$ $\exists$ eine NDTM
|
|
$M$ \"uber Alphabet $\Gamma \supset \Sigma$ und ein Polynom $T$, so dass
|
|
gilt: $M$ akzeptiert $L$ in nicht deterministischer Zeit $T$.
|
|
\end{definition}
|
|
|
|
\textbf{Deterministische Turingmaschine (DTM)} \; Falls
|
|
$|\delta(q,a)| \leq 1$ $\forall (q,a) \in Q \times \Gamma$, es also
|
|
h\"ochstens einen g\"ultigen \"Ubergang aus jedem Zustand gibt, nennt man
|
|
eine Turingmaschine \emph{deterministisch}. Die Berechnung der DTM ist
|
|
analog zu NDTMs \"uber Konfigurationen definiert.
|
|
|
|
Eine DTM $M$ \emph{entscheidet} $L$ [in deterministischer Zeit $T$] genau
|
|
dann wenn f\"ur alle W\"orter $w \in \Sigma^{*}$ die Berechnung von $w$ mit
|
|
einer Stopkonfiguration endet [und L\"ange $\leq T(|w|)$ hat]. Dabei liegt
|
|
der Zustand der Stopkonfigurationen in $F$, genau dann wenn $w$ in $L$
|
|
liegt.
|
|
|
|
Die Zugeh\"origkeit zu der Komplexit\"atsklasse $\PP$ wird nun analog
|
|
definiert.
|
|
|
|
\begin{definition}
|
|
$L \subset \Sigma^{*} \in \PP$ $\iff$ $\exists$ eine DTM $M$ \"uber Alphabet
|
|
$\Gamma \supset \Sigma$ und ein Polynom $T$, so dass $M$ die Sprache $L$ in
|
|
Zeit $T$ entscheidet.
|
|
\end{definition}
|
|
|
|
Nun bleibt zu zeigen, dass beide gezeigten Definitionen der
|
|
Komplexit\"atsklasse $\NP$ \"aquivalent sind, sie also die gleiche Klasse
|
|
beschreiben.
|
|
|
|
\begin{satz}
|
|
Die Klassen der Sprachen bez\"uglich Verifizierer und NDTM sind
|
|
\"aquivalent und beschreiben beide die gleiche Klasse $\NP$.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
$"\supset"$: Sei $N$ eine NDTM, die eine Sprache $L$ in Zeit $n^c$ f\"ur
|
|
eine Konstante $c$ entscheidet. F\"ur jedes $x \in L$ gibt es eine Folge
|
|
nicht-deterministischer \"Uberg\"ange, so dass $N$ bei Eingabe $x$ einen
|
|
akzeptierenden Zustand $q_{\mathrm{acc}}$ erreicht. Diese Folge kann durch
|
|
einen String $u$ der L\"ange $n^c$ \"uber einem Alphabet $\sigma'$ mit
|
|
$O(1)$ vielen Buchstaben repr\"asentiert werden (hierbei h\"angt die
|
|
Kardinalit\"at von $\sigma'$ von der maximalen Anzahl von Verzweigungen
|
|
(d.h.\ $|\delta(q,a)|$) ab). Dann folgt direkt, dass es eine DTM $M$ gibt,
|
|
die bei Eingabe $\langle x,u \rangle$ genau dieselben Berechnungen
|
|
durchf\"uhrt, also die gleichen \"Uberg\"ange wie $N$ macht. F\"ur die
|
|
Eingabe $x \in L$ folgt also auch, dass $M$ einen akzeptierenden Zustand
|
|
erreichen muss. Dann ist $M$ also auch ein Verifizierer f\"ur $L$.
|
|
|
|
$"\subset"$: Sei $L \subseteq \Sigma^{*}$ gegeben und sei $M$ ein
|
|
Verifizierer f\"ur $L$. Sei $p\colon \mathbb{N} \to \mathbb{N}$ ein
|
|
Polynom, das die L\"ange der Zertifikate angibt. Sei $n^c$ die Laufzeit der
|
|
DTM $M$, wobei $c$ wieder eine Konstante ist. Eine NDTM $N$, die $w$ in
|
|
Polynomzeit entscheidet, kann bei Eingabe $x \in \Sigma^{*}$ wie folgt
|
|
vorgehen:
|
|
|
|
\emph{Phase (1):} Nutze nicht-deterministische Entscheidungen um einen
|
|
beliebigen String $u$ der L\"ange $\mathrm{poly}(|x|)$, also polynomiell in
|
|
$|x|$, auf ein Arbeitsband zu schreiben.
|
|
|
|
\emph{Phase (2):} Simuliere $M$ bei Eingabe $\langle x,u \rangle$. Dann
|
|
folgt direkt, dass $N$ in Polynomzeit entscheidet, da $M$ diese Eingabe in
|
|
Polynomzeit verifizieren kann.
|
|
\end{proof}
|
|
|
|
\section{Satisfiability Problem (SAT)}
|
|
|
|
Der Kanadier Stephen A.~Cook begr\"undete 1971 die Klasse der
|
|
$\NP$-vollst\"andigen Probleme in $\NP$, indem er zeigte, dass ein
|
|
$\NP$-vollst\"andiges Problem existiert. Dieses Problem ist das sogenannte
|
|
\emph{Satisfiability Problem} (SAT). Leonid Levin hatte einen
|
|
vergleichbaren Satz 1973 ver\"offentlicht.
|
|
|
|
\subsection*{Satisfiability Problem (SAT)}
|
|
|
|
Das Satisfiability Problem (SAT) formalisiert die Frage nach der
|
|
Erf\"ullbarkeit eines aussagenlogischen Ausdrucks. Aussagenlogische
|
|
Ausdr\"ucke sind zusammengesetzt aus Variablen und den elementaren
|
|
Operatoren/Junktoren $\wedge$ (und), $\vee$ (oder) und $\neg$ (nicht). Die
|
|
Variablen sind Boolesche Variablen und wir notieren sie als $x_i$, d.h.\
|
|
$x_0, x_1, x_{10}, x_{11}, \dots$ und so weiter. F\"ur jede Variable $x_i$
|
|
existieren zwei \emph{Literale}. Diese sind das positive Literal $x_i$ und
|
|
das negative Literal $\neg x_i$. Aus den Literalen setzt man mit dem
|
|
elementaren Operator $\vee$ (oder) sogenannte \emph{Klauseln} zusammen,
|
|
d.h.\ disjunktive Ausdr\"ucke der Form $(y_1 \vee \dots \vee y_k)$ mit
|
|
Literalen $y_1, \dots, y_k$.
|
|
|
|
Ein Ausdruck $\alpha = C_1 \wedge \dots \wedge C_m$ mit Klauseln
|
|
$C_1, \dots, C_m$ hei\ss t Ausdruck in \emph{Konjunktiver Normalform}
|
|
(KNF). Ein Ausdruck $\alpha$ hei\ss t \emph{erf\"ullbar}, g.d.w.\ eine
|
|
Belegung $\varphi$ der Variablen in $\alpha$ mit $\true$, $\false$
|
|
existiert, so dass $\alpha$ unter der Belegung $\varphi$ zu $\true$
|
|
ausgewertet wird (siehe Beispiel~\ref{bsp:sat}).
|
|
|
|
Nun k\"onnen wir das SAT-Problem als Sprache wie folgt angeben:
|
|
\[
|
|
\mathrm{SAT} = \{\alpha \mid \alpha \text{ Boolescher Ausdruck in KNF},\
|
|
\alpha \text{ erf\"ullbar}\}
|
|
\]
|
|
|
|
\begin{bemerkung}
|
|
$\mathrm{SAT} \subset \{x, 1, 0, \vee, \wedge, \neg, (, )\}^{*}$.
|
|
\end{bemerkung}
|
|
|
|
\begin{beispiel}\label{bsp:sat}
|
|
Betrachte $\alpha = (x_1 \vee x_{10}) \wedge (x_1 \vee \neg x_{10}) \wedge
|
|
(x_{10})$. Wir erhalten die folgende Wahrheitstabelle:
|
|
\begin{center}
|
|
\begin{tabular}{c c | c}
|
|
$x_1$ & $x_{10}$ & $\alpha$\\
|
|
\hline
|
|
$\false$ & $\false$ & $\false$\\
|
|
$\true$ & $\false$ & $\false$\\
|
|
$\false$ & $\true$ & $\false$\\
|
|
$\true$ & $\true$ & $\true$
|
|
\end{tabular}
|
|
\end{center}
|
|
Die Belegung $\psi(x_1) = \psi(x_{10}) = \true$ ist eine erf\"ullende
|
|
Belegung.
|
|
\end{beispiel}
|
|
|
|
\begin{satz}[Cook, 1971 / Levin, 1973]
|
|
$\mathrm{SAT}$ ist $\NP$-vollst\"andig.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
\textbf{$\mathrm{SAT} \in \NP$} \; Wir skizzieren dies f\"ur eine
|
|
entsprechende nichtdeterministische Turingmaschine mit den
|
|
Zwischenergebnissen auf dem Turingband in Abb.~\ref{abb:sat-np}. Salopp
|
|
gesagt ,,raten`` wir nichtdeterministisch eine Belegung der Variablen und
|
|
pr\"ufen dann, ob sie den Ausdruck erf\"ullt.
|
|
|
|
\begin{figure}[h]
|
|
\begin{center}
|
|
\begin{tabular}{c}
|
|
$\alpha$\\
|
|
(1) $\downarrow$ det.\\
|
|
$\alpha\#$Liste der auftretenden Variablen\\
|
|
(2) $\downarrow$ nichtdet.\\
|
|
$\alpha\#$Belegung der Variablen durch wahr/falsch:\\
|
|
$x_{101} \to T_{101}$ oder $F_{101}$.\\
|
|
(3) $\downarrow$ det.\\
|
|
$\alpha\#$Wert von $\alpha$\\
|
|
(4) $\downarrow$ det.\\
|
|
$F$, wenn $\alpha = $ wahr; dummy-Zustand, falls $\alpha = $ falsch.
|
|
\end{tabular}
|
|
\end{center}
|
|
\caption{$\mathrm{SAT} \in \NP$: Alle vier Schritte sind in polynomieller
|
|
Zeit ausf\"uhrbar.}\label{abb:sat-np}
|
|
\end{figure}
|
|
|
|
\textbf{$L \in \NP \Longrightarrow L \leq \mathrm{SAT}$} \; Sei $M$ eine
|
|
NDTM und akzeptiere $L$ in nichtdeterministischer Zeit $T$ (f\"ur ein
|
|
geeignetes Polynom $T$). Wir suchen eine Transformation $u \to \alpha_u$,
|
|
die polynomzeitberechenbar ist mit
|
|
$u \in L \iff \alpha_u \in \mathrm{SAT}$.
|
|
|
|
\emph{Idee:} $\alpha_u$ wird so beschrieben, dass $M$ f\"ur $u$ in genau
|
|
$T(u)$ Schritten eine akzeptierende Stoppkonfiguration erreicht. Sei also
|
|
\[
|
|
M = (Q, \Gamma, q_0, \delta, F),
|
|
\]
|
|
wobei $Q = \{q_0, \dots, q_s\}$, $F = \{q_r, \dots, q_s\}$,
|
|
$\Gamma = \{a_0, \dots, a_m\}$, $a_0 = \flat$. Ohne Einschr\"ankung der
|
|
Allgemeinheit gelte: Akzeptiert $M$ das Wort $u = a_{j_1} \dots a_{j_{|u|}}$
|
|
mit einer Berechnung der L\"ange h\"ochstens $T(|u|)$, so akzeptiere $M$
|
|
das Wort mit einer Berechnung der L\"ange genau gleich $T(|u|)$.
|
|
|
|
Wir stellen $\delta$ durch eine Folge von Zeilen (F\"unftupeln)
|
|
$z_1, \dots, z_\varrho$ der Form $q\,a\,q'\,a'\,\beta$ dar (f\"ur
|
|
$(q',a',\beta) \in \delta(q,a)$). O.B.d.A.\ betrachten wir nur
|
|
Turingmaschinen, die nicht links vom Feld 0 arbeiten. Der zu konstruierende
|
|
Ausdruck in KNF $\alpha$ enth\"alt Variablen, deren Bedeutung in
|
|
Tabelle~\ref{tab:sat-var} zusammengefasst ist.
|
|
|
|
\begin{table}[h]
|
|
\begin{center}
|
|
\begin{tabular}{l|l}
|
|
Variablen in $\alpha_k$ & Bedeutung (wahr, falls \dots)\\
|
|
\hline
|
|
$z_{tk}$ & nach $t$ Schritten wird Zustand $q_k$ erreicht\\
|
|
$s_{ti}$ & nach $t$ Schritten ist Feld Nr.\ $i$ das Arbeitsfeld\\
|
|
$b_{tl}$ & nach $t$ Schritten wird Zeile $z_l$ ausgef\"uhrt\\
|
|
$a_{tij}$ & nach $t$ Schritten steht auf Feld Nr.\ $i$ der Buchstabe $a_j$
|
|
\end{tabular}\\[4pt]
|
|
Hierbei ist $0 \leq t, i \leq T(|u|)$, $0 \leq k \leq S$,
|
|
$1 \leq l \leq \varrho$, $0 \leq j \leq m$.
|
|
\end{center}
|
|
\caption{Variablen in $\alpha_k$}\label{tab:sat-var}
|
|
\end{table}
|
|
|
|
Die Anzahl der Variablen ist nach oben durch $c \cdot T(|u|)^2$
|
|
beschr\"ankt, wobei $c$ eine von der Turingmaschine abh\"angige Konstante
|
|
ist.
|
|
|
|
Wir bauen nun einen Ausdruck $\alpha_u$ auf mit
|
|
\[
|
|
\alpha_u = \alpha_{\text{Anfang}} \wedge \alpha_{\text{Ende}} \wedge
|
|
\alpha_{\text{Eindeutig}} \wedge \alpha_{\text{\"Ubergang}}.
|
|
\]
|
|
Das Ziel ist, dass erf\"ullende Belegungen von $\alpha_u$ den
|
|
akzeptierenden Berechnungen in Zeit $T(|u|)$ von $M$ f\"ur
|
|
$u = a_{j_1} \dots a_{j_{|u|}}$ entsprechen sollen. Wir setzen
|
|
\begin{align*}
|
|
\alpha_{\text{Anfang}} &= z_{00} \wedge s_{00} \wedge a_{000} \wedge
|
|
a_{01j_1} \wedge a_{02j_2} \wedge \dots \wedge a_{0|u|j_{|u|}} \wedge
|
|
a_{0(|u|+1)0} \wedge \dots \wedge a_{0\,T(|u|)\,0}\\
|
|
\alpha_{\text{Ende}} &= z_{T(|u|)\,r} \vee \dots \vee z_{T(|u|)\,s}\\
|
|
\alpha_{\text{Eindeutig}} &= \bigwedge_{0 \leq t \leq T(|u|)}
|
|
\Big(\text{,,genau ein Zustand``} \wedge \text{,,genau ein Arbeitsfeld``}\\
|
|
&\qquad\qquad \wedge \text{,,f\"ur alle Felder } i = 0, \dots, T(|u|)
|
|
\text{ genau ein Buchstabe``}\Big)
|
|
\end{align*}
|
|
Den ersten Teil, ,,genau ein Zustand``, schreiben wir als
|
|
\[
|
|
(z_{t0} \vee \dots \vee z_{ts}) \wedge \bigwedge_{i \neq j}
|
|
\underbrace{\neg(z_{ti} \wedge z_{tj})}_{(\neg z_{ti} \vee \neg z_{tj})},
|
|
\]
|
|
die anderen Bedingungen analog. Wir setzen
|
|
\[
|
|
\alpha_{\text{\"Ubergang}} = \bigwedge_{0 \leq t \leq T(|u|)} \alpha_t,
|
|
\]
|
|
wobei $\alpha_t$ Folgendes modelliert:
|
|
\begin{itemize}
|
|
\item Buchstaben auf nicht-Arbeitsfeldern bleiben unver\"andert
|
|
\item Falls das Arbeitsfeld Nr.\ $i$ hat und die $l$.\ Zeile
|
|
$q_{k_l} a_{j_l} q_{\tilde{k}_l} a_{\tilde{j}_l} \beta_l$ ausgef\"uhrt
|
|
wird, gilt:
|
|
\begin{enumerate}
|
|
\item[a)] nach $t$ Schritten wird $q_{k_l}$ erreicht
|
|
\item[b)] nach $t$ Schritten steht auf Feld $i$ der Buchstabe
|
|
$a_{j_l}$
|
|
\item[c)] nach $t+1$ Schritten wird $q_{\tilde{k}_l}$ erreicht
|
|
\item[d)] nach $t+1$ Schritten steht auf Feld $i$ Buchstabe
|
|
$a_{\tilde{j}_l}$
|
|
\item[e)] nach $t+1$ Schritten hat das Arbeitsfeld die Nummer
|
|
$i + \beta_l$.
|
|
\end{enumerate}
|
|
\end{itemize}
|
|
Wir erhalten insgesamt:
|
|
\begin{align*}
|
|
\alpha_t = \bigwedge_{0 \leq i \leq T(|u|)} \Bigg(
|
|
& \bigwedge_{0 \leq j \leq m} \Big( ((\neg s_{ti}) \wedge a_{tij}) \to
|
|
a_{(t+1)ij} \Big)\\
|
|
\wedge & \bigwedge_{1 < l \leq \varrho} \Big( (s_{ti} \wedge b_{tl}) \to
|
|
(z_{tk_l} \wedge a_{tij_l} \wedge z_{(t+1)\tilde{k}_l} \wedge
|
|
a_{(t+1)i\tilde{j}_l} \wedge s_{(t+1)(i+\beta_l)}) \Big) \Bigg)
|
|
\end{align*}
|
|
Insgesamt kann man $\alpha_u = \alpha_{\text{Anfang}} \wedge
|
|
\alpha_{\text{Ende}} \wedge \alpha_{\text{Eindeutig}} \wedge
|
|
\alpha_{\text{\"Ubergang}}$ in KNF darstellen. Wir m\"ussen noch zeigen:
|
|
\begin{enumerate}
|
|
\item[a)] die Transformation $u \mapsto \alpha_u$ ist polynomiell, und
|
|
\item[b)] es existiert eine akzeptierende Berechnung von $M$ zu $u$ der
|
|
L\"ange $T(|u|)$ dann und nur dann, wenn $\alpha_u$ erf\"ullbar ist.
|
|
\end{enumerate}
|
|
|
|
\begin{enumerate}
|
|
\item[a)] Wir bestimmen die Anzahl bzw.\ H\"aufigkeit der Variablen in
|
|
$\alpha_u$:
|
|
\begin{itemize}
|
|
\item in $\alpha_{\text{Anfang}}$: $T(n) + 3$
|
|
\item in $\alpha_{\text{Ende}}$: $\leq s + 1 = |Q|$
|
|
\item in $\alpha_{\text{Eindeutig}}$:
|
|
$\leq (T(n)+1)\big[s + 1 + 2(s+1)^2 + (T(n)+1)^2 +
|
|
(T(n)+1)(m+1)^2 + (\varrho+1)^2\big] \leq c(T(n))^3$
|
|
\item in $\alpha_{\text{\"Ubergang}}$:
|
|
$(T(n)+1)^2 \big[(3(m+1)) + (15(\varrho+1))\big] \leq c'T(n)^2$
|
|
\item insgesamt: $\leq dT(n)^3$
|
|
\end{itemize}
|
|
(f\"ur geeignete, von $M$ abh\"angige Konstanten $c, c', d$). Die
|
|
L\"ange einer Variablen ist nach oben durch $\bar{c}\log T(n)$
|
|
beschr\"ankt (f\"ur geeignetes $\bar{c}$), also ist die L\"ange von
|
|
$\alpha_u$ durch $\bar{d}T(n)^3 \log T(n)$ beschr\"ankt, also
|
|
polynomiell in $n = |u|$.
|
|
\item[b)] $\Rightarrow$ \; Sei $C_0, \dots, C_{T(|u|)}$ eine
|
|
akzeptierende Berechnung. Dann liefert das eine Belegung der Variablen
|
|
von $\alpha_u$ so, dass $\alpha_u$ den Wert wahr erh\"alt, und zwar:
|
|
\begin{align*}
|
|
\mathrm{Wert}(z_{tk}) = \text{wahr} &\iff C_t \text{ hat Zustand } q_k\\
|
|
\mathrm{Wert}(s_{ti}) = \text{wahr} &\iff \text{in } C_t \text{ hat das
|
|
Arbeitsfeld die Nr.\ } i\\
|
|
&\ \ \vdots
|
|
\end{align*}
|
|
$\Leftarrow$ \; Betrachte eine erf\"ullende Belegung von $\alpha_u$.
|
|
Wegen $\alpha_{\text{Eindeutig}} = $ wahr existiert zu jedem Zeitpunkt
|
|
$t$ genau ein $k$ mit $z_{tk} = $ wahr. Bezeichne diese $k$ mit $k(t)$.
|
|
Analog definiere $i(t)$, $l(t)$, $j(t,i)$. F\"ur alle Zeitpunkte $t$
|
|
wird eine Konfiguration $C_t$ eindeutig definiert durch den Zustand
|
|
$q_{k(t)}$, Arbeitsfeld Nr.\ $i(t)$, Bandinschrift
|
|
$a_{j(t,0)}, \dots, a_{j(t,T(|u|))}$.
|
|
|
|
Wir zeigen nur noch: $C_0, \dots, C_{T(|u|)}$ ist eine akzeptierende
|
|
Berechnung. Wegen $\alpha_{\text{Anfang}} = $ wahr ist $C_0$ die
|
|
Startkonfiguration zu $u$. Wegen $\alpha_{\text{Ende}} = $ wahr ist
|
|
$C_{T(|u|)}$ eine akzeptierende Konfiguration. Wegen
|
|
$\alpha_{\text{\"Ubergang}} = $ wahr geschieht der \"Ubergang
|
|
$C_t \to C_{t+1}$ gem\"a\ss{} Zeile $z_{l(t)}$. Insgesamt erhalten wir
|
|
eine akzeptierende Berechnung von $M$ auf $u$. \qedhere
|
|
\end{enumerate}
|
|
\end{proof}
|
|
|
|
Im Folgenden werden wir nun einige $\NP$-vollst\"andige Probleme betrachten
|
|
und ihre Schwere insbesondere beweisen. Es zeigt sich etwa, dass SAT sogar
|
|
dann $\NP$-vollst\"andig bleibt, wenn man pro Klausel nur maximal 3 Literale
|
|
erlaubt. Dieses Problem nennen wir 3-SAT.
|
|
|
|
\section{SAT mit kleinen Klauseln (3-SAT)}
|
|
|
|
\[
|
|
\text{3-SAT} = \{\alpha \mid \alpha \text{ Boolescher Ausdruck in KNF mit}
|
|
\leq 3 \text{ Literalen pro Klausel},\ \alpha \text{ erf\"ullbar}\}.
|
|
\]
|
|
|
|
\begin{satz}
|
|
\emph{3-SAT} ist $\NP$-vollst\"andig.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
Es reicht zu zeigen: $\mathrm{SAT} \leq \text{3-SAT}$. Gesucht ist eine
|
|
polynomzeit-berechenbare Transformation $\varphi\colon \alpha \to
|
|
\bar{\alpha}$ mit
|
|
\[
|
|
\alpha \in \mathrm{SAT} \Leftrightarrow \bar{\alpha} \in \text{3-SAT}.
|
|
\]
|
|
|
|
\emph{Idee:} $y_1 \vee y_2 \vee y_3 \vee y_4$ ist erf\"ullbar, g.d.w.\
|
|
$(y_1 \vee y_2 \vee x) \wedge (\neg x \vee y_3 \vee y_4)$ ist erf\"ullbar.
|
|
Hierbei ist $x$ eine neue Hilfsvariable.
|
|
|
|
\emph{Begr\"undung:} $y_1 \vee \dots \vee y_4$ erf\"ullbar
|
|
$\Leftrightarrow$ $y_1 \vee y_2$ erf\"ullbar oder $y_3 \vee y_4$
|
|
erf\"ullbar $\Leftrightarrow$ $y_1 \vee y_2 \vee x$ erf\"ullbar und
|
|
$y_3 \vee y_4 \vee \neg x$ erf\"ullbar.
|
|
|
|
\emph{Allgemein:} $(y_1 \vee \dots \vee y_n)$ erf\"ullbar
|
|
$\Leftrightarrow$
|
|
$(y_1 \vee y_2 \vee x_1) \wedge (\neg x_1 \vee y_3 \vee x_2) \wedge \dots
|
|
\wedge (\neg x_{n-3} \vee y_{n-1} \vee y_n)$ erf\"ullbar.
|
|
|
|
$\Rightarrow$: Es sei $(y_1 \vee \dots \vee y_n)$ wahr. Sind
|
|
$(y_1 \vee y_2)$ oder $(y_{n-1} \vee y_n)$ wahr, so ist die rechte Seite
|
|
erf\"ullbar durch Wahl $x_1 = \dots = x_{n-3} = \false$ falls
|
|
$y_1 \vee y_2$ wahr ist (bzw.\ alle Hilfsvariablen gleich $\true$ falls
|
|
$y_{n-1} \vee y_n$ wahr ist). Andernfalls sei $y_i$ wahr f\"ur
|
|
$i \notin \{1, 2, n-1, n\}$. In diesem Fall setze
|
|
$x_1, \dots, x_{i-2} = \true$ und $x_{i-1}, \dots, x_{n-3} = \false$.
|
|
|
|
$\Leftarrow$: Es sei eine Belegung gegeben, die die rechte Seite erf\"ullt.
|
|
Falls alle $y_i = \false$ sind, k\"onnen nicht alle Disjunktionen $\true$
|
|
werden.
|
|
\[
|
|
(y_1 \vee y_2 \vee x_1) \wedge (\neg x_1 \vee y_3 \vee x_2) \wedge \dots
|
|
\wedge (\neg x_{n-3} \vee y_{n-1} \vee y_n).
|
|
\]
|
|
Wenn $y_1 \vee y_2$ falsch ist, so muss $x_1$ wahr sein. Dann ist
|
|
$\neg x_1 \vee y_3$ auch falsch und $x_2$ muss wahr sein. Am Ende ist dann
|
|
aber $\neg x_{n-3}$ und $y_{n-1} \vee y_n$ falsch und wir haben einen
|
|
Widerspruch.
|
|
|
|
Definiere $\alpha \to \bar{\alpha}$ entsprechend klauselweise. Dann gilt
|
|
$|\bar{\alpha}| \leq c|\alpha|$ mit $c = O(1)$ und
|
|
$\alpha \to \bar{\alpha}$ ist polynomzeit-berechenbar.
|
|
\end{proof}
|
|
|
|
Wir betrachten erneut das Cliquenproblem und analysieren dieses Mal also
|
|
auch die Schwere des Problems.
|
|
|
|
\section{Cliquenproblem ($k$-Clique)}
|
|
|
|
\begin{description}
|
|
\item[Gegeben:] Ein ungerichteter Graph $G=(V,E)$ und eine Zahl
|
|
$k \geq 1$. Eine Clique ist eine Teilmenge $C \subseteq V$ mit
|
|
$\{u,v\} \in E$ f\"ur alle $u,v \in C$ mit $u \neq v$.
|
|
\item[Entscheide:] Hat der gegebene Graph $G$ eine Clique
|
|
$C \subseteq V$ mit mindestens $k$ Knoten (d.h.\ mit $|C| \geq k$)?
|
|
\end{description}
|
|
|
|
\begin{satz}
|
|
Das Problem $k$-\textsc{Clique} ist $\NP$-vollst\"andig.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
(a) $k$-\textsc{Clique} $\in \NP$: siehe Lemma~\ref{lem:clique-np}.
|
|
(b) Zeige: $\mathrm{SAT} \leq k$-\textsc{Clique}.
|
|
|
|
Es sei $F$ ein Boolescher Ausdruck in KNF, wobei
|
|
$F = F_1 \wedge \dots \wedge F_m$ und
|
|
$F_i = (y_{i1} \vee \dots \vee y_{i\ell_i})$ eine Klausel mit $\ell_i$
|
|
Literalen ist. Konstruktion von $G = (V,E)$ (dies geht in poly.\ Zeit):
|
|
\begin{align*}
|
|
V &= \{[i,j] \mid 1 \leq i \leq m,\ 1 \leq j \leq \ell_i\}\\
|
|
E &= \{\{[i,j],[i',j']\} \mid i \neq i' \text{ und }
|
|
y_{ij} \neq \neg y_{i'j'}\}
|
|
\end{align*}
|
|
|
|
\emph{Behauptung:} $F$ ist erf\"ullbar $\Leftrightarrow$ $G$ enth\"alt
|
|
eine Clique mit $k = m$ Knoten.
|
|
|
|
\begin{beispiel}
|
|
Betrachte $(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)$; ist erf\"ullbar mit
|
|
$\psi(x_1) = \psi(x_3) = \true$ und $\psi(x_2) = \false$. Zur Konstruktion
|
|
von $G$ und Clique $C$ siehe folgendes Bild:
|
|
|
|
\begin{center}
|
|
\abbtext{Graph mit acht Knoten $[i,j]$ f\"ur die Literale der drei Klauseln: $[1,1],[1,2],[1,3]$ (links), $[2,1],[2,2]$ (oben), $[3,1],[3,2],[3,3]$ (rechts). Kanten verbinden genau die Knoten verschiedener Klauseln, deren Literale nicht komplement\"ar sind. Die Knoten $[1,1]$ ($x_1$), $[2,2]$ ($\neg x_2$) und $[3,1]$ ($x_1$) bilden eine 3-Clique.}
|
|
\end{center}
|
|
\end{beispiel}
|
|
|
|
$\Rightarrow$: Es sei $F$ erf\"ullbar. Dann existiert ein $\psi$ mit
|
|
$\psi(F) = \true$. F\"ur diese Belegung gilt $\psi(F_i) = \true$ f\"ur alle
|
|
$i = 1, \dots, m$. Dann $\exists\ \psi\ \forall\ i = 1, \dots, m\
|
|
\exists\ r_i \in \{1, \dots, \ell_i\}$ mit $\psi(y_{ir_i}) = \true$.
|
|
|
|
Setze nun $C = \{[i,r_i] \mid 1 \leq i \leq m\}$ und zeige, dass $C$ eine
|
|
$m$-Clique ist.
|
|
|
|
Falls $\{[i,r_i],[j,r_j]\} \notin E$ f\"ur ein Paar $i,j$ mit $i \neq j$,
|
|
dann muss (wegen der Definition von $E$) $y_{ir_i} = \neg y_{jr_j}$ sein.
|
|
Dagegen gilt aber $\psi(y_{ir_i}) = \psi(y_{jr_j}) = \true$; ein
|
|
Widerspruch. Also bildet $C$ eine Clique.
|
|
|
|
$\Leftarrow$: Es sei $C$ eine $m$-Clique in $G$. Da es keine Kante zwischen
|
|
Knoten mit gleicher erster Komponente gibt, gilt:
|
|
\[
|
|
C = \{[1,r_1],[2,r_2],\dots,[m,r_m]\}
|
|
\]
|
|
f\"ur gewisse $r_1, r_2, \dots, r_m$. Definiere eine Belegung $\psi$ mit
|
|
$\psi(y_{1r_1}) = \psi(y_{2r_2}) = \dots = \psi(y_{mr_m}) = \true$.
|
|
|
|
Dies geht widerspruchsfrei, da $y_{ir_i} \neq \neg y_{jr_j}$ f\"ur alle
|
|
$1 \leq i \neq j \leq m$. Daraus folgt, dass $\psi(F_i) = \true$ f\"ur alle
|
|
$1 \leq i \leq m$ und damit $\psi(F) = \true$ ist.
|
|
\end{proof}
|
|
|
|
Ein weiteres Problem auf Graphen ist das sogenannte F\"arbungsproblem. Eine
|
|
\emph{$k$-F\"arbung} eines ungerichteten Graphen $G = (V,E)$ ist eine
|
|
Abbildung $f\colon V \to \{1, \dots, k\}$ mit $f(i) \neq f(j)$ f\"ur alle
|
|
$\{i,j\} \in E$ mit $i \neq j$. Eine $k$-F\"arbung $f$ f\"arbt also die
|
|
Knoten des Graphen $G$ mit $k$ Farben so, dass Kanten nur zwischen
|
|
unterschiedlich gef\"arbten Knoten existieren.
|
|
|
|
\section{F\"arbungsproblem ($k$-Color)}
|
|
|
|
\begin{description}
|
|
\item[Gegeben:] Ein ungerichteter Graph $G=(V,E)$ und eine Zahl
|
|
$k \geq 1$.
|
|
\item[Entscheide:] Hat der gegebene Graph $G$ eine $k$-F\"arbung?
|
|
\end{description}
|
|
|
|
\begin{satz}
|
|
Das F\"arbungsproblem $k$-\textsc{Color} ist $\NP$-vollst\"andig.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
(a) $k$-\textsc{Color} $\in \NP$: W\"ahle als Zertifikat eine Abbildung
|
|
$f\colon V \to \{1, \dots, k\}$ und teste, ob $f$ eine $k$-F\"arbung ist.
|
|
Der Testschritt geht in Zeit $O(|V| + |E|)$.
|
|
|
|
(b) Zeige: 3-SAT $\leq$ $k$-\textsc{Color}. Es sei $F$ Boolescher Ausdruck
|
|
in KNF mit $F = F_1 \wedge \dots \wedge F_m$ und $F_i$ Klausel der L\"ange
|
|
$\leq 3$ und ohne Paare $x_j \vee \neg x_j$ in einer Klausel (diese
|
|
Klauseln k\"onnen eliminiert werden).
|
|
|
|
Konstruktion von $G = (V,E)$ mit $|V| = 3n + m + 1$:
|
|
\begin{align*}
|
|
V ={} & \{x_i, \bar{x}_i, v_i \mid 1 \leq i \leq n\} \cup
|
|
\{F_j \mid 1 \leq j \leq m\} \cup \{z\}.\\
|
|
E ={} & \{\{v_i, v_j\} \mid 1 \leq i \neq j \leq n\}\\
|
|
& \cup \{\{v_i, x_j\}, \{v_i, \bar{x}_j\} \mid 1 \leq i \neq j \leq n\}\\
|
|
& \cup \{\{x_i, \bar{x}_i\} \mid 1 \leq i \leq n\}\\
|
|
& \cup \{\{x_i, F_j\} \mid \text{falls } x_i \text{ kein Literal in }
|
|
F_j\}\\
|
|
& \cup \{\{\bar{x}_i, F_j\} \mid \text{falls } \neg x_i \text{ kein
|
|
Literal in } F_j\}\\
|
|
& \cup \{\{v_i, z\} \mid 1 \leq i \leq n\} \cup \{\{F_j, z\} \mid
|
|
1 \leq j \leq m\}.
|
|
\end{align*}
|
|
|
|
\begin{beispiel}
|
|
Konstruktion f\"ur $(x_1 \vee x_2) \wedge (\neg x_1 \vee x_3)$.
|
|
|
|
\begin{center}
|
|
\abbtext{Graph mit Knoten $z$ (oben), $v_1,v_2,v_3$ (untereinander eine Clique, jeder mit $z$ verbunden), Literalknoten $x_i$/$\neg x_i$ f\"ur $i=1,2,3$ (jedes Paar durch eine Kante verbunden) und Klauselknoten $F_1,F_2$ (jeweils mit $z$ verbunden). Jeder Knoten $v_i$ ist mit allen Literalknoten $x_j,\neg x_j$ f\"ur $j \neq i$ verbunden; jeder Klauselknoten $F_j$ ist mit genau den Literalen verbunden, die \emph{nicht} in $F_j$ vorkommen (hier: $F_1$ mit $\neg x_1, \neg x_2, x_3, \neg x_3$ und $F_2$ mit $x_1, x_2, \neg x_2, \neg x_3$).}
|
|
\end{center}
|
|
|
|
Dieser Graph ist 4-f\"arbbar und $\psi(x_1) = \psi(x_3) = \true$,
|
|
$\psi(x_2) = \false$ ist erf\"ullende Belegung.
|
|
\end{beispiel}
|
|
|
|
\emph{Behauptung:} $F$ ist erf\"ullbar $\Leftrightarrow$ $G$ kann mit
|
|
$n+1$ Farben gef\"arbt werden.
|
|
|
|
\emph{Vor\"uberlegung:} $\{v_1, \dots, v_n, z\}$ ist Clique. Daher brauchen
|
|
wir $n+1$ Farben um $v_1, \dots, v_n, z$ zu f\"arben. O.B.d.A.\ gilt
|
|
$f(v_i) = i$ und $f(z) = n+1$; ansonsten umf\"arben. Desweiteren gilt
|
|
$\forall j$: $x_j, \bar{x}_j$ sind mit jedem $v_i$ f\"ur $i \neq j$
|
|
verbunden. Dann folgt $f(x_j), f(\bar{x}_j) \in \{j, n+1\}$. Da
|
|
$\{x_j, \bar{x}_j\} \in E$ folgt $f(x_j) \neq f(\bar{x}_j)$.
|
|
|
|
D.h.\ einer der beiden Knoten wird mit Farbe $j$ und der andere mit $n+1$
|
|
gef\"arbt, falls eine $n+1$ F\"arbung existiert. Dies erzeugt die
|
|
Variablensetzung.
|
|
|
|
\emph{Beweis der Behauptung.} $\Rightarrow$: $F$ ist erf\"ullbar. Dann
|
|
existiert eine Belegung $\psi$, so dass $F_j$ ein Literal $y$ mit
|
|
$\psi(y) = \true$ enth\"alt. F\"arbe nun
|
|
\[
|
|
f(x_i) = \begin{cases} i & \text{falls } \psi(x_i) = \true\\
|
|
n+1 & \text{sonst}\end{cases}
|
|
\]
|
|
und $f(\bar{x}_i)$ entsprechend. Dann ist
|
|
$\{x_i, \bar{x}_i, v_i \mid 1 \leq i \leq n\} \cup \{z\}$ korrekt mit
|
|
$n+1$ Farben gef\"arbt. Weiter ist $F_j$ mit $x_i$ und $\bar{x}_i$
|
|
verbunden, falls $x_i$ bzw.\ $\neg x_i$ kein Literal in $F_j$ ist. F\"ur
|
|
ein Literal $y \in \{x_i, \neg x_i\}$ in $F_j$ gilt $\psi(y) = \true$ und
|
|
$\{y, F_j\} \notin E$. F\"arbe dann $f(F_j) = i$. Dies ergibt dann korrekte
|
|
F\"arbung.
|
|
|
|
$\Leftarrow$: Gegeben sei eine F\"arbung, die o.B.d.A.\ gegeben ist durch
|
|
$f(v_i) = i$ und $f(z) = n+1$. Dann sind $x_j, \bar{x}_j$ wie oben
|
|
beschrieben mit Farbe $j$ und $n+1$ gef\"arbt. Betrachte Variablenbelegung
|
|
\[
|
|
\psi(x_j) = \begin{cases} \true & \text{falls } x_j \text{ Farbe } j
|
|
\text{ hat}\\ \false & \text{sonst}\end{cases}
|
|
\]
|
|
und setze $\psi(\neg x_j) = \neg\psi(x_j)$. $F_j$ hat $\leq 3$ Literale.
|
|
Daher ist $F_j$ mit $\geq 2n-3$ Knoten aus
|
|
$\{x_i, \bar{x}_i \mid 1 \leq i \leq n\}$ (und mit $z$) verbunden.
|
|
|
|
\emph{Annahme:} $\psi(F_j) = \false$; d.h.\ alle drei Literale in $F_j$
|
|
sind nach Definition mit $n+1$ gef\"arbt. Desweiteren ist $F_j$ verbunden
|
|
mit Knoten aus $\{x_1, \bar{x}_1, \dots, x_n, \bar{x}_n\}$ und Farben
|
|
$1, \dots, n$ (wegen der Voraussetzung \"uber die Paare
|
|
$x_j \vee \neg x_j$) und mit $z$ und Farbe $f(z) = n+1$. Daraus folgt
|
|
$f(F_j) \notin \{1, \dots, n+1\}$ und wir erhalten einen Widerspruch (da
|
|
$f$ eine $n+1$ F\"arbung ist).
|
|
\end{proof}
|
|
|
|
\section{3-dimensionales Matching}
|
|
|
|
\begin{description}
|
|
\item[Gegeben:] Mengen $U, V, W$ mit $|U| = |V| = |W|$ und Teilmenge
|
|
$T \subseteq V \times W \times U$.
|
|
\item[Entscheide:] Gibt es eine Teilmenge $M \subseteq T$ mit
|
|
$|M| = |U|$ mit der Eigenschaft: F\"ur jede zwei unterschiedliche
|
|
$(v,w,u), (v',w',u') \in M$ gilt: $u \neq u'$, $v \neq v'$ und
|
|
$w \neq w'$?
|
|
\end{description}
|
|
|
|
\begin{satz}
|
|
Das 3-dimensionale Matchingproblem (3-dim.\ Matching) ist
|
|
$\NP$-vollst\"andig.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
(a) 3-dim.\ Matching ist in $\NP$. W\"ahle als Zertifikat eine
|
|
entsprechende Teilmenge $M \subseteq T$ und teste die obigen Bedingungen.
|
|
|
|
(b) $\mathrm{SAT} \leq$ 3-dim.\ Matching. Es sei $F$ ein Boolescher
|
|
Ausdruck mit Variablen $x_1, \dots, x_n$ und Klauseln $C_1, \dots, C_m$.
|
|
Konstruiere Instanz $(V, W, U, T)$ mit:
|
|
\begin{align*}
|
|
V &= \{a_i^j \mid i = 1, \dots, n,\ j = 1, \dots, m\}
|
|
\cup \{v_j \mid j = 1, \dots, m\}
|
|
\cup \{c_k \mid k = 1, \dots, m(n-1)\}\\
|
|
W &= \{b_i^j \mid i = 1, \dots, n,\ j = 1, \dots, m\}
|
|
\cup \{w_j \mid j = 1, \dots, m\}
|
|
\cup \{d_k \mid k = 1, \dots, m(n-1)\}\\
|
|
U &= \{x_i^j, \bar{x}_i^j \mid i = 1, \dots, n,\ j = 1, \dots, m\}
|
|
\end{align*}
|
|
Es gilt $|U| = |V| = |W| = 2nm$. $T$ enthalte die folgenden Vektoren
|
|
\begin{enumerate}
|
|
\item[(1)] $(a_i^j, b_i^j, x_i^j)$ und $(a_i^{j+1}, b_i^j, \bar{x}_i^j)$
|
|
f\"ur $i = 1, \dots, n$, $j = 1, \dots, m$, wobei $a_i^{m+1} = a_i^1$.
|
|
|
|
Beachte: die $a$- und $b$-Knoten tauchen in den anderen Vektoren nicht
|
|
mehr auf. Hier \"uberdeckt man in $M$ entweder alle $x_i^j$ f\"ur
|
|
$j = 1, \dots, m$ oder alle $\bar{x}_i^j$. Das erzeugt die
|
|
Variablensetzung $x_i = \false$ oder $x_i = \true$.
|
|
\item[(2)] $(v_j, w_j, \lambda^j)$ f\"ur $j = 1, \dots, m$ und $\lambda$
|
|
Literal von $C_j$.
|
|
|
|
Die $v$- und $w$-Knoten tauchen in anderen Vektoren nicht mehr auf.
|
|
$\Rightarrow$ F\"ur jede Klausel $C_j$ m\"ussen wir ein Literal
|
|
$\lambda$ ausw\"ahlen und einen Vektor $(v_j, w_j, \lambda^j) \in M$.
|
|
D.h.\ die Knoten $v_j, w_j$ werden mit dem wahren Literal aus $C_j$
|
|
gematcht.
|
|
\item[(3)] Die $c$- und $d$-Knoten spielen die Rolle einer Garbage
|
|
Collection. Die Vektoren haben die Form $(c_k, d_k, x_i^j)$,
|
|
$(c_k, d_k, \bar{x}_i^j)$ f\"ur $k = 1, \dots, m(n-1)$ und
|
|
$i = 1, \dots, n$ und $j = 1, \dots, m$.
|
|
|
|
Damit sammelt man $(n-1)m$ Literale auf.
|
|
\end{enumerate}
|
|
Zeige dann die Behauptung: $F$ ist erf\"ullbar $\Leftrightarrow$
|
|
$(V, W, U, T)$ enth\"alt ein 3-dim.\ Matching.
|
|
|
|
Zur Variablensetzung betrachte folgendes Bild:
|
|
|
|
% --- PLATZHALTER: "Rad"-Abbildung zur Variablensetzung ---
|
|
% Im Original: kreisfoermige Anordnung der Knoten x^1..x^4, xbar^1..xbar^4
|
|
% mit den a^j/b^j-Knoten dazwischen (Zahnrad-Struktur).
|
|
\begin{center}
|
|
\fbox{\parbox{0.85\textwidth}{\small\emph{[Abbildung im Original: zyklische
|
|
,,Zahnrad``-Struktur der Vektoren $(a_i^j, b_i^j, x_i^j)$ und
|
|
$(a_i^{j+1}, b_i^j, \bar{x}_i^j)$ mit den Knoten $x^1,\dots,x^4$,
|
|
$\bar{x}^1,\dots,\bar{x}^4$ und $a^1,\dots,a^4$, $b^1,\dots,b^4$.]}}}
|
|
\end{center}
|
|
|
|
Konstruktion f\"ur $(x_1 \vee \neg x_2) \wedge (\neg x_1 \vee \neg x_2)$
|
|
mit $\psi(x_1) = \true$ und $\psi(x_2) = \false$:
|
|
|
|
% --- PLATZHALTER: Matching-Abbildung zum Beispiel ---
|
|
\begin{center}
|
|
\fbox{\parbox{0.85\textwidth}{\small\emph{[Abbildung im Original: Instanz
|
|
mit Knoten $x_1^1, x_1^2, \bar{x}_1^1, \bar{x}_1^2, x_2^1, x_2^2,
|
|
\bar{x}_2^1, \bar{x}_2^2$, den Klauselknoten $v_1, w_1, v_2, w_2$ sowie
|
|
$a_1^1, a_1^2, b_1^1, b_1^2, a_2^1, a_2^2, b_2^1, b_2^2$ und dem gew\"ahlten
|
|
Matching.]}}}
|
|
\end{center}
|
|
\end{proof}
|
|
|
|
\section{3-Exact Cover}
|
|
|
|
\begin{description}
|
|
\item[Gegeben:] Familie $F = \{S_1, \dots, S_n\}$ von $n$ Teilmengen
|
|
einer Menge $U = \{u_1, \dots, u_{3m}\}$ mit $|S_j| = 3$ f\"ur alle
|
|
$j = 1, \dots, n$.
|
|
\item[Entscheide:] Gibt es eine Teilfamilie von $F$ mit $m$ Teilmengen
|
|
$S_{i_1}, \dots, S_{i_m}$ und $\bigcup_{j=1,\dots,m} S_{i_j} = S$.
|
|
\end{description}
|
|
|
|
\begin{satz}
|
|
Das Problem 3-Exact Cover ist $\NP$-vollst\"andig.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
Dies folgt, da jede Instanz von 3-dim.\ Matching als eine Instanz von
|
|
3-Exact Cover aufgefasst werden kann.
|
|
\end{proof}
|
|
|
|
\section{SubSet Sum}
|
|
|
|
\begin{description}
|
|
\item[Gegeben:] $n$ ganze Zahlen $c_1, \dots, c_n$ und eine Zahl $K$.
|
|
\item[Entscheide:] Gibt es eine Teilmenge $S \subseteq \{1, \dots, n\}$
|
|
mit $\sum_{j \in S} c_j = K$?
|
|
\end{description}
|
|
|
|
\begin{satz}
|
|
Das Problem SubSet Sum ist $\NP$-vollst\"andig.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
(a) SubSet Sum $\in \NP$: W\"ahle als Zertifikat eine Teilmenge und teste,
|
|
ob Summe gleich $K$ ist.
|
|
|
|
(b) 3-Exact Cover $\leq$ SubSet Sum. Gegeben sei eine Familie von $n$
|
|
Mengen der Kardinalit\"at 3 und Grundmenge $U = \{u_1, \dots, u_{3m}\}$.
|
|
Konstruiere Zahlen $c_1, \dots, c_n$.
|
|
|
|
\emph{Idee:} Schreibe jede Menge $S_j$ in $F$ als einen Bitvektor der
|
|
L\"ange $3m$. Zum Beispiel $\{u_1, u_5, u_6\}$ als $100011$. Nun
|
|
interpretiere jeden Bitvektor als Zahl zur Basis $(n+1)$:
|
|
\[
|
|
c_j = \sum_{u_i \in S_j} (n+1)^{i-1}
|
|
\]
|
|
Dann gibt z.B.\ die Menge $\{u_1, u_5, u_6\}$ die Zahl
|
|
$(n+1)^0 + (n+1)^4 + (n+1)^5$.
|
|
|
|
Sei $K$ die Zahl zum Bitvektor $11\dots1$ der L\"ange $3m$. Dann gilt
|
|
\[
|
|
K = \sum_{j=0}^{3m-1} (n+1)^j.
|
|
\]
|
|
|
|
\emph{Behauptung:} $\exists$ $m$ Teilmengen in $F$, die
|
|
$\{u_1, \dots, u_{3m}\}$ \"uberdeckt $\Leftrightarrow$ es gibt Teilmenge
|
|
der $c_j$, deren Summe genau $K$ ergibt.
|
|
|
|
$\Leftarrow$: Sei $S \subseteq \{1, \dots, n\}$ mit
|
|
$\sum_{j \in S} c_j = K$.
|
|
|
|
Beachte: (1) Koeffizienten von $(n+1)^i$ sind immer 0 oder 1. (2) Wir haben
|
|
$< (n+1)$ Summanden auf der rechten Seite, da $|S| \leq n$. D.h.\ es gibt
|
|
keinen \"Ubertrag bei der Addition zur Basis $(n+1)$. Und wir erhalten
|
|
genau eine 1 in jeder Bitposition. Daraus folgt, dass
|
|
$C = \{S_j \mid j \in S\}$ genau die Menge $\{u_1, \dots, u_{3m}\}$
|
|
\"uberdeckt.
|
|
|
|
$\Rightarrow$: Gegeben sei ein Exact Cover $C$ von
|
|
$\{u_1, \dots, u_{3m}\}$. Dann folgt sofort $\sum_{S_j \in C} c_j = K$.
|
|
\end{proof}
|
|
|
|
\section{Partition}
|
|
|
|
\begin{description}
|
|
\item[Gegeben:] $n$ ganze Zahlen $c_1, \dots, c_n$.
|
|
\item[Entscheide:] Gibt es eine Teilmenge $S \subseteq \{1, \dots, n\}$
|
|
mit $\sum_{j \in S} c_j = \frac{1}{2}\sum_{j=1}^{n} c_j$?
|
|
\end{description}
|
|
|
|
\begin{satz}
|
|
Das Problem Partition ist $\NP$-vollst\"andig.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
(a) Partition $\in \NP$ (klar).
|
|
|
|
(b) SubSet Sum $\leq$ Partition. Gegeben seien Zahlen
|
|
$c_1, \dots, c_n, K$. Setze $N = \sum_{j=1}^{n} c_j + 1$ und konstruiere
|
|
die folgende Menge von $(n+2)$ Gegenst\"anden:
|
|
$\{1, \dots, n\} \cup \{b, c\}$ mit Zahlen $c_1, \dots, c_n$ und
|
|
$c_{n+1} = N - K$ und $c_{n+2} = K + 1$. Dann gilt
|
|
$\sum_{j=1}^{n+2} c_j = (N-1) + (N-K) + (K+1) = 2N$. D.h.
|
|
\[
|
|
\frac{1}{2}\sum_{j=1}^{n+2} c_j = N.
|
|
\]
|
|
|
|
\emph{Behauptung:} $c_1, \dots, c_n, K$ ist Ja-Eingabe von SubSet Sum
|
|
$\Leftrightarrow$ $c_1, \dots, c_{n+2}$ ist Ja-Eingabe von Partition.
|
|
|
|
\emph{Vorbemerkung:} $\{b, c\}$ k\"onnen nicht in einer L\"osung zusammen
|
|
vorkommen, da
|
|
\[
|
|
c_{n+1} + c_{n+2} = (N-K) + (K+1) = N + 1.
|
|
\]
|
|
|
|
$\Rightarrow$: Sei $S \subseteq \{1, \dots, n\}$ mit
|
|
$\sum_{j \in S} c_j = K$ gegeben. W\"ahle $S \cup \{b\}$ und erhalte
|
|
$\sum_{j \in S} c_j + c_{n+1} = K + (N-K) = N$. Dies ist L\"osung von
|
|
Partition.
|
|
|
|
$\Leftarrow$: Sei $S \subseteq \{1, \dots, n+2\}$ L\"osung von Partition
|
|
mit $\sum_{j \in S} c_j = N$ gegeben. Dann gilt f\"ur die Komplementmenge
|
|
$S^c = \{1, \dots, n+2\} \setminus S$ auch $\sum_{j \in S^c} c_j = N$.
|
|
Wegen der obigen Vorbemerkung k\"onnen $b$ und $c$ nicht beide in $S$ und
|
|
auch nicht in $S^c$ liegen. O.B.d.A.\ liege $b \in S$ und damit
|
|
$c \notin S$.
|
|
|
|
Dann gilt
|
|
\[
|
|
N = \sum_{j \in S} c_j = \sum_{j \in S \setminus \{b,c\}} c_j + c_{n+1}
|
|
= \sum_{j \in S \setminus \{b,c\}} c_j + (N - K)
|
|
\]
|
|
Deswegen gilt nun
|
|
\[
|
|
\sum_{j \in S \setminus \{b,c\}} c_j = K;
|
|
\]
|
|
d.h.\ $S \setminus \{b,c\}$ ist L\"osung von SubSet Sum.
|
|
\end{proof}
|
|
|
|
\section{Rucksackproblem}
|
|
|
|
\begin{description}
|
|
\item[Gegeben:] $n$ Gegenst\"ande mit Gr\"o\ss en $c_1, \dots, c_n$ und
|
|
Gewinnen $p_1, \dots, p_n$ und Rucksackkapazit\"at $K$ und Profitwert
|
|
$P$.
|
|
\item[Entscheide:] Gibt es eine Teilmenge $S \subseteq \{1, \dots, n\}$
|
|
der $n$ Gegenst\"ande mit Gesamtgr\"o\ss e $\sum_{j \in S} c_j \leq K$
|
|
und Gesamtprofit $\sum_{j \in S} p_j \geq P$?
|
|
\end{description}
|
|
|
|
\begin{satz}
|
|
Das Rucksackproblem ist $\NP$-vollst\"andig.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
Spezialfall mit $c_j = p_j$ f\"ur alle Gegenst\"ande und $P = K$
|
|
entspricht dem SubSet Sum Problem.
|
|
\end{proof}
|
|
|
|
\section{Exponentialzeit-Hypothese}
|
|
|
|
Die Exponentialzeit-Hypothese (ETH) ist eine, bisher unbewiesene,
|
|
Rechenh\"arte-Annahme. Formuliert wurde sie von Impagliazzo, Paturi und
|
|
Zane im Jahre 2001 [IPZ01].
|
|
|
|
\begin{satz}[Exponential Time Hypothesis]
|
|
Es existiert eine positive Zahl $\delta \in \mathbb{R}$ so dass 3-SAT mit
|
|
$n$ Variablen und $m$ Klauseln nicht in Zeit $2^{\delta n}(n+m)^{O(1)}$
|
|
gel\"ost werden kann.
|
|
\end{satz}
|
|
|
|
Dieses Theorem ist dadurch motiviert, dass alle bekannten Algorithmen f\"ur
|
|
3-SAT eine Laufzeit von $c^n (n+m)^{O(1)}$ besitzen. Die derzeit kleinste
|
|
Konstante $c$ ist $1{,}30704$.
|
|
|
|
\begin{lemma}[Sparsifikation-Lemma]
|
|
Unter der Annahme der ETH existiert ein $\delta' \in \mathbb{R}_{\geq 0}$,
|
|
so dass 3-SAT mit $m$ Klauseln nicht in Zeit
|
|
$O(2^{\delta' m}) = 2^{\delta' m}(n+m)^{O(1)}$ gel\"ost werden kann.
|
|
\end{lemma}
|
|
|
|
Aus obigem Lemma folgt, dass kein Algorithmus mit Laufzeit $2^{o(m)}$
|
|
f\"ur 3-SAT existieren kann.
|
|
|
|
\begin{satz}
|
|
Gegeben eine 3-SAT Formel $\Phi$ mit $n$ Variablen und $m$ Klauseln ist es
|
|
m\"oglich einen Graphen $G$ mit $O(n+m)$ Knoten in polynomieller Zeit zu
|
|
konstruieren, der genau dann 3-f\"arbbar ist, wenn $\Phi$ erf\"ullbar ist.
|
|
\end{satz}
|
|
|
|
Da es m\"oglich ist diesen Graphen in polynomieller Zeit zu erstellen und
|
|
die Anzahl der Knoten linear in Variablen und Klauseln ist, k\"onnen wir
|
|
direkt unter Annahme der ETH folgendes schlussfolgern.
|
|
|
|
\begin{satz}
|
|
Unter Annahme der ETH gibt es keinen $2^{o(n)}$ Algorithmus f\"ur
|
|
3-F\"arbung.
|
|
\end{satz}
|
|
|
|
Mittels \"ahnlichen Transformationen k\"onnen wir \"ahnliche Ergebnisse
|
|
auch f\"ur das Cliquenproblem, Vertex Cover und Independent Set folgern.
|
|
|
|
\begin{satz}
|
|
Unter Annahme der ETH gibt es keinen $2^{o(n)}$ Algorithmus f\"ur das
|
|
Cliquenproblem, Vertex Cover und Independent Set.
|
|
\end{satz}
|
|
|
|
Die ETH hat auch Konsequenzen f\"ur die bekannten Subset Sum und
|
|
Partition-Probleme. Wir zeigen eine Reduktion von 3-SAT auf Subset Sum und
|
|
schlie\ss en damit folgendes:
|
|
|
|
\begin{satz}
|
|
Partition, Subset Sum k\"onnen nicht in Zeit
|
|
$2^{o(n)}\mathrm{poly}(|I|)$ entschieden werden, au\ss er die ETH ist
|
|
falsch.
|
|
\end{satz}
|
|
|
|
\begin{proof}[Beweis (Beweis von Ingo Wegener)]
|
|
Gegeben sei eine Formel mit Variablen $x_1, \dots, x_n$ und Klauseln
|
|
$c_1, \dots, c_m$. F\"ur jede Variable $x_i$ erzeuge zwei Gegenst\"ande
|
|
$a_i, b_i$ mit Gr\"o\ss e
|
|
\begin{align*}
|
|
s(a_i) &= 10^{i-1} + \sum_{j \in [m],\, x_i \in c_j} 10^{n+j-1}\\
|
|
s(b_i) &= 10^{i-1} + \sum_{j \in [m],\, \bar{x}_i \in c_j} 10^{n+j-1}
|
|
\end{align*}
|
|
[Alle Zahlen haben $n+m$ Ziffern zur Basis 10.] Erzeuge zus\"atzlich zwei
|
|
Dummy Items $d_j, e_j$ f\"ur Klausel $c_j$ mit
|
|
$s(d_j) = s(e_j) = 10^{n+j-1}$.
|
|
|
|
Die Itemmenge $A = \{a_i, b_i \mid i \in [n]\} \cup
|
|
\{d_j, e_j \mid j \in [m]\}$. Target-Wert ist dann
|
|
\[
|
|
B = \sum_{i=1}^{n} 10^{i-1} + \sum_{j=1}^{m} 3 \cdot 10^{n+j-1}
|
|
\]
|
|
|
|
\emph{Bemerkung:} (a): Eine L\"osung kann nur entweder $a_i$ oder $b_i$
|
|
enthalten. Dies folgt aus der Variablensetzung.
|
|
|
|
(b): Bei den h\"oheren Ziffern ben\"otigt man durch die Variablensetzung
|
|
Werte 1, 2 oder 3 ($\hat{=}$ \# Literale, die erf\"ullt sind pro Klausel)
|
|
[die Dummy Items kann man nutzen um auf genau 3 zu kommen].
|
|
|
|
F\"ur den Beweis zeige noch: Die Reduktion ist streng (d.h.\ $|A| = O(m)$)
|
|
\begin{enumerate}
|
|
\item[a)] Wir k\"onnen annehmen, dass $n \leq 3m$ [beachte:
|
|
$m \leq O(n^3)$]
|
|
\[
|
|
\to |A| = 2n + 2m \leq_{n \leq 3m} 6m + 2m = 8m
|
|
\]
|
|
\end{enumerate}
|
|
Der Rest geht dann per indirektem Beweis. Daf\"ur nehmen wir an, dass ein
|
|
Algorithmus f\"ur Subset Sum mit Laufzeit $2^{o(n)}\mathrm{poly}(|I|)$
|
|
existiert. F\"ur eine Formel $\Phi$ in 3-SAT in KNF mit $m$ Klauseln
|
|
konstruiere Instanz von Subset Sum mit $\leq 8m = O(m)$ Gegenst\"anden und
|
|
l\"ose diese Instanz mit obigem Algorithmus.
|
|
\[
|
|
2^{o(8m)}\mathrm{poly}(|I|) = 2^{o(m)}\mathrm{poly}(|I|).
|
|
\]
|
|
Wegen Korrektheit und Laufzeit der Reduktion bestimmt dies die
|
|
Erf\"ullbarkeit von $\Phi$ in der Laufzeit von
|
|
$2^{o(m)}\mathrm{poly}(|I|)$. Dies ist ein Widerspruch zum Sparsification
|
|
Lemma der ETH. Als Anmerkung: Ohne das Sparsification Lemma kann kein
|
|
Algorithmus f\"ur Subset Sum existieren mit Laufzeit von
|
|
$2^{o(\sqrt[3]{n})}$.
|
|
\end{proof}
|
|
|
|
\paragraph{Einschub:} Eine Anmerkung zur $o$-Notation: Die kleine
|
|
$o$-Notation ist wie folgt definiert.
|
|
\[
|
|
f(x) = o(g(x)) \Leftrightarrow
|
|
\forall c > 0: \exists x_0 \geq 0: \forall x \geq x_0:
|
|
|f(x)| \leq c \cdot |g(x)|
|
|
\]
|
|
Man kann dies auch als $\frac{f(x)}{g(x)} \to 0$ f\"ur $x \to \infty$
|
|
schreiben. Nach dieser Definition gilt also auch dass $\delta n = o(n)$,
|
|
weswegen die beiden Schreibweisen austauschbar verwendet werden. Die
|
|
Originale Formulierung der ETH verwendet die $\delta n$ Notation, weswegen
|
|
sie in unserer Formulierung der Theoreme verwendet wurde.
|
|
|
|
\section{Hamiltonkreis Problem}
|
|
|
|
Das Hamiltonkreis Problem (HK) ist wie folgt definiert:
|
|
|
|
\begin{description}
|
|
\item[Gegeben:] Ein ungerichteter Graph $G = (V,E)$ mit
|
|
$V = \{v_1, \dots, v_n\}$.
|
|
\item[Entscheide:] Gibt es einen Hamiltonschen Kreis; d.h.\ eine
|
|
Permutation $\pi$ der Knoten $(v_{\pi(1)}, \dots, v_{\pi(n)})$ mit
|
|
$\{v_{\pi(i)}, v_{\pi(i \bmod n + 1)}\} \in E$ f\"ur alle
|
|
$i = 1, \dots, n$?
|
|
\end{description}
|
|
|
|
\begin{beispiel}
|
|
Der Graph in dem folgenden Bild hat einen entsprechenden Hamiltonkreis;
|
|
dieser ist fettgezeichnet.
|
|
|
|
\begin{center}
|
|
\abbtext{Graph mit f\"unf Knoten und acht Kanten; ein Hamiltonkreis \"uber alle f\"unf Knoten ist fett hervorgehoben, die restlichen drei Kanten geh\"oren nicht zum Kreis.}
|
|
\end{center}
|
|
\end{beispiel}
|
|
|
|
\begin{satz}
|
|
Das Hamiltonkreis Problem ist $\NP$-vollst\"andig.
|
|
\end{satz}
|
|
|
|
\begin{bemerkung}
|
|
Die gleiche Aussage gilt auch f\"ur gerichtete Graphen.
|
|
\end{bemerkung}
|
|
|
|
\begin{proof}
|
|
(a) HK ist in $\NP$: W\"ahle als Zertifikat eine Permutation $\pi$ der
|
|
Knoten und teste, ob $\{v_{\pi(i)}, v_{\pi(i+1 \bmod n)}\} \in E$ ist
|
|
f\"ur alle $i = 1, \dots, n$.
|
|
|
|
(b) $3\text{-}SAT' \leq HK$: Gegeben sei eine SAT Formel mit genau 3
|
|
Literalen pro Klausel (ist ebenfalls $\NP$-vollst\"andig). Zur Beweisidee
|
|
geben wir die folgenden Graph-Konstruktionen an. Als erstes verwende die
|
|
folgende $A$-Komponente:
|
|
|
|
% --- A-Komponente (Leiter-Graph) ---
|
|
\begin{center}
|
|
\abbtext{$A$-Komponente (Leitergraph): eine obere Reihe aus sechs Knoten (linke Ecke $1$, rechte Ecke $3$) und eine untere Reihe aus sechs Knoten (linke Ecke $2$, rechte Ecke $4$), jeweils zu einem Pfad verbunden; die vier inneren Knotenpaare sind \"uber vier mittlere Knoten $5,6,7,8$ sprossenartig verbunden (oben--Mitte--unten).}
|
|
\end{center}
|
|
|
|
Dann gibt es zwei M\"oglichkeiten, die Komponente $A$ zu durchlaufen; siehe
|
|
die folgenden zwei Abbildungen:
|
|
|
|
% --- PLATZHALTER: die zwei Durchlauf-Varianten der A-Komponente ---
|
|
\begin{center}
|
|
\fbox{\parbox{0.85\textwidth}{\small\emph{[Abbildungen im Original: die
|
|
zwei m\"oglichen Hamilton-Durchl\"aufe der $A$-Komponente
|
|
(Zickzack-Pfade $1 \to 3$ oben bzw.\ $2 \to 4$ unten).]}}}
|
|
\end{center}
|
|
|
|
F\"ur jede Klausel verwenden wir die folgende Komponente $B$:
|
|
|
|
% --- PLATZHALTER: B-Komponente ---
|
|
\begin{center}
|
|
\fbox{\parbox{0.85\textwidth}{\small\emph{[Abbildung im Original:
|
|
$B$-Komponente mit den rechten Knoten $1, 2, 3, 4$ (Kanten
|
|
$\{u_1,u_2\}, \{u_2,u_3\}, \{u_3,u_4\}$) und innerer
|
|
Dreiecks-/Rechteckstruktur.]}}}
|
|
\end{center}
|
|
|
|
Eine der vielen M\"oglichkeiten, wie $B$ durchlaufen werden kann, ist im
|
|
folgenden Bild dargestellt.
|
|
|
|
% --- PLATZHALTER: Beispiel-Durchlauf der B-Komponente ---
|
|
\begin{center}
|
|
\fbox{\parbox{0.85\textwidth}{\small\emph{[Abbildung im Original: ein
|
|
m\"oglicher Hamilton-Durchlauf der $B$-Komponente
|
|
(fettgezeichnete Kanten).]}}}
|
|
\end{center}
|
|
|
|
Insgesamt gibt es f\"ur jede nicht-leere Teilmenge der rechten Kanten
|
|
$\{u_1, u_2\}, \{u_2, u_3\}, \{u_3, u_4\}$ eine M\"oglichkeit die
|
|
Komponente $B$ zu durchlaufen. Bei einer leeren Teilmenge dieser Kanten
|
|
funktioniert dies aber nicht; dies entspricht dem Fall, dass alle Literale
|
|
falsch gew\"ahlt worden sind. Als Kurzform f\"ur die Spezialkomponenten
|
|
$A$ und $B$ verwenden wir:
|
|
|
|
% Kurzform A-Komponente
|
|
\begin{center}
|
|
\abbtext{Kurzform der $A$-Komponente: zwei parallele Kanten $1$--$3$ (oben) und $2$--$4$ (unten), verbunden \"uber einen mittleren Kreis-Knoten $5$ mit Doppelpfeilen zu beiden Kanten.}
|
|
\end{center}
|
|
|
|
% Kurzform B-Komponente
|
|
\begin{center}
|
|
\abbtext{Kurzform der $B$-Komponente: vier \"ubereinanderliegende Knoten $1,2,3,4$ mit den B\"ogen $\{1,2\}, \{2,3\}, \{3,4\}$; ein Kreis-Knoten $5$ links zeigt mit Pfeilen auf alle vier Knoten.}
|
|
\end{center}
|
|
|
|
Im folgenden Beispiel zeigen wir die Konstruktion des Graphen $G$ zu einem
|
|
Booleschen Ausdruck $F$.
|
|
|
|
\begin{beispiel}
|
|
Ausdruck $F = (x_1 \vee \neg x_2 \vee x_3) \wedge
|
|
(\neg x_1 \vee x_2 \vee \neg x_3) \wedge
|
|
(\neg x_1 \vee \neg x_2 \vee x_3)$ und der zugeh\"orige konstruierte Graph
|
|
$G$:
|
|
|
|
% --- PLATZHALTER: Gesamtkonstruktion zu Beispiel 6.44 ---
|
|
\begin{center}
|
|
\fbox{\parbox{0.85\textwidth}{\small\emph{[Abbildung im Original: Graph
|
|
$G$ mit den $B$-Komponenten $10, 11, 12$ (links, eine pro Klausel), den
|
|
$A$-Komponenten $1$--$9$ (Mitte, eine pro Literalvorkommen) und dem
|
|
rechten Pfad mit den Knotenpaaren $13/14$, $15/16$, $17/18$ (Doppelkanten
|
|
$\{v_i, w_i\}$ f\"ur die Variablensetzung).]}}}
|
|
\end{center}
|
|
\end{beispiel}
|
|
|
|
F\"ur die Variablensetzung von Variable $x_i$ w\"ahlt man im rechten Pfad
|
|
im obigen Bild jeweils zwischen zwei Knoten $v_i, w_i$ f\"ur
|
|
$i = 1, \dots, n$ die rechte oder linke Kopie der Kante $\{v_i, w_i\}$.
|
|
Die $A$-Komponenten werden nun genutzt um die Verbindung zwischen den
|
|
Variablen und den Literalen in den $B$-Komponenten zu den entsprechenden
|
|
Klauseln herzustellen. Dazu bezeichnen wir die $u$-Knoten in der
|
|
$B$-Komponente zu Klausel $F_i$ mit $u_{i1}, u_{i2}, u_{i3}$ und $u_{i4}$.
|
|
|
|
Wenn das $j$.te Literal in Klausel $F_i$ gleich $x_k$ ist, dann verbinden
|
|
wir die Kante $\{u_{ij}, u_{ij+1}\}$ via einer $A$-Komponente mit der
|
|
linken Kopie von $\{v_k, w_k\}$. Wenn das $j$.te Literal gleich
|
|
$\neg x_k$, so verbinden wir die Kante $\{u_{ij}, u_{ij+1}\}$ mit der
|
|
rechten Kopie.
|
|
|
|
Formal beweist man am Ende die folgende Aussage: $F$ ist erf\"ullbar genau
|
|
dann, wenn $G$ einen Hamiltonkreis besitzt.
|
|
\end{proof}
|
|
|
|
Die Details findet man im Buch von Papadimitriou und Steiglitz.
|
|
|
|
\subsection*{\"Ubungsaufgaben}
|
|
|
|
\begin{uebung}
|
|
Die Eingabe des Problems $\mathrm{SAT}^3$ ist ein boolscher Ausdruck in
|
|
KNF, f\"ur den entschieden werden soll, ob es mindestens 3 erf\"ullende
|
|
Belegungen f\"ur diese Formel gibt.
|
|
|
|
Zeigen Sie, dass $\mathrm{SAT}^3$ $\NP$-vollst\"andig ist.
|
|
\end{uebung}
|
|
|
|
\begin{uebung}
|
|
Eine NAE-$k$-SAT (Not-All-Equal) Formel hat folgende Form
|
|
$\bigwedge_{i=1}^{m}(z_1^i, \dots, z_k^i)$, wobei eine Klausel
|
|
$(z_1^i, \dots, z_k^i)$ mit Literalen $z_1^i, \dots, z_k^i$ genau dann
|
|
erf\"ullt ist, wenn mindestens ein Literal zu wahr und mindestens ein
|
|
Literal zu falsch ausgewertet wird.
|
|
|
|
Beispiel: F\"ur die NAE-3-SAT Formel $(x, y, z) \wedge (\neg x, y, z)$ ist
|
|
durch $x = y = z = \true$ keine erf\"ullende Belegung gegeben, da in
|
|
diesem Fall die erste Klausel nicht erf\"ullt ist. Bei der Belegung
|
|
$x = y = \true$ und $z = \false$ hingegen ist die Formel erf\"ullt.
|
|
|
|
Zeigen Sie in einem ersten Schritt, dass NAE-4-SAT $\NP$-vollst\"andig
|
|
ist, und in einem zweiten Reduktionsschritt zeigen, dass ebenfalls
|
|
NAE-3-SAT $\NP$-vollst\"andig ist.
|
|
\end{uebung}
|
|
|
|
\begin{uebung}
|
|
Ein Independent Set in einem Graphen $G = (V,E)$ ist eine Menge von Knoten
|
|
$I$, so dass f\"ur je zwei Knoten $i, j \in I$ gilt, dass
|
|
$\{i,j\} \notin E$. F\"ur das Problem \textsc{Independent Set} ist ein
|
|
Graph $G = (V,E)$ sowie eine Zahl $k \in \mathbb{N}$ gegeben und es soll
|
|
entschieden werden, ob es in $G$ ein Independent Set mit $k$ Knoten gibt.
|
|
|
|
Zeigen Sie, dass das Problem \textsc{Independent Set}
|
|
$\NP$-vollst\"andig ist.
|
|
\end{uebung}
|
|
|
|
\begin{uebung}
|
|
Ein Vertex Cover in einem Graphen $G = (V,E)$ ist eine Menge von Knoten
|
|
$C \subseteq V$ so dass f\"ur jede Kante $\{v,w\} \in E$ gilt das
|
|
$v \in C$ oder $w \in C$. F\"ur das Problem \textsc{Vertex Cover} ist ein
|
|
Graph $G = (V,E)$ sowie eine Zahl $k \in \mathbb{N}$ gegeben und es soll
|
|
entschieden werden, ob es in $G$ ein Vertex Cover mit $k$ Knoten gibt.
|
|
|
|
Zeigen Sie, dass das Problem \textsc{Vertex Cover} $\NP$-vollst\"andig
|
|
ist.
|
|
\end{uebung}
|
|
|
|
\begin{uebung}
|
|
In dem Problem \textsc{Clique-Member} ist ein Graph $G = (V,E)$, ein
|
|
Knoten $v \in V$ sowie eine Zahl $k \in \mathbb{N}$ gegeben und es soll
|
|
entschieden werden, ob es eine Clique mit $k$ Knoten gibt, die den Knoten
|
|
$v$ enth\"alt.
|
|
|
|
Zeigen Sie, dass \textsc{Clique-Member} $\NP$-vollst\"andig ist.
|
|
\end{uebung}
|
|
|
|
\begin{uebung}
|
|
In dem Problem \textsc{Clique-Nomember} ist ein Graph $G = (V,E)$, ein
|
|
Knoten $v \in V$ sowie eine Zahl $k \in \mathbb{N}$ gegeben und es soll
|
|
entschieden werden, ob es eine Clique mit $k$ Knoten gibt, die den Knoten
|
|
$v$ nicht enth\"alt.
|
|
|
|
Zeigen Sie, dass \textsc{Clique-Nomember} $\NP$-vollst\"andig ist, indem
|
|
Sie eine Reduktion von \textsc{Clique} auf \textsc{Clique-Nomember}
|
|
angeben.
|
|
\end{uebung}
|
|
|
|
\begin{uebung}
|
|
In dem Problem \textsc{Z-Clique} ist ein zusammenh\"angender Graph
|
|
$G = (V,E)$ und eine Zahl $k \in \mathbb{N}$ gegeben und es soll
|
|
entschieden werden, ob $G$ eine Clique mit $k$ Knoten enth\"alt.
|
|
|
|
Zeigen Sie, dass \textsc{Z-Clique} $\NP$-vollst\"andig ist.
|
|
\end{uebung}
|
|
|
|
\begin{uebung}
|
|
Zeigen Sie, dass das \textsc{Partition} Problem ebenfalls $\NP$-schwer
|
|
ist, wenn eine Teilmenge $A'' \subseteq A$ gesucht ist mit
|
|
\[
|
|
\sum_{a \in A''} a = 3 \sum_{a \in A \setminus A''} a.
|
|
\]
|
|
\end{uebung}
|
|
|
|
\begin{uebung}
|
|
F\"ur das Problem \textsc{Subset Sum Cardinality} seien $n$ ganze Zahlen
|
|
$c_1, \dots, c_n \in \mathbb{N}_{>0}$ (wobei $n$ gerade sei) sowie eine
|
|
Zahl $K \in \mathbb{N}$ gegeben. Es soll entschieden werden, ob es eine
|
|
Teilmenge $S \subset \{1, \dots, n\}$ gibt mit $|S| = n/2$ und
|
|
$\sum_{i \in S} c_i = K$.
|
|
|
|
Zeigen Sie, dass das Problem \textsc{Subset Sum Cardinality}
|
|
$\NP$-vollst\"andig ist.
|
|
\end{uebung}
|
|
|
|
\begin{uebung}
|
|
Eine Eingabe des Problems \textsc{Even-Knapsack} ist eine Menge von Items
|
|
$I$, sowie ein Rucksack mit gerader Gr\"o\ss e $B$ (d.h.\ es gibt
|
|
$b \in \mathbb{N}$ mit $B = 2b$), sowie ein Profitwert $P \in \mathbb{N}$.
|
|
Jedes Item hat eine Gr\"o\ss e $s_i \in \mathbb{N}$ und einen Profit
|
|
$p_i \in \mathbb{N}$. Das Entscheidungsproblem ist eine Teilmenge
|
|
$I' \subseteq I$ zu finden mit $\sum_{i \in I'} s_i \leq B$ und
|
|
$\sum_{i \in I'} p_i \geq P$.
|
|
|
|
Zeigen Sie, dass \textsc{Even-Knapsack} $\NP$-vollst\"andig ist.
|
|
\end{uebung}
|
|
|
|
\begin{uebung}
|
|
Die Probleme Multiple-Choice-Knapsack (kurz MC-Knapsack) ist wie folgt
|
|
definiert: Gegeben sind endliche Mengen
|
|
$C_1, \dots, C_k \subseteq \mathbb{N} \times \mathbb{N}$ von Items, eine
|
|
Kapazit\"at $B \in \mathbb{N}$ und ein Zielprofit $P \in \mathbb{N}$. Wir
|
|
bezeichnen $C_i$ als Klasse von Items und f\"ur ein Item
|
|
$(w,p) \in C_i$ ist $w$ das Gewicht und $p$ der Profit des Items. Es soll
|
|
entschieden werden, ob aus jeder Klasse $C_i$ genau ein Item $(w_i, p_i)$
|
|
gew\"ahlt werden kann, sodass die gew\"ahlten Items gemeinsam den
|
|
Zielprofit erf\"ullen ohne die Kapazit\"at zu \"uberschreiten, d.h.\
|
|
$\sum_{i \in [k]} p_i \geq P$ und $\sum_{i \in [k]} w_i \leq B$.
|
|
|
|
Das Problem ist in $\NP$. Zeigen Sie: MC-Knapsack ist $\NP$-vollst\"andig.
|
|
\end{uebung}
|
|
|
|
\chapter{Approximative Algorithmen}
|
|
|
|
Das letzte Kapitel hat uns Einblicke in die Schwierigkeit der polynomiellen
|
|
Berechenbarkeit gegeben. Wir wissen nun insbesondere, dass es viele Probleme
|
|
gibt, deren exakte L\"osung eine gro\ss e, nicht-polynomielle Laufzeit
|
|
ben\"otigt -- es sei denn, es gilt $\PP = \NP$. In Ermangelung einer
|
|
Eingebung zu der Frage, ob $\PP = \NP$ oder $\PP \neq \NP$ gilt, hat sich
|
|
die Disziplin der Approximativen Algorithmen entwickelt; anstatt eine
|
|
exakte L\"osung zu verlangen, l\"asst man die Berechnung geringf\"ugig
|
|
schlechterer L\"osungen zu, welche sich aber deutlich schneller berechnen
|
|
lassen. Die exakte L\"osung wird in diesem Sinne nur noch approximiert.
|
|
|
|
In diesem Kapitel wollen wir einige solche Approximationsalgorithmen
|
|
studieren.
|
|
|
|
\section{Traveling Salesman Problem}
|
|
|
|
\begin{description}
|
|
\item[Gegeben:] Eine Menge $V = \{1, \dots, n\}$, Distanzen
|
|
$d(i,j) \in \mathbb{Z}^{+} \cup \{\infty\}$ f\"ur alle
|
|
$i, j \in \{1, \dots, n\}$
|
|
\item[Gesucht:] Eine minimale Rundreise, die jeden Knoten genau einmal
|
|
besucht.
|
|
\end{description}
|
|
|
|
Formal: Eine L\"osung ist gegeben durch eine Permutation $\Pi$ von
|
|
$\{1, \dots, n\}$, wobei die L\"ange der Tour
|
|
$\sum_{i=1}^{n} d(\Pi(i), \Pi(i+1))$ mit $\Pi(n+1) = \Pi(1)$ ist.
|
|
|
|
\begin{beispiel}
|
|
Betrachte den folgenden Graphen mit 4 Knoten:
|
|
|
|
\begin{center}
|
|
\abbtext{Vollst\"andiger Graph mit vier Knoten $1,2,3,4$ als Quadrat: die vier Seiten haben Distanz $1$, die beiden Diagonalen Distanz $2$.}
|
|
\end{center}
|
|
|
|
Eine optimale Rundreise ist $[1,2,3,4,1]$ mit L\"ange 4.
|
|
\end{beispiel}
|
|
|
|
\begin{satz}
|
|
Das Entscheidungsproblem zum Traveling Salesman Problem, ob eine Rundreise
|
|
mit L\"ange $\leq L$ existiert, ist $\NP$-vollst\"andig.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
Dies folgt durch eine Reduktion vom Hamiltonkreis Problem: W\"ahle f\"ur
|
|
jede Kante $\{u,v\} \in E$ den Wert $d(u,v) = 1$ und f\"ur alle anderen
|
|
Paare $\{u,v\} \notin E$ den Wert $d(u,v) = |V| + 1$ sowie $L = |V|$.
|
|
\end{proof}
|
|
|
|
Durch Modifikation der Distanzen $d(u,v) = \infty$ f\"ur alle
|
|
$\{u,v\} \notin E$, kann man sogar zeigen, dass es keinen approximativen
|
|
Algorithmus f\"ur das allgemeine TSP Problem mit beschr\"ankter
|
|
Approximationsg\"ute gibt.
|
|
|
|
Deswegen betrachten wir den \emph{symmetrischen Fall} des TSP mit
|
|
$d(i,j) = d(j,i)$ und mit Erf\"ullung der Dreiecksungleichung (kurz:
|
|
$\Delta$-Ungleichung) $d(i,j) \leq d(i,k) + d(k,j)$; siehe auch folgendes
|
|
Bild:
|
|
|
|
\begin{center}
|
|
\abbtext{Dreieck mit den Ecken $i$, $j$ und $k$: die direkte Kante $i$--$j$ und der Umweg \"uber $k$ veranschaulichen die $\Delta$-Ungleichung.}
|
|
\end{center}
|
|
|
|
\begin{bemerkung}
|
|
Das TSP bleibt $\NP$-vollst\"andig im symmetrischen Fall mit
|
|
Dreiecksungleichung.
|
|
\end{bemerkung}
|
|
|
|
\begin{definition}
|
|
Es sei $G$ ein Multigraph mit parallelen Kanten. Ein \emph{Eulerscher
|
|
Kreis} ist ein Kreis, der jede Kante von $G$ genau einmal besucht.
|
|
\end{definition}
|
|
|
|
\begin{beispiel}[K\"onigsberger Br\"uckenproblem]
|
|
\leavevmode
|
|
\begin{center}
|
|
\abbtext{Schematische Karte: vier Landmassen $A, B, C, D$, verbunden durch sieben Br\"ucken (je zwei zwischen $A$--$B$ und $A$--$C$, je eine zwischen $A$--$D$, $B$--$D$ und $C$--$D$).}
|
|
\end{center}
|
|
|
|
\textbf{Frage:} Gibt es einen Rundweg, bei dem man \"uber jede der 7
|
|
Br\"ucken genau einmal l\"auft?
|
|
|
|
Wir k\"onnen das Br\"uckenproblem in ein Graphproblem wie folgt
|
|
transformieren:
|
|
|
|
\begin{center}
|
|
\abbtext{Multigraph mit vier Knoten $A, B, C, D$ und sieben Kanten: Doppelkanten $A$--$B$ und $A$--$C$, einfache Kanten $A$--$D$, $B$--$D$ und $C$--$D$.}
|
|
\end{center}
|
|
|
|
\textbf{Frage:} Gibt es einen Eulerschen Kreis in dem Graphen?
|
|
\end{beispiel}
|
|
|
|
Die Frage nach einem Eulerschen Kreis l\"asst sich durch das folgende
|
|
Kriterium beantworten.
|
|
|
|
\begin{satz}
|
|
Es sei $G$ ein zusammenh\"angender Multigraph. Dann sind \"aquivalent:
|
|
\begin{enumerate}
|
|
\item[(a)] $G$ ist Eulersch (d.h.\ besitzt einen Eulerschen Kreis).
|
|
\item[(b)] Jeder Knoten in $G$ hat geraden Grad.
|
|
\item[(c)] Die Kantenmenge von $G$ kann in disjunkte Kreise zerlegt
|
|
werden.
|
|
\end{enumerate}
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
zur \"Ubung.
|
|
\end{proof}
|
|
|
|
Mit Hilfe von dem obigen Kriterium sieht man nun, dass der obige Graph zum
|
|
K\"onigsberger Br\"uckenproblem Knoten mit ungeradem Grad besitzt und es
|
|
daher keinen entsprechenden Rundweg gibt.
|
|
|
|
Wir betrachten nun den folgenden Algorithmus:
|
|
|
|
\begin{quote}
|
|
\begin{alltt}
|
|
\textbf{Algorithmus} \(\Delta TSP1\)(V = \{1,...,n\}, D = (d(i,j)))
|
|
1 Berechne einen minimalen spannenden Baum \(T\) des Graphen
|
|
2 \(K\sb{n}\) mit Distanzen \(d(i,j)\);
|
|
3 Konstruiere einen Multigraphen \(G\) aus \(T\) durch Verdoppeln
|
|
4 aller Kanten;
|
|
5 Bestimme einen Eulerschen Kreis \(K\) in \(G\);
|
|
6 Bestimme eine Rundreise \(R\) aus \(K\) durch Abk\"urzungen;
|
|
7 return Rundreise \(R\).
|
|
\end{alltt}
|
|
\end{quote}
|
|
|
|
\begin{beispiel}
|
|
Betrachte den Graphen mit $V = \{A, B, C, D, E\}$; siehe folgendes Bild
|
|
(links).
|
|
|
|
% Links: vollstaendiger Graph mit allen Distanzen (Gewichte gemaess
|
|
% Original: 2,2,2,2,1,2,1,3,3,3); rechts: MST mit Gewicht 6.
|
|
\begin{center}
|
|
\abbtext{Links: vollst\"andiger Graph auf $V=\{A,B,C,D,E\}$ mit Distanzen, u.a.\ $d(A,E)=1$, $d(B,C)=1$, $d(A,C)=2$, $d(C,D)=2$ (\"ubrige Distanzen $2$ bzw.\ $3$). Rechts: minimaler Spannbaum $T$ mit den Kanten $A$--$E$ ($1$), $B$--$C$ ($1$), $A$--$C$ ($2$), $C$--$D$ ($2$); Gewicht $w(T)=6$.}
|
|
\end{center}
|
|
|
|
Eine optimale Tour ist $[C, B, D, E, A, C]$ der L\"ange 8. Der Algorithmus
|
|
berechnet einen Baum $T$ mit Gewicht $w(T) = 6$; siehe obiges Bild
|
|
(rechts). Wir erhalten den Graphen $G$ durch Verdopplung der Kanten mit
|
|
$w(G) = 12$; siehe folgendes Bild:
|
|
|
|
\begin{center}
|
|
\abbtext{Multigraph $G$: die vier Baumkanten $A$--$C$, $A$--$E$, $B$--$C$ und $C$--$D$ liegen jeweils doppelt vor; Gesamtgewicht $12$.}
|
|
\end{center}
|
|
|
|
Als Eulerschen Kreis erhalten wir $K = [C, A, E, A, C, B, C, D, C]$ mit
|
|
L\"ange $d(K) = 12$; und durch die Abk\"urzungen (d.h.\ \"Uberspringen der
|
|
schon vorher besuchten Knoten) erhalten wir die Rundreise
|
|
$R = [C, A, E, B, D, C]$ mit L\"ange $d(R) = 10$.
|
|
\end{beispiel}
|
|
|
|
\begin{satz}
|
|
Der Algorithmus $\Delta TSP1$ hat eine multiplikative G\"ute 2; d.h.\
|
|
$d(R) \leq 2\,\OPT(I)$, wobei $\OPT(I)$ die L\"ange einer minimalen
|
|
Rundreise zu der Eingabe $I$ mit $V = \{1, \dots, n\}$ und Distanzen
|
|
$D = (d(i,j))$ ist.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
Die Behauptung folgt aus den folgenden Ungleichungen:
|
|
\begin{enumerate}
|
|
\item[(1)] Das Gewicht $w(T) \leq \OPT(I)$, da eine optimale Rundreise
|
|
nach Weglassen einer Kante einen spannenden Baum ergibt und $w(T)$
|
|
das kleinste Gewicht eines spannenden Baums ist.
|
|
\item[(2)] $d(K) = 2w(T) \leq 2\,\OPT(I)$. Die erste Gleichung folgt
|
|
wegen der Verdopplung der Kanten und die Ungleichung wegen (1).
|
|
\item[(3)] $d(R) \leq d(K)$. Das gilt, da wegen der
|
|
$\Delta$-Ungleichung die folgende Ungleichung gilt:
|
|
$d(i,j) \leq d(i,\ell_1) + d(\ell_1,\ell_2) + \dots + d(\ell_t,j)$;
|
|
siehe auch folgendes Bild:
|
|
|
|
\begin{center}
|
|
\abbtext{Oben ein Pfad $i$--$\ell_1$--$\dots$--$\ell_t$--$j$, unten die direkte Kante $i$--$j$: wegen der $\Delta$-Ungleichung ist $d(i,j)$ h\"ochstens so lang wie der Umweg.}
|
|
\end{center}
|
|
|
|
Formal zeigt man die obige Ungleichung per Induktion nach $t \geq 1$.
|
|
\qedhere
|
|
\end{enumerate}
|
|
\end{proof}
|
|
|
|
\begin{bemerkung}
|
|
Es gibt Beispiele f\"ur Eingaben $I$ zu dem Traveling Salesman Problem mit
|
|
$\OPT(I) = n$, bei denen der Algorithmus $\Delta TSP1$ eine Rundreise der
|
|
L\"ange $2n - 2$ berechnet.
|
|
\end{bemerkung}
|
|
|
|
\begin{proof}
|
|
Zur Beweisidee geben wir hier ein Beispiel mit $n = 8$ Knoten. Betrachte
|
|
einen Stern mit Knoten 8 in der Mitte und Knoten $1, \dots, 7$ au\ss en,
|
|
die \"uber einen Kreis miteinander verbunden sind. Formal haben wir
|
|
$V = \{1, \dots, 8\}$ und
|
|
$E = \{\{i,8\} \mid i = 1, \dots, 7\} \cup \{\{i,i+1\} \mid
|
|
i = 1, \dots, 6\} \cup \{\{7,1\}\}$. Alle Kanten haben die Distanz 1; die
|
|
anderen Nicht-Kanten haben Distanz 2.
|
|
|
|
Eine optimale TSP Tour hat die Form $[1,2,3,4,5,6,7,8,1]$ der L\"ange 8.
|
|
Dagegen kann der MST Algorithmus einen Stern mit 8 als Mittelpunkt und
|
|
allen anderen Knoten au\ss en generieren; d.h.\ $T = (V, E')$ hat die
|
|
Kantenmenge $E' = \{\{i,8\} \mid i = 1, \dots, 7\}$. Durch Verdopplung der
|
|
Kanten erhalten wir einen Multigraphen mit $2n - 2$ Kanten. Eine
|
|
m\"ogliche Eulertour ist
|
|
\[
|
|
[8, 1, 8, 3, 8, 5, 8, 7, 8, 2, 8, 4, 8, 6, 8].
|
|
\]
|
|
Der Algorithmus erzeugt dann \"uber die Abk\"urzungen die folgende Tour:
|
|
\[
|
|
[8, 1, 3, 5, 7, 2, 4, 6, 8]
|
|
\]
|
|
mit L\"ange $14 = 2n - 2$.
|
|
\end{proof}
|
|
|
|
\begin{definition}
|
|
Ein \emph{Matching} in einem ungerichteten Graphen $G = (V,E)$ ist eine
|
|
Teilmenge $E' \subseteq E$ von Kanten, von denen keine zwei Kanten einen
|
|
gemeinsamen Endpunkt gemeinsam haben. Bei Gewichten $d(i,j)$ auf den
|
|
Kanten sei $d(E') = \sum_{\{i,j\} \in E'} d(i,j)$ das Gewicht von $E'$.
|
|
Ein Matching ist \emph{perfekt}, falls jeder Knoten $v \in V$ dabei
|
|
\"uberdeckt wird; d.h.\ $2|E'| = |V|$.
|
|
\end{definition}
|
|
|
|
\begin{beispiel}
|
|
Ein bipartiter Graph $G$ und ein perfektes Matching:
|
|
|
|
\begin{center}
|
|
\abbtext{Bipartiter Graph mit je drei Knoten links und rechts und mehreren Kanten; ein perfektes Matching aus drei Kanten (jeder linke Knoten mit genau einem rechten Knoten) ist fett hervorgehoben.}
|
|
\end{center}
|
|
\end{beispiel}
|
|
|
|
\begin{satz}[Lawler 1976]
|
|
Ein perfektes Matching in einem Graphen $G = (V,E)$ mit minimalem Gewicht
|
|
kann in Zeit $O(|V|^3)$ berechnet werden.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
siehe z.B.\ Vorlesung Discrete Optimization.
|
|
\end{proof}
|
|
|
|
Eine bessere Approximationsg\"ute erhalten wir, in dem wir die Knoten mit
|
|
ungeraden Grad optimaler durch Kanten augmentieren. Hier hilft uns ein
|
|
Matching mit minimalem Gewicht. Man beachte, dass die Anzahl der Knoten
|
|
mit ungeradem Grad gerade ist; siehe auch Lemma 5.4.
|
|
|
|
\begin{quote}
|
|
\begin{alltt}
|
|
\textbf{Algorithmus} \(\Delta TSP2\)(V = \{1,...,n\}, D = (d(i,j)))
|
|
1 Berechne einen minimalen spannenden Baum \(T\) des
|
|
2 Graphen \(K\sb{n}\) mit Gewichten \(d(i,j)\);
|
|
3 Bestimme die Menge \(X\) der Knoten in \(T\),
|
|
4 die ungeraden Grad haben;
|
|
5 Bilde den vollst\"andigen Graphen \(H\) auf \(X\)
|
|
6 mit Gewichten \(d(i,j)\) f\"ur \(i,j \in X\) mit \(i \neq j\).
|
|
7 Bestimme ein perfektes Matching \(K\) in \(H\) mit minimalem
|
|
8 Gewicht.
|
|
9 Bilde den Multigraphen \(G\), der aus \(T\) durch
|
|
10 Hinzuf\"ugen aller Kanten aus \(K\) entsteht.
|
|
11 Bestimme einen Eulerschen Kreis \(C\) in \(G\);
|
|
12 Bestimme eine Rundreise \(R\) aus \(C\) durch Abk\"urzungen;
|
|
13 return Rundreise \(R\).
|
|
\end{alltt}
|
|
\end{quote}
|
|
|
|
\begin{satz}[Christofides]
|
|
Der Algorithmus $\Delta TSP2$ hat eine multiplikative G\"ute $1{,}5$;
|
|
d.h.\ $d(R) \leq 1{,}5\,\OPT(I)$.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
Es gilt $d(C) = w(T) + d(K) \leq \OPT(I) + d(K)$. Man zeige nun, dass
|
|
$d(K) \leq \OPT(I)/2$. Daraus folgt dann die Behauptung.
|
|
|
|
Sei dazu $(i_1, \dots, i_{2m})$ mit $|X| = 2m$ die Reihenfolge, in der die
|
|
Knoten von $X$ in einer optimalen Tour $\delta$ von $I$ durchlaufen
|
|
werden. Betrachte die Matchings:
|
|
\begin{align*}
|
|
M_1 &= \{\{i_1, i_2\}, \{i_3, i_4\}, \dots, \{i_{2m-1}, i_{2m}\}\}\\
|
|
M_2 &= \{\{i_2, i_3\}, \{i_4, i_5\}, \dots, \{i_{2m}, i_1\}\}
|
|
\end{align*}
|
|
Betrachte eine optimale Tour und die Knoten aus $X$:
|
|
|
|
% Skizze: optimale Tour (Kreis) mit markierten X-Knoten i1..i6 und x, y
|
|
\begin{center}
|
|
\abbtext{Optimale Tour als Kreis: auf dem Kreis liegen die $X$-Knoten $i_1,\dots,i_6$ in dieser Reihenfolge sowie weitere Knoten $x$ und $y$. $M_1$ verbindet die aufeinanderfolgenden Paare $(i_1,i_2),(i_3,i_4),(i_5,i_6)$; $M_2$ die versetzten Paare $(i_2,i_3),(i_4,i_5),(i_6,i_1)$.}
|
|
\end{center}
|
|
|
|
Wegen der $\Delta$-Ungleichung gilt:
|
|
$\OPT(I) \geq d(i_1,i_2) + d(i_2,i_3) + \dots + d(i_{2m},i_1) =
|
|
d(M_1) + d(M_2)$. Daher gilt:
|
|
$\OPT(I) \geq d(M_1) + d(M_2) \geq 2d(K)$, da $K$ ein perfektes Matching
|
|
bez\"uglich $X$ mit minimalem Gewicht ist. Deswegen gilt:
|
|
$d(K) \leq \OPT(I)/2$ und damit die Behauptung.
|
|
\end{proof}
|
|
|
|
\begin{beispiel}
|
|
Zu unserem Graphen im obigen Beispiel erhalten wir den folgenden
|
|
induzierten Graphen $H$ rechts mit einem perfektem Matching $K$ und
|
|
Gewicht $w(K) = 3$:
|
|
|
|
\begin{center}
|
|
\abbtext{Links: der MST aus dem obigen Beispiel (Kanten $A$--$E$, $B$--$C$, $A$--$C$, $C$--$D$). Rechts: vollst\"andiger Graph $H$ auf $X=\{B,C,D,E\}$ (die Knoten mit ungeradem Grad in $T$) mit Gewichten $d(B,C)=1$, $d(D,E)=2$, $d(B,E)=2$, $d(C,D)=2$, $d(B,D)=3$, $d(C,E)=3$; das minimale perfekte Matching $K=\{\{B,C\},\{D,E\}\}$ mit Gewicht $3$ ist fett hervorgehoben.}
|
|
\end{center}
|
|
|
|
Als Multigraphen $G$ erhalten wir dann
|
|
|
|
\begin{center}
|
|
\abbtext{Multigraph $G$ aus $T$ plus Matching $K$: Kanten $A$--$C$ ($2$), $A$--$E$ ($1$), $C$--$D$ ($2$), Doppelkante $B$--$C$ ($1$) und Kante $D$--$E$ ($2$); alle Knoten haben geraden Grad.}
|
|
\end{center}
|
|
|
|
Ein Eulerkreis in $G$ ist $C = [C, B, C, A, E, D, C]$ und nach den
|
|
Abk\"urzungen erhalten wir $R = [C, B, A, E, D, C]$ mit L\"ange
|
|
$d(R) = 9$.
|
|
\end{beispiel}
|
|
|
|
\begin{lemma}
|
|
Es gibt Beispiele f\"ur Eingaben $I$ zu dem Traveling Salesman Problem mit
|
|
$\OPT(I) = n$, bei denen der Algorithmus $\Delta TSP2$ von Christofides
|
|
eine Rundreise der L\"ange $(n-1) + \lfloor n/2 \rfloor$ berechnet.
|
|
\end{lemma}
|
|
|
|
\begin{proof}
|
|
zur \"Ubung.
|
|
\end{proof}
|
|
|
|
\section{Rucksackproblem}
|
|
|
|
Dass das Rucksackproblem $\NP$-vollst\"andig ist, haben wir schon am Ende
|
|
des letzten Kapitels gesehen. Hier wollen wir nun einige einfache
|
|
Approximationsalgorithmen studieren.
|
|
|
|
\begin{description}
|
|
\item[Gegeben:]\leavevmode
|
|
\begin{itemize}
|
|
\item $n$ Gegenst\"ande mit Gewichten
|
|
$w_0, \dots, w_{n-1} \in \mathbb{N}$ und Gewinnen
|
|
$p_0, \dots, p_{n-1} \in \mathbb{N}$.
|
|
\item Rucksack der Kapazit\"at $B \in \mathbb{N}$.
|
|
\end{itemize}
|
|
\item[Gesucht:] Teilmenge $I \subseteq \{0, \dots, n-1\}$ mit
|
|
$\sum_{i \in I} w_i \leq B$ und
|
|
\[
|
|
\sum_{i \in I} p_i = \max\Big\{\sum_{i \in I'} p_i \,\Big|\,
|
|
I' \subseteq \{0, \dots, n-1\},\ \sum_{i \in I'} w_i \leq B\Big\}.
|
|
\]
|
|
\end{description}
|
|
|
|
\begin{satz}
|
|
Das Entscheidungsproblem zum Rucksackproblem ist $\NP$-vollst\"andig;
|
|
sogar wenn $w_i = p_i$ f\"ur alle $i = 0, \dots, n-1$.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
siehe Kapitel Einf\"uhrung in die Komplexit\"atstheorie.
|
|
\end{proof}
|
|
|
|
Zun\"achst betrachten wir einen einfachen Greedy Algorithmus (GA):
|
|
|
|
\begin{quote}
|
|
\begin{alltt}
|
|
\textbf{Algorithmus} GA(I = ((\(w\sb{0}\),\(p\sb{0}\)),...,(\(w\sb{n-1}\),\(p\sb{n-1}\)), B))
|
|
1 sortiere die Gegenst\"ande, so dass
|
|
\(p\sb{0}/w\sb{0} \geq p\sb{1}/w\sb{1} \geq \ldots \geq p\sb{n-1}/w\sb{n-1}\);
|
|
2 setze \(S = \emptyset\);
|
|
3 for i = 0 to n-1 do
|
|
4 if \((\sum\sb{j \in S} w\sb{j}) + w\sb{i} \leq B\) then
|
|
5 \(S = S \cup \{i\}\)
|
|
6 fi
|
|
7 od
|
|
8 return(\(S\)).
|
|
\end{alltt}
|
|
\end{quote}
|
|
|
|
Es sei $GA(I)$ der Gesamtgewinn der durch Algorithmus GA berechneten
|
|
L\"osung $S \subseteq \{0, \dots, n-1\}$ und $\OPT(I)$ der Gesamtgewinn
|
|
einer optimalen L\"osung zur Eingabe $I$.
|
|
|
|
\begin{satz}\leavevmode
|
|
\begin{enumerate}
|
|
\item[(a)] Die Laufzeit des Algorithmus GA ist $O(n \log n)$.
|
|
\item[(b)] Der Algorithmus GA hat eine multiplikative G\"ute gr\"o\ss er
|
|
gleich $B - 1$ (d.h.\ $\OPT(I)/GA(I) \geq (B-1)$).
|
|
\end{enumerate}
|
|
Der Algorithmus GA hat daher keine konstante Worst-Case G\"ute.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
Zu (a): hierzu speichere bei jedem Hinzuf\"ugen eines Gegenstands die
|
|
momentan benutzte Kapazit\"at $K$. Dann geht Schritt (2--8) in $O(n)$
|
|
Zeit. Die Gesamtlaufzeit ergibt sich durch das Sortieren in
|
|
$O(n \log n)$.
|
|
|
|
Zu (b): Betrachte das folgende Beispiel:
|
|
$I = ((w_0, p_0) = (1,1), (w_1, p_1) = (B, B-1), B)$. Hier gilt
|
|
$p_0/w_0 = 1$ und $p_1/w_1 = (B-1)/B < 1$. Der Algorithmus liefert hier
|
|
$S = \{0\}$ mit Gewinn 1; optimal ist aber $S_{\mathrm{opt}} = \{1\}$ mit
|
|
Gewinn $B - 1$.
|
|
|
|
In diesem Fall gilt $\OPT(I)/GA(I) = B - 1$. D.h.\ im allgemeinen Fall
|
|
ist die Rate unbeschr\"ankt.
|
|
\end{proof}
|
|
|
|
\emph{Hinweis:} Man beachte, dass GA in dem obigen Beispiel das Element
|
|
mit maximalem Profit $p_{\max}$ ignoriert hat. Aus diesem Grunde
|
|
betrachten wir eine leichte Modifikation von GA, die sofort hilft die
|
|
Approximationsg\"ute zu beschr\"anken.
|
|
|
|
\begin{quote}
|
|
\begin{alltt}
|
|
\textbf{Algorithmus} MGA(I = ((\(w\sb{0}\),\(p\sb{0}\)),...,(\(w\sb{n-1}\),\(p\sb{n-1}\)), B))
|
|
1 berechne L\"osung \(S\sb{1}\) mit Algorithmus GA,
|
|
2 berechne L\"osung \(S\sb{2} = \{j\}\) mit \(p\sb{j} = \max\sb{i \in \{0,...,n-1\}} p\sb{i}\),
|
|
3 w\"ahle L\"osung \(S \in \{S\sb{1}, S\sb{2}\}\) mit gr\"o\ss{}erem Gewinn.
|
|
4 return(\(S\)).
|
|
\end{alltt}
|
|
\end{quote}
|
|
|
|
Es sei $MGA(I)$ der Gesamtgewinn der durch Algorithmus MGA berechneten
|
|
L\"osung $S \subseteq \{0, \dots, n-1\}$ und $\OPT(I)$ der Gesamtgewinn
|
|
einer optimalen L\"osung zur Eingabe $I$.
|
|
|
|
\begin{satz}
|
|
Die Worst-Case G\"ute von Algorithmus MGA ist 2 (d.h.\
|
|
$\OPT(I)/MGA(I) \leq 2$ f\"ur alle Eingaben $I$).
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
Betrachte relaxierte Version des Rucksackproblems, bei dem Gegenst\"ande
|
|
fraktional genommen werden d\"urfen. Es sei $\OPT_f(I)$ der maximale Wert
|
|
einer fraktionalen L\"osung $x^{*}$. Es gilt dann
|
|
$\OPT(I) \leq \OPT_f(I)$, da der L\"osungsraum sich vergr\"o\ss ert und
|
|
ein Max-Problem vorliegt.
|
|
|
|
Eine fraktionale L\"osung $x^{*}$ von $\max \sum_{j=1}^{n} x_j p_j$ mit
|
|
$\sum_j x_j w_j \leq B$ und $x_j \in [0,1]$ f\"ur alle $j = 1, \dots, n$
|
|
nimmt Gegenst\"ande in der sortierten Reihenfolge
|
|
\[
|
|
p_1/w_1 \geq p_2/w_2 \geq \dots \geq p_n/w_n,
|
|
\]
|
|
wobei die ersten $k$ Gegenst\"ande ganzzahlig (d.h.\ $x_j^{*} = 1$) und
|
|
der letzte Gegenstand fraktional mit $x_{k+1}^{*} \in [0,1)$ gew\"ahlt
|
|
wird.
|
|
|
|
\emph{Beachte:} Es gilt $\sum_{j=1}^{k} w_j \leq B$ und
|
|
$\sum_{j=1}^{k+1} w_j > B$. Insgesamt haben wir
|
|
$\sum_{j=1}^{k+1} x_j^{*} w_j = B$. Falls wir einen fraktionalen
|
|
Gegenstand haben mit $x_{k+1}^{*} > 0$, so gilt
|
|
$\sum_{j=1}^{k} w_j < B$.
|
|
|
|
Im Folgenden zeigen wir, dass eine optimale fraktionale L\"osung die
|
|
obige Form hat. Angenommen, wir haben ein Teilst\"uck eines Gegenstands
|
|
$\ell > k+1$ der L\"ange $x_\ell^{*} w_\ell$ im Rucksack mit
|
|
$p_\ell/w_\ell < p_{k+1}/w_{k+1}$ und $x_\ell^{*} > 0$. Dann muss ein
|
|
anderes St\"uck $(1 - x_i^{*})w_i$ mit $i \leq k+1$ und $x_i^{*} < 1$ im
|
|
Rucksack fehlen (wegen den obigen Bedingungen). Betrachte die minimale
|
|
L\"ange
|
|
$\mathrm{length} = \min\{(1 - x_i^{*})w_i,\ x_\ell^{*} w_\ell\}$. Das
|
|
folgende Bild veranschaulicht die genaue Situation:
|
|
|
|
% --- PLATZHALTER: Austausch-Skizze (fraktionale Loesung) ---
|
|
\begin{center}
|
|
\fbox{\parbox{0.85\textwidth}{\small\emph{[Abbildung im Original:
|
|
Gegenst\"ande $1, 2, \dots, i, \dots, k, \dots, \ell, \dots, n$ als
|
|
Balken ($w_j$ Breite, $p_j$ H\"ohe); der Rucksackinhalt ist gr\"un
|
|
markiert; das fehlende St\"uck $(1-x_i^{*})w_i$ von Gegenstand $i$ und
|
|
das St\"uck $x_\ell^{*} w_\ell$ bzw.\ $y_\ell w_\ell$ von Gegenstand
|
|
$\ell$ werden ausgetauscht.]}}}
|
|
\end{center}
|
|
|
|
Dann gilt $\mathrm{length} = y_i w_i = y_\ell w_\ell$ mit
|
|
$y_i \in (0, 1 - x_i^{*}]$ und $y_\ell \in (0, x_\ell^{*}]$ und
|
|
$p_i/w_i \geq p_{k+1}/w_{k+1} > p_\ell/w_\ell$.
|
|
|
|
\emph{Frage:} Wie bestimmt man $y_i, y_\ell$?
|
|
|
|
Man beachte, dass
|
|
$\mathrm{length} = \min\{(1 - x_i^{*})w_i,\ x_\ell^{*} w_\ell\} > 0$.
|
|
|
|
\emph{Fall 1:} $(1 - x_i^{*})w_i = \mathrm{length}$. Hier setze
|
|
$y_i = (1 - x_i^{*})$ und $y_\ell = \mathrm{length}/w_\ell$.
|
|
|
|
\emph{Fall 2:} $x_\ell^{*} w_\ell = \mathrm{length}$. Hier setze
|
|
$y_\ell = x_\ell^{*}$ und $y_i = \mathrm{length}/w_i$.
|
|
|
|
Ersetze nun die L\"ange $y_\ell w_\ell$ in der L\"osung durch $y_i w_i$.
|
|
Der Profitgewinn durch diesen Austausch ist dann
|
|
$y_i p_i - y_\ell p_\ell$ und es gilt:
|
|
\begin{align*}
|
|
y_i p_i - y_\ell p_\ell &> y_i (p_\ell/w_\ell) w_i - y_\ell p_\ell\\
|
|
&= y_i w_i p_\ell/w_\ell - y_\ell p_\ell\\
|
|
&= y_\ell w_\ell p_\ell/w_\ell - y_\ell p_\ell\\
|
|
&= y_\ell p_\ell - y_\ell p_\ell = 0.
|
|
\end{align*}
|
|
D.h.\ der Profitgewinn ist echt positiv und damit kann ein solcher
|
|
obiger Fall nicht auftreten.
|
|
|
|
Nun kommen wir zur Absch\"atzung der Approximationsg\"ute: Da $k+1$ das
|
|
erste Item ist, dass der Algorithmus GA nicht nimmt, gilt
|
|
\[
|
|
\OPT_f(I) \leq GA(I) + p_{k+1}.
|
|
\]
|
|
Der Algorithmus MGA berechnet L\"osung mit Wert $GA(I)$ oder
|
|
$p_{\max} \geq p_{k+1}$ (bzw.\ sogar genauer mit Wert
|
|
$\max\{GA(I), p_{\max}\}$). Daher gilt
|
|
\begin{align*}
|
|
\OPT(I) &\leq \OPT_f(I) \leq GA(I) + p_{k+1}\\
|
|
&\leq GA(I) + p_{\max} \leq 2 \max\{GA(I), p_{\max}\}\\
|
|
&= 2 \cdot MGA(I) \qedhere
|
|
\end{align*}
|
|
\end{proof}
|
|
|
|
\begin{bemerkung}\leavevmode
|
|
\begin{enumerate}
|
|
\item[(a)] Der Algorithmus MGA l\"auft in Zeit $O(n \log n)$.
|
|
\item[(b)] Durch eine Modifikation von MGA k\"onnen wir auch einen
|
|
approximativen Algorithmus angeben mit Worst Case G\"ute 2, der in
|
|
$O(n)$ Zeit l\"auft.
|
|
\end{enumerate}
|
|
\end{bemerkung}
|
|
|
|
\begin{proof}
|
|
Wir verwenden als Idee zur Laufzeitverbesserung (b) hierzu den
|
|
Median-Algorithmus um das sogenannte Split-Item $k+1$ in $O(n)$ Zeit zu
|
|
finden.
|
|
\end{proof}
|
|
|
|
Der folgende Algorithmus verallgemeinert die Idee vom MGA Algorithmus,
|
|
in dem er alle $k$-elementigen Teilmengen durchprobiert, in den Rucksack
|
|
vorplaziert, wenn das m\"oglich ist, und mit Hilfe vom GA Algorithmus die
|
|
Restkapazit\"at auff\"ullt.
|
|
|
|
\paragraph{Algorithmus von Sahni}\leavevmode\\
|
|
\textbf{Gegeben:} Parameter $k \in \{0, \dots, n\}$.\\
|
|
\emph{Idee:} F\"ur jedes $k$ definiere Algorithmus $A_k$ wie folgt:
|
|
\begin{enumerate}
|
|
\item[(1)] w\"ahle eine Teilmenge $S$ mit $|S| \leq k$
|
|
Gegenst\"anden, die am Anfang im Rucksack liegen,
|
|
\item[(2)] wende Algorithmus GA auf die \"ubrigen Elemente an und
|
|
f\"uge die ausgew\"ahlten Gegenst\"ande zus\"atzlich in den Rucksack
|
|
ein.
|
|
\end{enumerate}
|
|
Wende (1) + (2) auf alle m\"oglichen Teilmengen $S$ mit $|S| \leq k$ an
|
|
und w\"ahle L\"osung mit maximalem Gewinn.
|
|
|
|
Die Technik nennt man \emph{$k$-Enumeration}. Es sei $A_k(I)$ der Gewinn
|
|
der L\"osung, den der Algorithmus $A_k$ von Sahni bez\"uglich einer
|
|
Eingabe $I$ und Parameter $k \in \{0, \dots, n\}$ produziert.
|
|
|
|
\begin{satz}
|
|
F\"ur alle $k \geq 1$ gilt: $A_k$ hat G\"ute $\leq 1 + 1/k$ und Laufzeit
|
|
$T_{A_k}(n) = O(n^{k+1})$.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
siehe Vorlesung Effiziente Algorithmen.
|
|
\end{proof}
|
|
|
|
\paragraph{Idee f\"ur ein schnelleres Verfahren:} Konstruiere aus dem
|
|
exakten Algorithmus \textsc{Knapsack} aus Kapitel 2 zum Rucksackproblem
|
|
einen polynomiellen approximativen Algorithmus.
|
|
|
|
\emph{Erinnerung:} Das dynamische Programm zum Rucksackproblem hat eine
|
|
nicht-polynomielle (bzw.\ eine sogenannte pseudo-polynomielle) Laufzeit
|
|
$O(n^2 \cdot p_{\max})$, wobei
|
|
$p_{\max} = \max\{p_i \mid 0 \leq i \leq n-1\}$. Hierbei k\"onnte
|
|
$p_{\max}$ exponentiell in der Eingabegr\"o\ss e sein; siehe auch
|
|
Bemerkung 2.20.
|
|
|
|
\paragraph{Idee zu Algorithmus $A_K$}\leavevmode
|
|
\begin{enumerate}
|
|
\item[(1)] konstruiere eine Eingabe $I_K$ mit Gewinnen
|
|
$p_i' = \lfloor p_i/K \rfloor$ (alle anderen Gr\"o\ss en $w_i$ und
|
|
$B$ bleiben gleich).
|
|
\item[(2)] wende Algorithmus \textsc{Knapsack} auf Eingabe $I_K$ an.
|
|
\end{enumerate}
|
|
Der Algorithmus $A_K$ berechnet eine L\"osung
|
|
$S \subseteq \{0, \dots, n-1\}$ mit Gr\"o\ss e
|
|
$\sum_{i \in S} w_i \leq B$ und maximalem Gewinn $\sum_{i \in S} p_i'$.
|
|
|
|
Wir entwickeln aus $A_K$ ein Verfahren $A_\epsilon$ durch die Wahl
|
|
\[
|
|
K = \frac{\epsilon\, p_{\max}}{(1/\epsilon + 1)n}.
|
|
\]
|
|
|
|
\begin{satz}
|
|
Der Algorithmus $A_\epsilon$ l\"auft in Zeit $O(n^3/\epsilon)$ und hat
|
|
eine Worst-Case G\"ute $\OPT(I)/A_\epsilon(I) \leq 1 + \epsilon$.
|
|
\end{satz}
|
|
|
|
Man nennt eine solche Familie von Algorithmen $(A_\epsilon)$ ein
|
|
\emph{vollst\"andiges polynomielles Approximationsschema} (FPTAS).
|
|
|
|
\begin{proof}
|
|
(a) zur Laufzeit: F\"ur die skalierten Profite gilt:
|
|
$p'_{\max} = \max_i p_i' = \max_i \lfloor p_i/K \rfloor =
|
|
\max_i \lfloor p_i (1/\epsilon + 1)n / (\epsilon\, p_{\max}) \rfloor =
|
|
\lfloor (1/\epsilon + 1)n/\epsilon \cdot \epsilon \rfloor =
|
|
O(n/\epsilon)$.
|
|
|
|
Der Algorithmus \textsc{Knapsack} angewandt auf die skalierte Instanz
|
|
hat dann eine Laufzeit von
|
|
\[
|
|
O(n^2 p'_{\max}) = O(n^2\, n/\epsilon) = O(n^3/\epsilon).
|
|
\]
|
|
|
|
(b) zur G\"ute: Es gilt zun\"achst
|
|
\begin{equation}
|
|
\OPT(I) \leq K \cdot \OPT(I_K) + K \cdot n \tag{1}
|
|
\end{equation}
|
|
Da $p_i' = \lfloor p_i/K \rfloor \geq p_i/K - 1$, haben wir
|
|
$p_i \leq K \cdot (p_i' + 1)$ und deswegen haben wir
|
|
\begin{align*}
|
|
\OPT(I) = \sum_{i \in I_{\mathrm{opt}}} p_i
|
|
&\leq \sum_{i \in I_{\mathrm{opt}}} (K p_i' + K)\\
|
|
&\leq \sum_{i \in I_{\mathrm{opt}}} K p_i' + K \cdot n
|
|
\leq K \cdot \OPT(I_K) + K \cdot n
|
|
\end{align*}
|
|
Beachte, dass $I_{\mathrm{opt}}$ eine zul\"assige L\"osung von $I_K$ ist
|
|
und $(I_K)_{\mathrm{opt}}$ i.a.\ ein h\"oheren Gewinn als
|
|
$I_{\mathrm{opt}}$ bez\"uglich Instanz $I_K$ hat. Daneben gilt:
|
|
\begin{equation}
|
|
K \cdot \OPT(I_K) \leq A_K(I) \tag{2}
|
|
\end{equation}
|
|
Da $p_i' \leq p_i/K$ gilt
|
|
\begin{align*}
|
|
K \cdot \OPT(I_K) = K \cdot \sum_{i \in (I_K)_{\mathrm{opt}}} p_i'
|
|
&\leq K \cdot \sum_{i \in (I_K)_{\mathrm{opt}}} p_i/K\\
|
|
&= \sum_{i \in (I_K)_{\mathrm{opt}}} p_i \leq A_K(I).
|
|
\end{align*}
|
|
Aus (1) + (2) folgt
|
|
\[
|
|
\OPT(I) \leq A_K(I) + K \cdot n.
|
|
\]
|
|
Da alle $w_i \leq B$ (ansonsten kann Gegenstand $i$ aus der Instanz
|
|
gel\"oscht werden), gilt $\OPT(I) \geq p_{\max} = \max_i p_i$.
|
|
|
|
Wir erhalten
|
|
\begin{align*}
|
|
\frac{\OPT(I)}{A_\epsilon(I)} \leq \frac{A_K(I) + Kn}{A_K(I)}
|
|
= 1 + \frac{Kn}{A_K(I)}
|
|
&\leq 1 + \frac{Kn}{\OPT(I) - Kn}\\
|
|
&\leq 1 + \frac{Kn}{p_{\max} - Kn} = 1 + \epsilon.
|
|
\end{align*}
|
|
Die letzte Gleichung gilt, da
|
|
\[
|
|
\frac{Kn}{p_{\max} - Kn}
|
|
= \frac{\frac{p_{\max}}{(1/\epsilon+1)n} \cdot n}
|
|
{p_{\max} - \frac{p_{\max}}{(1/\epsilon+1)n}\, n}
|
|
= \frac{\frac{1}{(1/\epsilon+1)}}{1 - \frac{1}{(1/\epsilon+1)}}
|
|
= \frac{\frac{1}{1/\epsilon+1}}{\frac{1/\epsilon+1-1}{1/\epsilon+1}}
|
|
= \frac{1}{1/\epsilon} = \epsilon. \qedhere
|
|
\]
|
|
\end{proof}
|
|
|
|
\paragraph{Weitere Approximationsschema}
|
|
\begin{itemize}
|
|
\item $O(n^2/\epsilon)$ (Ibarra und Kim 1975).
|
|
\item $O(n \log(1/\epsilon) + 1/\epsilon^4)$ (Lawler 1979).
|
|
\item $O(n \min\{\log n, \log(1/\epsilon)\} + 1/\epsilon^2
|
|
\log(1/\epsilon) \min\{n, 1/\epsilon \log(1/\epsilon)\})$
|
|
(Kellerer, Pferschy 2004).
|
|
\item $\tilde{O}(n + (1/\epsilon)^{5/2})$ (Rhee 2015).
|
|
\item $\tilde{O}(n + (1/\epsilon)^{12/5})$ (Chan 2018).
|
|
\item $\tilde{O}(n + (1/\epsilon)^{9/4})$ (Jin 2019).
|
|
\end{itemize}
|
|
In der $\tilde{O}$ Notation vernachl\"assigt man $\log(.)$-Terme in der
|
|
Laufzeit.
|
|
|
|
\begin{bemerkung}
|
|
Es gibt kein FPTAS mit einer Laufzeit $O((n + 1/\epsilon)^{2-\delta})$,
|
|
au\ss er $(\min,+)$ Convolution hat einen Algorithmus mit einer
|
|
subquadratischen Laufzeit (Cygan u.a.\ 2017 bzw.\ K\"unnemann u.a.\
|
|
2017).
|
|
\end{bemerkung}
|
|
|
|
\section{Scheduling}
|
|
|
|
Der Begriff Scheduling beschreibt die Problematik der Erstellung eines
|
|
Ablaufplans bzw.\ Schedules, der Prozessen zeitlich begrenzt Ressourcen,
|
|
wie etwa Maschinen bzw.\ Prozessoren oder Speicher, zuteilt. Dabei
|
|
untersucht man die Optimierung bzw.\ Approximation diverser
|
|
Zielfunktionen. Eine klassische Variante wird formal als $P||C_{\max}$
|
|
angegeben und l\"asst sich wie folgt formulieren.
|
|
|
|
\begin{description}
|
|
\item[Gegeben:] $n$ Jobs $J = \{J_1, \dots, J_n\}$ mit
|
|
Ausf\"uhrungszeiten $p_1, \dots, p_n \in \mathbb{N}$ und $m$
|
|
identische Maschinen.
|
|
\item[Gesucht:] Partition von $J$ in $m$ Teilmengen
|
|
$B_1, \dots, B_m$ mit minimaler maximaler Last
|
|
\[
|
|
C_{\max} = \max_{1 \leq i \leq m} \sum_{J_j \in B_i} p_j.
|
|
\]
|
|
\end{description}
|
|
|
|
Den Wert $C_{\max}$ nennt man auch den \emph{Makespan} des Schedules. Das
|
|
Problem wird bezeichnet durch $P||C_{\max}$ bzw.\ $Pm||C_{\max}$, wenn
|
|
die Anzahl der Maschinen $m$ konstant ist. Im Folgenden betrachten wir
|
|
eine Instanz f\"ur das Schedulingproblem $P||C_{\max}$:
|
|
|
|
\begin{table}[h]
|
|
\begin{center}
|
|
\begin{tabular}{c|ccccc}
|
|
$J_j$ & $J_1$ & $J_2$ & $J_3$ & $J_4$ & $J_5$\\
|
|
\hline
|
|
$p_j$ & 1 & 2 & 1 & 3 & 1
|
|
\end{tabular}\\[4pt]
|
|
$m = 2$
|
|
\end{center}
|
|
\caption{Schedulinginstanz}
|
|
\end{table}
|
|
|
|
F\"ur diese Instanz mit zwei Maschinen k\"onnen wir etwa die beiden
|
|
folgenden Ablaufpl\"ane/Schedules als zul\"assig erkennen:
|
|
\begin{itemize}
|
|
\item $B_1 = \{J_1, J_2, J_5\}$, $B_2 = \{J_4, J_5\}$ mit Makespan 4.
|
|
% Anm.: so im Original; gemaess Abbildung ist B1 = {J1, J2, J3},
|
|
% B2 = {J4, J5} gemeint.
|
|
|
|
\begin{center}
|
|
\abbtext{Gantt-Diagramm mit zwei Maschinen: $M_1$ f\"uhrt $J_1$ ($0$--$1$), $J_2$ ($1$--$3$), $J_3$ ($3$--$4$) aus; $M_2$ f\"uhrt $J_4$ ($0$--$3$), $J_5$ ($3$--$4$) aus. Makespan $4$.}
|
|
\end{center}
|
|
|
|
\item $B_1 = \{J_1, J_3, J_4\}$, $B_2 = \{J_2, J_5\}$ mit Makespan 5.
|
|
|
|
\begin{center}
|
|
\abbtext{Gantt-Diagramm mit zwei Maschinen: $M_1$ f\"uhrt $J_1$ ($0$--$1$), $J_3$ ($1$--$2$), $J_4$ ($2$--$5$) aus; $M_2$ f\"uhrt $J_2$ ($0$--$2$), $J_5$ ($2$--$3$) aus. Makespan $5$.}
|
|
\end{center}
|
|
\end{itemize}
|
|
|
|
Man erkennt leicht, dass der erste Ablaufplan ein optimaler Ablaufplan
|
|
ist. Der optimale Makespan ist also 4. Wie schwer ist nun dieses Problem?
|
|
Der folgende Satz gibt uns Auskunft.
|
|
|
|
\begin{satz}
|
|
Das Schedulingproblem auf identischen Maschinen $Pm||C_{\max}$ ist
|
|
$\NP$-vollst\"andig sogar f\"ur $m = 2$ Maschinen.
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
Dies folgt durch eine Reduktion des Partitionsproblems.
|
|
\end{proof}
|
|
|
|
Man mache sich klar, dass daraus unmittelbar auch die
|
|
$\NP$-Vollst\"andigkeit von $P||C_{\max}$ folgt. Wir wollen nun einen
|
|
ersten Approximationsalgorithmus studieren, den wir
|
|
\textsc{ListScheduling} nennen.
|
|
|
|
\begin{quote}
|
|
\begin{alltt}
|
|
\textbf{Algorithmus} ListScheduling(L=(\(J\sb{1}\),...,\(J\sb{n}\)),m)
|
|
1 for i=1 to m do
|
|
2 \(E\sb{i} = 0\); \(B\sb{i} = \emptyset\);
|
|
3 od
|
|
4 for j=1 to n do
|
|
5 w\"ahle Job \(J\sb{j}\) aus Liste L;
|
|
6 w\"ahle Maschine \(M\sb{i}\) mit minimaler Last \(E\sb{i}\);
|
|
7 \(B\sb{i} = B\sb{i} \cup \{J\sb{j}\}\);
|
|
8 \(E\sb{i} = E\sb{i} + p\sb{j}\);
|
|
9 od
|
|
\end{alltt}
|
|
\end{quote}
|
|
|
|
Es sei $LS(I)$ die L\"ange eines List Schedules und $\OPT(I)$ die
|
|
L\"ange eines optimalen Schedules zur Eingabe $I$.
|
|
|
|
\begin{satz}\leavevmode
|
|
\begin{enumerate}
|
|
\item[(a)] F\"ur alle Eingaben $I = (L,m)$ gilt
|
|
$LS(I)/\OPT(I) \leq 2 - 1/m$.
|
|
\item[(b)] Es existiert eine Eingabe $I^{*}$ mit
|
|
$LS(I^{*}) = (2 - 1/m)\OPT(I^{*})$. Der Algorithmus hat also eine
|
|
multiplikative G\"ute bzw.\ absolute Worst Case G\"ute von
|
|
$2 - 1/m$.
|
|
\end{enumerate}
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
Zu (a): O.B.d.A.\ hat Maschine $M_1$ nach der Zuordnung die h\"ochste
|
|
Last $L = \sum_{j \in B_1} p_j$ (ansonsten nummeriere die Maschinen um).
|
|
Es sei $J_k$ der letzte Job, der auf Maschine $M_1$ fertig wird. Dann
|
|
haben alle Maschinen eine Last $L_i \geq L - p_k$. Zu dem Zeitpunkt, wo
|
|
$J_k$ der Maschine $M_1$ zugeordnet wurde, hatte $M_1$ die kleinste Last
|
|
$L - p_k$. Wir illustrieren dies in Abb.~\ref{abb:ls}.
|
|
|
|
\begin{figure}[h]
|
|
\begin{center}
|
|
\abbtext{Gantt-Diagramm der Maschinen $M_1,\dots,M_m$: $M_1$ endet mit dem Job $J_k$ zum Zeitpunkt $L$; alle anderen Maschinen haben eine Last von mindestens $L-p_k$. Gestrichelte Linien markieren die Zeitpunkte $L-p_k$ und $L$.}
|
|
\end{center}
|
|
\caption{Maschine $M_1$ hat mit $J_k$ bzw.\ ohne $J_k$ die gr\"o\ss te
|
|
Last bzw.\ kleinste Last}\label{abb:ls}
|
|
\end{figure}
|
|
|
|
Daraus folgt sofort die folgende Absch\"atzung:
|
|
\[
|
|
\sum_{i=1}^{n} p_i \geq m(L - p_k) + p_k.
|
|
\]
|
|
Daneben gilt (da die gesamte Last $\sum p_i$ auf $m$ Maschinen verteilt
|
|
werden muss und mindestens eine Maschine eine Last $\geq \sum p_i/m$
|
|
hat):
|
|
\[
|
|
\sum_{i=1}^{n} p_i/m \leq \OPT(I).
|
|
\]
|
|
Da nun $LS(I) = L$ ist, gilt
|
|
\begin{align*}
|
|
\OPT(I) \geq \sum_{i=1}^{n} p_i/m &\geq m(L - p_k)/m + p_k/m\\
|
|
&= L - (1 - 1/m)p_k = LS(I) - (1 - 1/m)p_k
|
|
\end{align*}
|
|
Da $\OPT(I) \geq p_k$ folgt nun
|
|
$\OPT(I) \geq LS(I) - (1 - 1/m)\OPT(I)$ bzw.
|
|
\[
|
|
LS(I) \leq (2 - 1/m)\OPT(I).
|
|
\]
|
|
|
|
Zu (b): zur \"Ubung.
|
|
\end{proof}
|
|
|
|
Wir haben gesehen, dass ein erstaunlich einfacher Algorithmus schon eine
|
|
G\"ute von 2 garantieren kann. Allerdings f\"allt auf, dass die
|
|
beliebige Wahl des n\"achsten Jobs (in Zeile 5) mitunter schlecht sein
|
|
kann. Es scheint besser zu sein, die Jobs absteigend ihrer
|
|
Ausf\"uhrungszeit nach zu plazieren, was uns zum folgenden Algorithmus
|
|
\textsc{LPT Scheduling} f\"uhrt.
|
|
|
|
\begin{quote}
|
|
\begin{alltt}
|
|
\textbf{Algorithmus} LPT Scheduling(I=(J,m))
|
|
1 sortiere die Jobs in J so, dass \(p\sb{1} \geq p\sb{2} \ldots \geq p\sb{n}\);
|
|
2 wende den List Scheduling Algorithmus an auf I=(L,m)
|
|
mit L=(\(J\sb{1}\),...,\(J\sb{n}\))
|
|
\end{alltt}
|
|
\end{quote}
|
|
|
|
Es sei $LPT(I)$ die L\"ange eines LPT Schedules bez\"uglich einer
|
|
Eingabe $I = (J,m)$.
|
|
|
|
\begin{satz}
|
|
Der LPT Algorithmus hat eine absolute Worst Case Rate von
|
|
$4/3 - 1/(3m)$; d.h.
|
|
\begin{equation}
|
|
LPT(I) \leq (4/3 - 1/(3m))\OPT(I). \tag{$*$}
|
|
\end{equation}
|
|
\end{satz}
|
|
|
|
\begin{proof}
|
|
\emph{Annahme:} Es existiert eine Jobmenge $J$ und Maschinenzahl $m$,
|
|
die die Behauptung $(*)$ nicht erf\"ullt. Der Satz gilt sofort f\"ur
|
|
$m = 1$ (in diesem Fall gilt n\"amlich $LPT(I) = \OPT(I)$). Daher nehmen
|
|
wir an: $m \geq 2$ und $n$ ist minimal (d.h.\ wir haben ein minimales
|
|
Gegenbeispiel).
|
|
|
|
\emph{Annahme:} Es existiert ein Job $J_r$ mit $r < n$, f\"ur den die
|
|
Fertigstellungszeit $f_r = LPT(I = (J,m))$ gilt. Betrachte
|
|
$J' = \{J_1, \dots, J_r\}$ mit Liste $L' = (J_1, \dots, J_r)$. Dann gilt
|
|
$LPT(I = (J,m)) = LPT(I' = (J',m))$ und der optimale Wert
|
|
$\OPT(I') \leq \OPT(I)$. Damit haben wir
|
|
\[
|
|
\frac{LPT(I')}{\OPT(I')} \geq \frac{LPT(I)}{\OPT(I)} > 4/3 - 1/(3m)
|
|
\]
|
|
ein kleineres Gegenbeispiel gefunden. Widerspruch zur Minimalit\"at von
|
|
$n$.
|
|
|
|
Es gilt also $f_k < LPT(I = (J,m))$ f\"ur alle $k < n$. Desweiteren
|
|
haben wir die Ungleichungen:
|
|
\begin{align}
|
|
\OPT(I) &\geq \frac{1}{m}\sum_{i=1}^{n} p_i \tag{1}\\
|
|
\sum_{i=1}^{n-1} p_i &\geq m s_n = m(LPT(I) - p_n), \tag{2}
|
|
\end{align}
|
|
wobei $s_n$ der Startzeitpunkt von Job $J_n$ ist.
|
|
|
|
\begin{center}
|
|
\abbtext{Gantt-Diagramm: alle $m$ Maschinen sind bis zum Startzeitpunkt $s_n$ l\"uckenlos mit den Jobs $J_1,\dots,J_{n-1}$ besch\"aftigt; anschlie\ss end l\"auft $J_n$ (L\"ange $p_n$) bis zum Zeitpunkt $LPT(J)$.}
|
|
\end{center}
|
|
|
|
\emph{Beachte:} Alle Maschinen sind bis zum Zeitpunkt $s_n$ voll
|
|
besch\"aftigt (d.h.\ keine Maschine ist idle vor dem Zeitpunkt $s_n$).
|
|
\begin{align*}
|
|
\frac{LPT(I)}{\OPT(I)} = \frac{s_n + p_n}{\OPT(I)}
|
|
&\leq_{(2)} \frac{p_n}{\OPT(I)} +
|
|
\frac{1}{m\,\OPT(I)}\sum_{i=1}^{n-1} p_i\\
|
|
&= \frac{(m-1)p_n}{m\,\OPT(I)} +
|
|
\frac{1}{m\,\OPT(I)}\sum_{i=1}^{n} p_i\\
|
|
&\leq_{(1)} \frac{(m-1)p_n}{m\,\OPT(I)} + 1.
|
|
\end{align*}
|
|
Da $(*)$ f\"ur $I$ nicht gilt, folgt
|
|
\[
|
|
1 + \frac{(m-1)p_n}{m\,\OPT(I)} \geq \frac{LPT(I)}{\OPT(I)}
|
|
> 4/3 - 1/(3m).
|
|
\]
|
|
Daraus folgt
|
|
\[
|
|
\frac{(m-1)p_n}{m\,\OPT(I)} > 1/3 - 1/(3m) = \frac{m-1}{3m}
|
|
\quad\text{bzw.}\quad
|
|
p_n > \frac{\OPT(I)}{3}.
|
|
\]
|
|
(d.h.\ der kleinste Job $J_n$ ist gr\"o\ss er als $\OPT(I)/3$). Daraus
|
|
folgt, dass keine Maschine in einem optimalen Schedule mehr als 2 Jobs
|
|
ausf\"uhren kann.
|
|
|
|
Als n\"achstes transformieren wir einen optimalen Schedule
|
|
$D_{\mathrm{opt}}$ f\"ur solch eine Jobmenge mit $p_n > \OPT(I)/3$ in
|
|
einen Schedule $\bar{D}_{\mathrm{opt}}$, der zus\"atzliche Eigenschaften
|
|
erf\"ullt.
|
|
|
|
\paragraph{Transformation I.1 f\"ur $D_{\mathrm{opt}}$.} Gegeben sei ein
|
|
Schedule $D_{\mathrm{opt}}$ mit Makespan $C_{\max}$ und zwei Jobs $J_i$
|
|
und $J_{i'}$ auf einer Maschine und zwei Jobs $J_j$ und $J_{j'}$ auf
|
|
einer anderen Maschine, wobei $p_i > p_j$ und $p_{i'} > p_{j'}$ ist.
|
|
|
|
% --- Skizze Transformation I.1 ---
|
|
\begin{center}
|
|
\abbtext{Zwei Maschinen: oben $J_i$ gefolgt von $J_{i'}$, unten $J_j$ gefolgt von $J_{j'}$, mit $p_i > p_j$ und $p_{i'} > p_{j'}$.}
|
|
\end{center}
|
|
|
|
Wenn wir $J_{i'}$ und $J_{j'}$ vertauschen, so erhalten wir den
|
|
folgenden Schedule $D'_{\mathrm{opt}}$ mit Makespan
|
|
$C'_{\max} \leq C_{\max}$:
|
|
|
|
\begin{center}
|
|
\abbtext{Nach dem Tausch von $J_{i'}$ und $J_{j'}$: oben $J_i$ gefolgt von $J_{j'}$, unten $J_j$ gefolgt von $J_{i'}$; der Makespan wird dadurch nicht gr\"o\ss er.}
|
|
\end{center}
|
|
|
|
\paragraph{Transformation I.2 f\"ur $D_{\mathrm{opt}}$.} Gegeben sei ein
|
|
Schedule $D_{\mathrm{opt}}$ mit Makespan $C_{\max}$ und zwei Jobs $J_i$
|
|
und $J_{i'}$ auf einer Maschine und ein Job $J_j$ auf einer anderen
|
|
Maschine, wobei $p_i > p_j$ ist.
|
|
|
|
Wenn wir den Job $J_{i'}$ auf die andere Maschine verschieben, so
|
|
erhalten wir einen Schedule $D'_{\mathrm{opt}}$ ebenso mit Makespan
|
|
$C'_{\max} \leq C_{\max}$:
|
|
|
|
\begin{center}
|
|
\abbtext{Oben $J_i$ gefolgt von $J_{i'}$, unten nur $J_j$ (mit $p_i > p_j$); der Job $J_{i'}$ wird auf die untere Maschine verschoben.}
|
|
\end{center}
|
|
|
|
\paragraph{Transformation II f\"ur $D_{\mathrm{opt}}$.} Gegeben sei ein
|
|
Schedule $D_{\mathrm{opt}}$ mit Makespan $C_{\max}$ und zwei Jobs $J_i$
|
|
und $J_{i'}$ auf einer Maschine mit $p_i < p_j$. In diesem Fall
|
|
vertauschen wir die Reihenfolge beider Jobs auf der entsprechenden
|
|
Maschine:
|
|
|
|
\begin{center}
|
|
\abbtext{Eine Maschine mit $J_i$ vor $J_j$ und $p_i < p_j$; die Reihenfolge der beiden Jobs auf der Maschine wird vertauscht.}
|
|
\end{center}
|
|
|
|
\emph{Beachte:} Keine der Transformationstypen I.1, I.2 oder II erh\"oht
|
|
den Makespan.
|
|
|
|
\begin{definition}[Lastfunktion]
|
|
Bei gegebenen Lastwerten $L_i$ auf den Maschinen $M_i$ in einem Schedule
|
|
$D$ ist die Lastfunktion
|
|
$L(D) = \sum_{1 \leq i < j \leq m} |L_i - L_j|$.
|
|
\end{definition}
|
|
|
|
\begin{bemerkung}\leavevmode
|
|
\begin{enumerate}
|
|
\item[(1)] Erhalten wir einen Schedule $D'$ aus $D$ durch eine Type I
|
|
Transformation, so gilt $L(D') < L(D)$.
|
|
\item[(2)] Erhalten wir einen Schedule $D'$ aus $D$ durch eine Type II
|
|
Transformation, so gilt $L(D') = L(D)$.
|
|
\end{enumerate}
|
|
\end{bemerkung}
|
|
|
|
Wir wenden nun auf $D_{\mathrm{opt}}$ alle m\"oglichen Type I und Type
|
|
II Transformationen an, bis keine Transformation mehr anwendbar ist. Es
|
|
sei $D^{*}$ der erzeugte Schedule. Ein solcher Schedule existiert, da
|
|
\begin{enumerate}
|
|
\item[(1)] es nur endlich viele Anordnungen von $n$ Jobs auf $m$
|
|
Maschinen gibt,
|
|
\item[(2)] wir zwischen zwei Type I Transformationen nur endlich viele
|
|
Type II Transformationen einf\"ugen k\"onnen,
|
|
\item[(3)] wir wegen Eigenschaft (1) in der obigen Bemerkung nur
|
|
endlich viele Type I Transformationen ausf\"uhren k\"onnen.
|
|
\end{enumerate}
|
|
$D^{*}$ erf\"ullt die folgende Bedingung:
|
|
|
|
% --- PLATZHALTER: Skizze zu D* (drei Maschinen mit Ji,Ji', Jj,Jj', Jk) ---
|
|
\begin{center}
|
|
\fbox{\parbox{0.85\textwidth}{\small\emph{[Abbildung im Original: drei
|
|
Maschinen mit Jobs $J_i, J_{i'}$ auf der ersten, $J_j, J_{j'}$ auf der
|
|
zweiten und dem einzelnen Job $J_k$ auf der dritten Maschine.]}}}
|
|
\end{center}
|
|
|
|
Wenn wir zwei Jobs $J_i, J_{i'}$ auf einer Maschine, zwei Jobs
|
|
$J_j, J_{j'}$ auf einer zweiten Maschine und einen einzelnen Job $J_k$
|
|
auf einer dritten Maschine haben mit $p_i > p_j$, so folgt
|
|
\begin{equation}
|
|
\begin{aligned}
|
|
p_{j'} \geq p_{i'},\quad p_i \leq p_k,\quad p_i \geq p_{i'},\\
|
|
p_j \leq p_k,\quad p_j \geq p_{j'}.
|
|
\end{aligned}
|
|
\tag{$**$}
|
|
\end{equation}
|
|
Durch Umordnen der Maschinen in $D^{*}$ erhalten wir einen Schedule
|
|
$\bar{D}_{\mathrm{opt}}$:
|
|
|
|
% --- PLATZHALTER: Skizze zu D-bar-opt ---
|
|
\begin{center}
|
|
\fbox{\parbox{0.85\textwidth}{\small\emph{[Abbildung im Original:
|
|
Maschinen mit Einzeljobs $J_{k_1}, \dots, J_{k_s}$ oben und
|
|
Jobpaaren $(J_{i_1}, J_{i'_1}), \dots, (J_{i_t}, J_{i'_t})$ darunter.]}}}
|
|
\end{center}
|
|
|
|
Hierbei gelten die Ungleichungen $p_{k_1} \geq \dots \geq p_{k_s}$ sowie
|
|
$p_{i_1} \geq \dots \geq p_{i_t}$ und wegen $(**)$ haben wir
|
|
$p'_{i_1} \leq \dots \leq p'_{i_t}$ und $p_{k_s} \geq p_{i_1}$ sowie
|
|
$p_{i_t} \geq p'_{i_t}$. Damit haben wir die folgende Ordnung der Jobs:
|
|
\[
|
|
p_{k_1} \geq \dots \geq p_{k_s} \geq p_{i_1} \geq \dots \geq p_{i_t}
|
|
\geq p'_{i_t} \geq \dots \geq p'_{i_1}.
|
|
\]
|
|
Der Schedule $\bar{D}_{\mathrm{opt}}$ ist nun \"aquivalent zu einem List
|
|
Schedule $D_L$ bei gegebener Liste $L = (J_1, \dots, J_n)$ mit
|
|
$p_1 \geq \dots \geq p_n$ (bis auf Vertauschen von Jobs mit gleicher
|
|
Ausf\"uhrungszeit). Daraus folgt aber
|
|
\[
|
|
LPT(I = (J,m)) = \OPT(I = (J,m)).
|
|
\]
|
|
Wegen $LPT(I)/\OPT(I) > 4/3 - 1/(3m)$ erhalten wir nun aber einen
|
|
Widerspruch (d.h.\ es kann kein Gegenbeispiel f\"ur die Ungleichung
|
|
$(*)$ existieren).
|
|
\end{proof}
|
|
|
|
\begin{bemerkung}
|
|
F\"ur jede Anzahl $m$ von Maschinen existiert eine Eingabe
|
|
$I_m^{*} = (J^{*}, m)$ mit
|
|
\[
|
|
\frac{LPT(I_m^{*})}{\OPT(I_m^{*})} = \frac{4}{3} - \frac{1}{3m}.
|
|
\]
|
|
\end{bemerkung}
|
|
|
|
\begin{proof}
|
|
zur \"Ubung.
|
|
\end{proof}
|
|
|
|
\begin{satz}
|
|
F\"ur jede Genauigkeit $\epsilon > 0$ gibt es einen approximativen
|
|
Algorithmus $A_\epsilon$ f\"ur $P||C_{\max}$ mit
|
|
$A_\epsilon(I) \leq (1 + \epsilon)\OPT(I)$ und Laufzeit
|
|
$2^{O(1/\epsilon \log^2(1/\epsilon))} + O(n)$.
|
|
\end{satz}
|
|
|
|
\begin{bemerkung}
|
|
Eine Familie $(A_\epsilon)$ von solchen Algorithmen nennt man ein
|
|
(effizientes) polynomielles Approximationsschema (EPTAS).
|
|
\end{bemerkung}
|
|
|
|
Details: siehe Vorlesung Effiziente Algorithmen.
|
|
|
|
\subsection*{\"Ubungsaufgaben}
|
|
|
|
\begin{uebung}
|
|
Zeigen Sie:
|
|
\begin{itemize}
|
|
\item Ein zusammenh\"angender ungerichteter Graph $G = (V,E)$
|
|
enth\"alt eine Eulertour genau dann, wenn jeder Knoten in $V$
|
|
geraden Knotengrad hat.
|
|
\item Ein stark zusammenh\"angender gerichteter Graph $G = (V,E)$
|
|
enth\"alt eine Eulertour genau dann, wenn f\"ur jeden Knoten
|
|
$v \in V$ gilt, dass $d_{\mathrm{in}}(v) = d_{\mathrm{out}}(v)$.
|
|
\end{itemize}
|
|
\end{uebung}
|
|
|
|
\end{document}
|