2491 lines
107 KiB
TeX
2491 lines
107 KiB
TeX
\documentclass[11pt]{article}
|
|
\input{style_guide.tex}
|
|
|
|
\setlength{\parskip}{0.4em}
|
|
\setlength{\parindent}{0pt}
|
|
|
|
% Aufgabenkopf: #1 Nummer, #2 Titel, #3 Quelle+Punkte
|
|
\newcounter{aufg}
|
|
\newcommand{\katkopf}[2]{%
|
|
\stepcounter{aufg}%
|
|
\phantomsection\addcontentsline{toc}{subsection}{A\theaufg\ \ #1}%
|
|
\noindent{\setlength{\fboxsep}{6pt}\colorbox{aufgabeink}{\parbox{\dimexpr\linewidth-12pt\relax}{%
|
|
\color{white}\textbf{A\theaufg\quad #1}\hspace{1em}\hfill\mbox{\small #2}}}}\par\medskip}
|
|
\newcommand{\lsg}{\par\medskip\noindent{\color{loesgreen}\rule{\linewidth}{0.8pt}}\par\smallskip\noindent\textbf{Lösung.}\par\smallskip}
|
|
|
|
% Beispiel-Seite (eigene Seite, Teal-Kopf zur Abgrenzung vom Aufgabenkopf)
|
|
\newcommand{\bspkopf}[1]{\par\bigskip%
|
|
\noindent{\setlength{\fboxsep}{6pt}\colorbox{bspink}{\parbox{\dimexpr\linewidth-12pt\relax}{%
|
|
\color{white}\textbf{Beispiel\quad #1}}}}\par\medskip}
|
|
|
|
% Muster-Block: Amber-Kopf, dann Kurzsatz + Bulletliste
|
|
\definecolor{musterink}{HTML}{B45309}
|
|
\newcommand{\musterkopf}[1]{\par\medskip
|
|
\noindent{\setlength{\fboxsep}{6pt}\colorbox{musterink}{\parbox{\dimexpr\linewidth-12pt\relax}{%
|
|
\color{white}\textbf{Muster\quad #1}}}}\par\medskip}
|
|
|
|
\title{\textbf{\Huge Musterkatalog}\\[0.4em]
|
|
\large 25 Aufgaben, 26 Muster --- eine Pr\"asentator-Aufgabe je Muster\\
|
|
\normalsize \textit{Analyse von Algorithmen und Komplexit\"at} -- CAU Kiel}
|
|
\author{}
|
|
\date{}
|
|
|
|
\begin{document}
|
|
\maketitle
|
|
\thispagestyle{empty}
|
|
\tableofcontents
|
|
\newpage
|
|
|
|
% ##################################################################
|
|
\section{Beweismuster: einmal verstehen, überall anwenden}
|
|
% ##################################################################
|
|
|
|
% ==================================================================
|
|
\katkopf{Longest Path $\in$ NP (Dreischritt)}{Klausur SS23-H, A2, 3+3+4 P.}
|
|
\textbf{Problem \problem{Longest Path}:} Gegeben ein ungerichteter Graph
|
|
$G = (V,E)$ und eine Zahl $k$. Gibt es einen \emph{einfachen} Pfad in $G$
|
|
(kein Knoten wird doppelt besucht) mit Länge $\ge k$?
|
|
|
|
Zeigen Sie auf verschiedene Weisen, dass das Problem in NP liegt:
|
|
\begin{enumerate}
|
|
\item[a)] Geben Sie ein Zertifikat für \problem{Longest Path} an.
|
|
\item[b)] Beschreiben Sie einen Verifizierer für \problem{Longest Path} und
|
|
geben Sie dessen Laufzeit konkret an.
|
|
\item[c)] Beschreiben Sie eine nichtdeterministische Turing-Maschine (in
|
|
Worten), die \problem{Longest Path} löst. Geben Sie auch hier die Laufzeit
|
|
konkret an.
|
|
\end{enumerate}
|
|
|
|
\bspkopf{Longest Path $\in$ NP}
|
|
\textbf{Instanz.} Das folgende Viereck mit Schranke $k=3$ (gesucht: ein
|
|
einfacher Pfad mit $k{+}1=4$ Knoten).
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=1]
|
|
\node[knoten] (v1) at (0,2) {1};
|
|
\node[knoten] (v2) at (2,2) {2};
|
|
\node[knoten] (v3) at (2,0) {3};
|
|
\node[knoten] (v4) at (0,0) {4};
|
|
\draw[line width=1.6pt] (v1)--(v2) (v2)--(v3) (v3)--(v4);
|
|
\draw[thick] (v4)--(v1);
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
\textbf{Kern.} Zertifikat $(1,2,3,4)$ (fetter Pfad): alle vier Knoten sind
|
|
paarweise verschieden und jede der drei Pfadkanten existiert -- der
|
|
Verifizierer akzeptiert diesen einfachen Pfad der Länge $3 \ge k$. Der
|
|
Rechenweg der NTM, der genau diese Folge rät, akzeptiert.
|
|
|
|
|
|
\musterkopf{$X \in$ NP beweisen}
|
|
Ein Zertifikat wird geraten oder gegeben und in Polynomialzeit geprüft.
|
|
\begin{itemize}
|
|
\item Wähle das Zertifikat: die Lösung selbst (Pfad, Menge, Belegung).
|
|
\item Schreibe den Verifizierer als Schrittliste: Größe prüfen, Eigenschaften prüfen, sonst akzeptiere.
|
|
\item Korrektheit in zwei Sätzen: Ja-Instanz $\to$ akzeptiertes Zertifikat; Nein-Instanz $\to$ jede Prüfung schlägt fehl.
|
|
\item Laufzeit: jede Prüfung mit Operation und $O(\cdot)$.
|
|
\item Schluss: \glqq Also gilt $X \in \NP$.\grqq{} (NDTM-Variante: Zertifikat im ersten Schritt nichtdeterministisch raten.)
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{a)} Eine Folge von $k+1$ paarweise verschiedenen Knoten
|
|
$(v_0, \dots, v_k)$ -- der behauptete Pfad.
|
|
|
|
\textbf{b)} Eingabe: Graph $G = (V,E)$, Zahl $k$ und Zertifikat
|
|
$(v_0, \dots, v_k)$.
|
|
|
|
Der Verifizierer arbeitet wie folgt:
|
|
\begin{itemize}
|
|
\item Falls das Zertifikat nicht aus $k+1$ Knoten besteht, lehne ab.
|
|
\item Prüfe, ob alle $v_i$ paarweise verschieden sind; lehne sonst ab.
|
|
\item Prüfe für jedes $i < k$, ob $\{v_i, v_{i+1}\} \in E$ gilt; lehne sonst
|
|
ab.
|
|
\item Sonst akzeptiere.
|
|
\end{itemize}
|
|
\textbf{Korrektheit:} Hat $G$ einen einfachen Pfad der Länge $\ge k$, dann
|
|
sind seine ersten $k+1$ Knoten ein Zertifikat -- beide Prüfungen gelingen.
|
|
Hat $G$ keinen solchen Pfad, dann scheitert jedes Zertifikat an einer
|
|
Prüfung -- der Verifizierer lehnt ab.
|
|
|
|
\textbf{Laufzeit:} Paarweise Vergleiche $O(|V|^2)$, Kantenprüfungen $O(k)$ -- gesamt $O(|V|^2)$.
|
|
|
|
\textbf{c)} Die NTM arbeitet wie folgt:
|
|
\begin{itemize}
|
|
\item Rate nichtdeterministisch $k+1$ Knoten $v_0, \dots, v_k$.
|
|
\item Prüfe, ob alle geratenen Knoten paarweise verschieden sind; lehne sonst
|
|
ab.
|
|
\item Prüfe für jedes $i < k$, ob $\{v_i, v_{i+1}\} \in E$ gilt; lehne sonst
|
|
ab.
|
|
\item Sonst akzeptiere.
|
|
\end{itemize}
|
|
\textbf{Korrektheit:} Hat $G$ einen einfachen Pfad der Länge $\ge k$, dann rät
|
|
ein Rechenweg genau dessen erste $k+1$ Knoten und akzeptiert. Sonst scheitert
|
|
auf jedem Rechenweg eine Prüfung -- die NTM lehnt ab.
|
|
|
|
\textbf{Laufzeit:} Rateschritte $O(k)$, paarweise Vergleiche $O(|V|^2)$, Kantenprüfungen $O(k)$ -- gesamt $O(|V|^2)$.
|
|
|
|
Also gilt $\problem{Longest Path} \in \NP$. \hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{NDTM-Definition $\subseteq$ Verifizierer-Definition}{Klausur SS25-H, A2, 2+8 P.}
|
|
Sei $L \subseteq \Sigma^*$ eine Sprache, für die eine NDTM $M$ über einem
|
|
Alphabet $\Gamma \supset \Sigma$ und ein Polynom $T$ existieren, sodass $L$
|
|
von $M$ in nicht-deterministischer Zeit $T$ entschieden wird. Beweisen Sie:
|
|
Es existiert ein polynomieller Verifizierer für $L$.
|
|
\begin{enumerate}
|
|
\item[a)] Geben Sie dafür zunächst für die Sprache $L$, die durch die
|
|
folgende NDTM $M$ akzeptiert wird, einen polynomiellen Verifizierer an, der
|
|
in analoger Weise arbeitet. Die NDTM $M$ erhält als Eingabe einen
|
|
ungerichteten Graphen $G = (V,E)$ und eine Zahl $k \in \mathbb{N}_0$.
|
|
|
|
\smallskip
|
|
$M(G = (V,E),\ k)$
|
|
\begin{itemize}
|
|
\item[1.] Rate nichtdeterministisch eine Menge von Knoten $C \subseteq V$.
|
|
\item[2.] Für alle $\{u,v\} \in E$: Falls $u \notin C$ und $v \notin C$,
|
|
verwerfe.
|
|
\item[3.] Falls $|C| > k$, verwerfe.
|
|
\item[4.] Akzeptiere.
|
|
\end{itemize}
|
|
\item[b)] Führen Sie nun einen allgemeingültigen Beweis.
|
|
\end{enumerate}
|
|
|
|
\bspkopf{NDTM $\subseteq$ Verifizierer: VC am Dreieck, $k=2$}
|
|
\textbf{Instanz.} Das folgende Dreieck $G$ mit $k=2$:
|
|
\begin{center}
|
|
\begin{tikzpicture}
|
|
\node[kndick] (n1) at (90:1) {$1$};
|
|
\node[kndick] (n2) at (210:1) {$2$};
|
|
\node[knoten] (n3) at (330:1) {$3$};
|
|
\draw[very thick] (n1)--(n2);
|
|
\draw[thick] (n1)--(n3) (n2)--(n3);
|
|
\node[font=\footnotesize,align=center] at (0,-1.8)
|
|
{Zertifikat: Knotenmenge $C=\{1,2\}$\\ (Knoten $1,2$ hervorgehoben)};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
\textbf{Kern.} Die NDTM rät die Knotenmenge $C \subseteq V$; der
|
|
Verifizierer erhält $C$ als Zertifikat und prüft mit denselben Schritten
|
|
2--4 -- das Raten ist durch das Zertifikat ersetzt. Für $C=\{1,2\}$ ist
|
|
jede Kante durch $1$ oder $2$ gedeckt und $|C|=2\le k$ -- er akzeptiert.
|
|
|
|
|
|
\musterkopf{Zertifikat $\leftrightarrow$ Rechenweg}
|
|
Übersetzt zwischen den zwei NP-Definitionen: nichtdeterministische Entscheidungen und Zertifikat sind dasselbe Objekt.
|
|
\begin{itemize}
|
|
\item Richtung NDTM $\to$ Verifizierer: Zertifikat $=$ Folge der nichtdeterministischen Entscheidungen.
|
|
\item Der Verifizierer simuliert die NDTM deterministisch entlang dieser Folge.
|
|
\item Rückrichtung Verifizierer $\to$ NDTM (analog): rate das Zertifikat, simuliere dann den Verifizierer.
|
|
\item Korrektheit: akzeptierender Rechenweg $\leftrightarrow$ akzeptiertes Zertifikat.
|
|
\item Laufzeit: Simulation Schritt für Schritt, bleibt polynomiell.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{a)} Eingabe: Graph $G = (V,E)$, Zahl $k$ und Zertifikat $c$: eine
|
|
Knotenmenge $C \subseteq V$.
|
|
|
|
Der Verifizierer $V(G, k;\ c)$ arbeitet wie folgt:
|
|
\begin{itemize}
|
|
\item[1.] Für alle $\{u,v\} \in E$: Falls $u \notin C$ und $v \notin C$,
|
|
verwerfe.
|
|
\item[2.] Falls $|C| > k$, verwerfe.
|
|
\item[3.] Akzeptiere.
|
|
\end{itemize}
|
|
Das Raten ist durch das Zertifikat ersetzt. Die Prüfschritte sind identisch
|
|
zu den Schritten 2--4 der NDTM. \textbf{Laufzeit:} Jede Kante prüfen und $|C|$ zählen --
|
|
$O(|V| + |E|)$.
|
|
|
|
\textbf{b)} Sei $L$ von der NDTM $M$ in nicht-deterministischer Zeit $T$
|
|
akzeptiert.
|
|
|
|
Eingabe: Wort $x$ und als Zertifikat eine Folge $c$ von höchstens $T(|x|)$
|
|
nichtdeterministischen Entscheidungen.
|
|
|
|
Der Verifizierer $V(x, c)$ arbeitet wie folgt:
|
|
\begin{itemize}
|
|
\item Simuliere $M$ auf $x$ deterministisch, höchstens $T(|x|)$ Schritte.
|
|
\item Bei jedem Schritt mit mehreren möglichen Übergängen wähle den Übergang,
|
|
den die Entscheidungsfolge $c$ vorgibt.
|
|
\item Falls die Simulation akzeptierend endet, akzeptiere.
|
|
\item Sonst lehne ab.
|
|
\end{itemize}
|
|
|
|
\textbf{Korrektheit:} Ist $x \in L$, dann hat $M$ einen akzeptierenden
|
|
Rechenweg mit höchstens $T(|x|)$ Schritten. Seine Entscheidungsfolge ist ein
|
|
Zertifikat, das $V$ akzeptiert.
|
|
|
|
Ist $x \notin L$, dann akzeptiert kein Rechenweg von $M$. Jede
|
|
Entscheidungsfolge steuert die Simulation einen Rechenweg von $M$ entlang --
|
|
$V$ lehnt jedes Zertifikat ab.
|
|
|
|
\textbf{Laufzeit:} Höchstens $T(|x|)$ Simulationsschritte mit konstantem
|
|
Aufwand pro Schritt -- $O(T(|x|))$, polynomiell. Das Zertifikat umfasst
|
|
höchstens $T(|x|)$ Entscheidungen -- polynomiell viele. Somit ist $V$ ein
|
|
polynomieller Verifizierer für $L$. \hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{Vererbung der NP-Vollständigkeit}{Vorlesung (Skript)}
|
|
Zeigen Sie: Ist $L_0$ NP-vollständig, gilt $L_0 \redp L_1$ und ist
|
|
$L_1 \in \NP$, so ist auch $L_1$ NP-vollständig.
|
|
|
|
\emph{Hinweis:} Die Relation $\redp$ ist transitiv.
|
|
|
|
\bspkopf{Vererbung: von VertexCover zu FeedbackVertexSet}
|
|
\textbf{Instanz.} $L_0 = \problem{VertexCover}$ (NP-vollständig),
|
|
$L_1 = \problem{FeedbackVertexSet} \in \NP$; die Reduktion
|
|
$\problem{VertexCover} \redp \problem{FeedbackVertexSet}$ macht jede Kante
|
|
zu zwei antiparallelen Bögen:
|
|
\begin{center}
|
|
\begin{tikzpicture}
|
|
\begin{scope}
|
|
\node[knoten] (a1) at (0,0) {1};
|
|
\node[kndick] (a2) at (1.5,0) {2};
|
|
\node[knoten] (a3) at (3,0) {3};
|
|
\draw (a1)--(a2) (a2)--(a3);
|
|
\node[font=\footnotesize] at (1.5,-1.0) {VC-Instanz, $k=1$};
|
|
\end{scope}
|
|
\draw[->,thick] (3.9,0) -- (5.3,0);
|
|
\begin{scope}[xshift=6.2cm]
|
|
\node[knoten] (b1) at (0,0) {1};
|
|
\node[kndick] (b2) at (1.5,0) {2};
|
|
\node[knoten] (b3) at (3,0) {3};
|
|
\draw[->] (b1) to[bend left=35] (b2);
|
|
\draw[->] (b2) to[bend left=35] (b1);
|
|
\draw[->] (b2) to[bend left=35] (b3);
|
|
\draw[->] (b3) to[bend left=35] (b2);
|
|
\node[font=\footnotesize] at (1.5,-1.0) {FVS-Instanz, $k=1$};
|
|
\end{scope}
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
\textbf{Kern.} Jedes $L \in \NP$ reduziert auf \problem{VertexCover},
|
|
und mit $\problem{VertexCover} \redp \problem{FeedbackVertexSet}$ folgt per
|
|
Transitivität $L \redp \problem{FeedbackVertexSet}$. Also ist
|
|
\problem{FeedbackVertexSet} NP-schwer und wegen
|
|
$\problem{FeedbackVertexSet} \in \NP$ NP-vollständig.
|
|
|
|
|
|
\musterkopf{Reduktionen verketten}
|
|
Meta-Beweise über NP: bekannte Reduktionen einsetzen und verketten, nie neu konstruieren.
|
|
\begin{itemize}
|
|
\item Schreibe die Voraussetzungen als Reduktionen hin ($L' \redp L$, $L \redp X$, $L \in P$, \dots).
|
|
\item Verkette per Transitivität von $\redp$: $f \circ g$ ist wieder eine Reduktion -- Polynom in Polynom bleibt Polynom.
|
|
\item Folgere die Behauptung Definition für Definition.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
Zu zeigen sind die beiden Teile der NP-Vollständigkeit: $L_1 \in \NP$ (gilt
|
|
nach Voraussetzung) und $L \redp L_1$ für \emph{jedes} $L \in \NP$.
|
|
|
|
\textbf{Beweis der NP-Schwere:} Sei $L \in \NP$ beliebig.
|
|
\begin{itemize}
|
|
\item Da $L_0$ NP-vollständig ist, reduziert jedes NP-Problem auf $L_0$ --
|
|
insbesondere $L \redp L_0$.
|
|
\item Nach Voraussetzung gilt $L_0 \redp L_1$.
|
|
\item Da $\redp$ transitiv ist, folgt $L \redp L_1$.
|
|
\end{itemize}
|
|
Da $L$ beliebig gewählt war, reduziert jedes NP-Problem auf $L_1$ -- $L_1$
|
|
ist NP-schwer. Zusammen mit $L_1 \in \NP$ ist $L_1$ NP-vollständig.
|
|
\hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{$k$-Clique ist NP-vollständig}{Klausuren SS23-H A4 und SS24-H A2, je 10 P.}
|
|
\textbf{Problem $k$-\problem{Clique}:}\\
|
|
\textbf{Eingabe:} Ein ungerichteter Graph $G = (V,E)$ und eine Zahl
|
|
$k \ge 1$. Eine Clique ist eine Teilmenge $C \subseteq V$ mit
|
|
$\{u,v\} \in E$ für alle $u,v \in C$ mit $u \ne v$.\\
|
|
\textbf{Entscheide:} Hat der gegebene Graph $G$ eine Clique $C \subseteq V$
|
|
mit mindestens $k$ Knoten (d.\,h.\ mit $|C| \ge k$)?
|
|
|
|
Beweisen Sie: Das Problem $k$-\problem{Clique} ist NP-vollständig.
|
|
\emph{Hinweis: Die Reduktion geht von allgemeinem SAT aus -- NICHT von 3-SAT.}
|
|
|
|
\bspkopf{$k$-Clique: Reduktionsgraph und Zertifikat}
|
|
\textbf{Instanz.} $F_1=(x\vee y),\ F_2=(\neg x\vee z),
|
|
\ F_3=(\neg y\vee\neg z)$, $k=m=3$.
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.85]
|
|
\node[kndick,font=\small] (x) at (-0.9,1.6) {$x$};
|
|
\node[knoten,font=\small] (y) at (0.9,1.6) {$y$};
|
|
\node[knoten,font=\small] (nx) at (-2.4,-0.2) {$\neg x$};
|
|
\node[kndick,font=\small] (z) at (-2.4,-1.6) {$z$};
|
|
\node[kndick,font=\small] (ny) at (2.4,-1.6) {$\neg y$};
|
|
\node[knoten,font=\small] (nz) at (2.4,-0.2) {$\neg z$};
|
|
\draw[black!50] (x)--(nz) (y)--(nx) (y)--(z) (y)--(nz) (nx)--(ny) (nx)--(nz);
|
|
\draw[very thick] (x)--(z) (x)--(ny) (z)--(ny);
|
|
\draw[dashed,black!60,rounded corners] (-1.55,1.05) rectangle (1.55,2.15);
|
|
\draw[dashed,black!60,rounded corners] (-3.05,-2.25) rectangle (-1.75,0.45);
|
|
\draw[dashed,black!60,rounded corners] (1.75,-2.25) rectangle (3.05,0.45);
|
|
\node[font=\footnotesize,black!60] at (0,2.4) {$F_1$};
|
|
\node[font=\footnotesize,black!60] at (-2.4,0.75) {$F_2$};
|
|
\node[font=\footnotesize,black!60] at (2.4,0.75) {$F_3$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
\textbf{Kern.} Je Literalvorkommen ein Knoten. Kanten verbinden Literale
|
|
verschiedener Klauseln, die sich nicht widersprechen. Die Belegung
|
|
$x=z=\true$, $y=\false$ macht pro Klausel ein Literal wahr -- deren
|
|
Knoten $\{x,z,\neg y\}$ sind die fette $3$-Clique und das akzeptierte
|
|
Zertifikat.
|
|
|
|
|
|
\musterkopf{Reduktions-Gerüst (NP-Vollständigkeit)}
|
|
Das Gerüst jedes NP-Vollständigkeits-Beweises -- die Konstruktion wechselt, das Gerüst nie.
|
|
\begin{itemize}
|
|
\item Teil 1: $X \in \NP$ (Muster \glqq$X \in$ NP beweisen\grqq, kurz).
|
|
\item Teil 2: bekanntes NP-vollständiges Problem wählen, Konstruktion $\textsc{Bekannt} \redp X$ angeben.
|
|
\item Beweis hin: aus einer Lösung von \textsc{Bekannt} eine Lösung von $X$ bauen.
|
|
\item Beweis zurück: aus einer Lösung von $X$ eine Lösung von \textsc{Bekannt} gewinnen.
|
|
\item Laufzeit der Transformation: Operation $+$ $O(\cdot)$.
|
|
\item Schluss: $X \in \NP$ und NP-schwer $\Rightarrow$ NP-vollständig.
|
|
\end{itemize}
|
|
\musterkopf{Auswahl-Graph}
|
|
Konstruktion für \glqq wähle je Gruppe einen Vertreter\grqq: Knoten $=$ Möglichkeiten, Kanten $=$ Verträglichkeit.
|
|
\begin{itemize}
|
|
\item Pro Gruppe (Klausel) ein Knoten je Möglichkeit (Literalvorkommen).
|
|
\item Kante zwischen zwei Knoten, wenn sie gemeinsam wählbar sind -- nie innerhalb einer Gruppe.
|
|
\item Ziel $k$ $=$ Anzahl der Gruppen.
|
|
\item Lösung $\leftrightarrow$ Clique: je Gruppe ein Vertreter, paarweise verträglich.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{$\in$ NP:} Eingabe: Graph $G = (V,E)$, Zahl $k$ und Zertifikat
|
|
$C \subseteq V$.
|
|
|
|
Der Verifizierer arbeitet wie folgt:
|
|
\begin{itemize}
|
|
\item Falls $|C| < k$, lehne ab.
|
|
\item Prüfe für jedes Paar $\{u,v\} \subseteq C$, ob $\{u,v\} \in E$ gilt;
|
|
lehne sonst ab.
|
|
\item Sonst akzeptiere.
|
|
\end{itemize}
|
|
Existiert eine $k$-Clique, dann gibt es ein Zertifikat dafür. Dieses wird
|
|
akzeptiert. Sonst verletzt jedes Zertifikat eine Prüfung -- abgelehnt.
|
|
|
|
\textbf{Laufzeit:} Größe zählen $O(|V|)$, alle Paare testen $O(|V|^2)$ --
|
|
gesamt $O(|V|^2)$. Also gilt $k$-\problem{Clique} $\in$ NP.
|
|
|
|
\textbf{NP-schwer} durch
|
|
$\problem{SAT} \redp k\text{-}\problem{Clique}$:
|
|
|
|
\textbf{Konstruktion:} Sei $F = F_1 \wedge \dots \wedge F_m$ eine
|
|
KNF-Formel. Wir konstruieren daraus eine $k$-\problem{Clique}-Instanz durch:
|
|
\begin{itemize}
|
|
\item $V = \{[i,j] \mid \text{$j$-tes Literal in Klausel } i\}$;
|
|
$y_{ij}$ bezeichne dieses Literal
|
|
\item $E = \{\{[i,j],[i',j']\} \mid i \ne i',\ y_{ij} \ne \neg y_{i'j'}\}$
|
|
\item $k = m$
|
|
\end{itemize}
|
|
|
|
\textbf{Beweis hin:}
|
|
\begin{itemize}
|
|
\item Sei $\psi$ eine erfüllende Belegung von $F$.
|
|
\item Dann ist in jeder Klausel mindestens ein Literal wahr. Wähle pro
|
|
Klausel eines.
|
|
\item $C$ sei die Menge der $m$ zugehörigen Knoten.
|
|
\item Je zwei Knoten aus $C$ stammen aus verschiedenen Klauseln.
|
|
\item Ihre Literale widersprechen sich nicht, denn beide sind unter
|
|
$\psi$ wahr.
|
|
\item Nach Definition von $E$ sind sie also verbunden.
|
|
\item Also ist $C$ eine $m$-Clique und $(G, m)$ eine Ja-Instanz.
|
|
\end{itemize}
|
|
|
|
\textbf{Beweis zurück:}
|
|
\begin{itemize}
|
|
\item Sei $C$ eine $m$-Clique in $G$.
|
|
\item Knoten derselben Klausel sind nie verbunden. Also enthält $C$ aus
|
|
jeder der $m$ Klauseln genau einen Knoten.
|
|
\item Die zugehörigen Literale widersprechen sich paarweise nicht (sonst
|
|
fehlte eine Kante).
|
|
\item Setze alle diese Literale wahr -- eine widerspruchsfreie Belegung.
|
|
\item Sie erfüllt in jeder Klausel ein Literal.
|
|
\item Also ist $F$ erfüllbar.
|
|
\end{itemize}
|
|
|
|
\textbf{Laufzeit:} Sei $L$ die Zahl der Literalvorkommen. Knoten anlegen
|
|
$O(L)$, Kanten prüfen $O(L^2)$ -- gesamt $O(L^2)$.
|
|
|
|
Da \problem{SAT} NP-vollständig ist, $\problem{SAT} \redp
|
|
k\text{-}\problem{Clique}$ gilt und $k\text{-}\problem{Clique} \in \NP$, ist
|
|
$k$-\problem{Clique} NP-vollständig. \hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{Lower Bounds: VertexCover}{Hausaufgabe 12.1, 5 P.}
|
|
Betrachten Sie die Reduktion $\problem{Clique} \redp \problem{VertexCover}$
|
|
(Komplementgraph, $k' = n-k$).
|
|
\begin{enumerate}
|
|
\item Geben Sie $|V'|$, $|E'|$ und $k'$ in Abhängigkeit der Clique-Instanz an.
|
|
\item Zeigen Sie Lower Bounds für \problem{VertexCover} bzgl.\ $|V'|$, $|E'|$
|
|
und $k'$ basierend auf der ETH.
|
|
\end{enumerate}
|
|
|
|
\emph{Hinweis:} Unter der ETH ist \problem{Clique} nicht in
|
|
$2^{o(|V|)} \cdot |I|^{O(1)}$ lösbar (Vorlesung).
|
|
|
|
\bspkopf{Lower Bounds VertexCover: konkrete Zahlen}
|
|
\textbf{Instanz.} \problem{Clique}-Instanz $G$ mit $|V|=5$, $|E|=6$, $k=3$.
|
|
Die Reduktion bildet den Komplementgraphen $\bar G$ mit $k' = |V|-k$.
|
|
|
|
\begin{center}
|
|
\begin{tikzpicture}[plab/.style={font=\scriptsize,align=center}]
|
|
\node[kndick] (g1) at (0,2.0) {1};
|
|
\node[kndick] (g2) at (-1.1,1.0) {2};
|
|
\node[kndick] (g3) at (1.1,1.0) {3};
|
|
\node[knoten] (g4) at (-0.7,-0.2) {4};
|
|
\node[knoten] (g5) at (0.7,-0.2) {5};
|
|
\draw (g1) -- (g2); \draw (g1) -- (g3); \draw (g2) -- (g3);
|
|
\draw (g2) -- (g4); \draw (g3) -- (g5); \draw (g4) -- (g5);
|
|
\node[plab] at (0,-1.2) {$G$: Clique $\{1,2,3\}$ (grau)};
|
|
\draw[->] (2.2,0.9) -- node[above,plab] {Komplement} (3.9,0.9);
|
|
\node[knoten] (h2) at (4.7,0.9) {2};
|
|
\node[kndick] (h5) at (5.9,0.9) {5};
|
|
\node[knoten] (h1) at (7.1,0.9) {1};
|
|
\node[kndick] (h4) at (8.3,0.9) {4};
|
|
\node[knoten] (h3) at (9.5,0.9) {3};
|
|
\draw (h2) -- (h5); \draw (h5) -- (h1); \draw (h1) -- (h4); \draw (h4) -- (h3);
|
|
\node[plab] at (7.1,-1.2) {$\bar G$: VertexCover $\{4,5\}$ (grau)};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{Kern.} Die VC-Instanz hat $|V'|=5$, $|E'|=\tbinom{5}{2}-6=4$ und
|
|
$k'=5-3=2$. Wegen $|V'|=|V|$ wäre ein $2^{o(|V'|)}$-Algorithmus für
|
|
\problem{VertexCover} zugleich ein $2^{o(|V|)}$-Algorithmus für
|
|
\problem{Clique} -- Widerspruch zur ETH. Kein $2^{o(|V'|)}$.
|
|
|
|
|
|
\musterkopf{ETH-Kontraposition}
|
|
Überträgt die ETH-Schranke entlang einer Reduktion: ein schneller Algorithmus fürs Ziel wäre ein schneller Algorithmus für die Quelle.
|
|
\begin{itemize}
|
|
\item Parameter der Zielinstanz zählen -- als Funktion der Quellparameter.
|
|
\item Angenommen, das Ziel wäre in $2^{o(\mathrm{param})} \cdot |I|^{O(1)}$ lösbar.
|
|
\item Parameter einsetzen: daraus folgt $2^{o(\mathrm{Quellparameter})}$ für die Quelle.
|
|
\item Bei quadratischem Blowup: Wurzel im Exponenten ansetzen ($\sqrt{\mathrm{param}} = O(\cdot)$).
|
|
\item Widerspruch zur bekannten Schranke (ETH bzw.\ Hinweis). Bound notieren.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{1.} $|V'| = |V|$,\quad
|
|
$|E'| = \tfrac12|V|(|V|-1) - |E| \le |V|^2$,\quad $k' = |V| - k \le |V|$.
|
|
\begin{center}
|
|
\begin{tikzpicture}[
|
|
pbox/.style={draw,rounded corners,minimum height=6mm,inner sep=5pt,font=\small},
|
|
plab/.style={font=\scriptsize,align=center},
|
|
blab/.style={font=\scriptsize,align=center,text=black!60}]
|
|
\node[pbox] (cl) at (0,0) {\problem{Clique} $(G,k)$};
|
|
\node[pbox] (vc) at (7.8,0) {\problem{VertexCover} $(\bar G,k')$};
|
|
\draw[->] (cl) -- node[above,plab,yshift=0.5mm]
|
|
{Komplementgraph:\\ $|V'|{=}|V|$, $|E'|\le|V|^2$,\\ $k'{=}|V|{-}k\le|V|$} (vc);
|
|
\node[blab,anchor=east] at (-1.55,0) {ETH:\\ kein $2^{o(|V|)}$};
|
|
\node[blab,anchor=south] at (7.8,0.45)
|
|
{kein $2^{o(|V'|)}$, kein $2^{o(\sqrt{|E'|})}$,\\ kein $2^{o(k')}$};
|
|
\draw[->,dashed] (vc.south) .. controls (6.5,-2.2) and (1.3,-2.2) .. (cl.south);
|
|
\node[plab] at (3.9,-2.4)
|
|
{Kontraposition: \problem{VertexCover} in $2^{o(|V'|)}$/$2^{o(\sqrt{|E'|})}$/$2^{o(k')}$\\
|
|
$\Rightarrow$ \problem{Clique} in $2^{o(|V|)}\cdot|I|^{O(1)}$ $\Rightarrow$ ETH verletzt};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{2.} Für \problem{Clique} gilt unter der ETH: kein
|
|
$2^{o(|V|)} \cdot |I|^{O(1)}$-Algorithmus.
|
|
\begin{itemize}
|
|
\item \textbf{Bzgl.\ $|V'|$:} Angenommen, \problem{VertexCover} wäre in
|
|
$2^{o(|V'|)} \cdot |I|^{O(1)}$ lösbar. Wegen $|V'| = |V|$ ergäbe sich ein
|
|
$2^{o(|V|)}$-Algorithmus für \problem{Clique}. Widerspruch zur ETH.
|
|
\item \textbf{Bzgl.\ $|E'|$:} Angenommen, \problem{VertexCover} wäre in
|
|
$2^{o(\sqrt{|E'|})} \cdot |I|^{O(1)}$ lösbar. Wegen $|E'| \le |V|^2$ ist
|
|
$\sqrt{|E'|} = O(|V|)$ -- es ergäbe sich ein $2^{o(|V|)}$-Algorithmus für
|
|
\problem{Clique}. Widerspruch zur ETH.
|
|
\item \textbf{Bzgl.\ $k'$:} Angenommen, \problem{VertexCover} wäre in
|
|
$2^{o(k')} \cdot |I|^{O(1)}$ lösbar. Wegen $k' \le |V|$ ergäbe sich ein
|
|
$2^{o(|V|)}$-Algorithmus für \problem{Clique}. Widerspruch zur ETH.
|
|
\end{itemize}
|
|
\hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{ListScheduling hat Güte $2 - \frac{1}{m}$}{Klausur SS23-N, A4, 10 P.}
|
|
$P\,\|\,C_{\max}$: $n$ Jobs mit Zeiten $p_1, \dots, p_n$, $m$ Maschinen;
|
|
minimiere $\Cmax$. ListScheduling legt jeden Job der Reihe nach auf die
|
|
Maschine mit minimaler Last. Zeigen Sie: Für alle $I$ gilt
|
|
$\mathrm{LS}(I)/\mathrm{OPT}(I) \le 2 - 1/m$.
|
|
|
|
\bspkopf{ListScheduling-Güte $2-\frac1m$ scharf: $m=2$, Jobs $(1,1,2)$}
|
|
\textbf{Instanz.} $m=2$ Maschinen, Jobs $(1,1,2)$. ListScheduling legt
|
|
jeden Job auf die Maschine kleinster Last: $J_1\!\to\!M_1$,
|
|
$J_2\!\to\!M_2$, $J_3\!\to\!M_1$ $\Rightarrow \mathrm{LS}=3$.
|
|
\begin{center}
|
|
\begin{tikzpicture}[x=1.1cm,y=0.7cm]
|
|
\node[font=\small] at (-1.5,1) {\textbf{LS}};
|
|
\node[left,font=\small] at (-0.15,1.5) {$M_1$};
|
|
\draw[fill=black!10] (0,1.25) rectangle (1,1.75); \node at (0.5,1.5) {\small$J_1$};
|
|
\draw[fill=black!25] (1,1.25) rectangle (3,1.75); \node at (2,1.5) {\small$J_3$};
|
|
\node[left,font=\small] at (-0.15,0.5) {$M_2$};
|
|
\draw[fill=black!10] (0,0.25) rectangle (1,0.75); \node at (0.5,0.5) {\small$J_2$};
|
|
\draw[->] (0,-0.15) -- (3.7,-0.15) node[below,font=\small]{$t$};
|
|
\foreach \t in {0,1,2,3} {\draw (\t,-0.22)--(\t,-0.08); \node[below,font=\scriptsize] at (\t,-0.18){\t};}
|
|
\draw[dashed] (3,-0.15)--(3,2.05); \node[above,font=\footnotesize] at (3,2.0){$\mathrm{LS}=3$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
\textbf{Kern.} Das Optimum legt $J_1, J_2$ auf eine Maschine und $J_3$
|
|
auf die andere: $\OPT=2$. Also $\mathrm{LS}/\OPT=\tfrac32=2-\tfrac1m$ --
|
|
die Schranke ist \emph{scharf}:
|
|
\begin{center}
|
|
\begin{tikzpicture}[x=1.1cm,y=0.7cm]
|
|
\node[font=\small] at (-1.5,1) {\textbf{OPT}};
|
|
\node[left,font=\small] at (-0.15,1.5) {$M_1$};
|
|
\draw[fill=black!10] (0,1.25) rectangle (1,1.75); \node at (0.5,1.5) {\small$J_1$};
|
|
\draw[fill=black!10] (1,1.25) rectangle (2,1.75); \node at (1.5,1.5) {\small$J_2$};
|
|
\node[left,font=\small] at (-0.15,0.5) {$M_2$};
|
|
\draw[fill=black!25] (0,0.25) rectangle (2,0.75); \node at (1,0.5) {\small$J_3$};
|
|
\draw[->] (0,-0.15) -- (3.7,-0.15) node[below,font=\small]{$t$};
|
|
\foreach \t in {0,1,2,3} {\draw (\t,-0.22)--(\t,-0.08); \node[below,font=\scriptsize] at (\t,-0.18){\t};}
|
|
\draw[dashed] (2,-0.15)--(2,2.05); \node[above,font=\footnotesize] at (2,2.0){$\OPT=2$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
|
|
\musterkopf{Güte-Rahmen}
|
|
Jeder Güte-Beweis klemmt den Algorithmuswert zwischen eine Schranke und $c \cdot \mathrm{OPT}$.
|
|
\begin{itemize}
|
|
\item ALG nach oben abschätzen -- am kritischen Moment der Ausführung argumentieren.
|
|
\item Untere Schranken für OPT sammeln (z.\,B. $\mathrm{OPT} \ge \frac1m \sum p_j$, $\mathrm{OPT} \ge p_{\max}$).
|
|
\item Die ALG-Schranke durch die OPT-Schranken ausdrücken.
|
|
\item Kombinieren: $\mathrm{ALG} \le c \cdot \mathrm{OPT}$; $c$ ist die Güte.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
O.B.d.A.\ habe Maschine $M_1$ am Ende die höchste Last
|
|
$L = \mathrm{LS}(I)$. Sei $J_k$ der letzte Job, der $M_1$ zugeordnet wurde.
|
|
|
|
\textbf{Kernbeobachtung:} Bei der Zuordnung von $J_k$ hatte $M_1$ die
|
|
\emph{kleinste} Last $L - p_k$ -- also hatten alle $m$ Maschinen mindestens
|
|
Last $L - p_k$. Daraus folgt
|
|
\[
|
|
\sum_{i=1}^{n} p_i \;\ge\; m\,(L - p_k) + p_k.
|
|
\]
|
|
\begin{center}
|
|
\begin{tikzpicture}[x=1.1cm,y=1cm]
|
|
\node[left] at (-0.15,2.975) {\small $M_1$};
|
|
\draw[fill=black!10] (0,2.7) rectangle (7,3.25);
|
|
\draw[fill=black!25] (7,2.7) rectangle (10,3.25);
|
|
\node at (8.5,2.975) {\small $J_k$};
|
|
\node[left] at (-0.15,2.275) {\small $M_2$};
|
|
\draw[fill=black!10] (0,2.0) rectangle (8.2,2.55);
|
|
\node[left] at (-0.15,1.575) {\small $M_3$};
|
|
\draw[fill=black!10] (0,1.3) rectangle (7.6,1.85);
|
|
\node at (-0.45,0.95) {\small $\vdots$};
|
|
\node[left] at (-0.15,0.275) {\small $M_m$};
|
|
\draw[fill=black!10] (0,0.0) rectangle (7.3,0.55);
|
|
\draw[thin] (7,3.45) -- (7,3.6) -- node[above] {\small $p_k$} (10,3.6) -- (10,3.45);
|
|
\draw[dashed,thin] (7,-0.35) -- (7,3.25);
|
|
\draw[dashed,thin] (10,-0.35) -- (10,3.25);
|
|
\draw[->,thin] (0,-0.35) -- (10.9,-0.35) node[below] {\small $t$};
|
|
\draw[thin] (0,-0.42) -- (0,-0.28);
|
|
\node[below] at (0,-0.45) {\small $0$};
|
|
\node[below] at (7,-0.45) {\small $s = L - p_k$};
|
|
\node[below] at (10,-0.45) {\small $L = \mathrm{LS}(I)$};
|
|
\node at (5,-1.35) {\small $s \;\le\; \tfrac1m\bigl(\textstyle\sum_i p_i - p_k\bigr)$,
|
|
denn alle Maschinen sind bis mindestens $s$ gef\"ullt};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{Zwei Schranken für das Optimum:}
|
|
$\mathrm{OPT}(I) \ge \frac{1}{m}\sum_i p_i$ (Gesamtlast auf $m$ Maschinen) und
|
|
$\mathrm{OPT}(I) \ge p_k$ (jeder Job muss irgendwo laufen).
|
|
|
|
\textbf{Kombination:}
|
|
\[
|
|
\mathrm{OPT}(I) \;\ge\; \frac{1}{m}\sum_i p_i
|
|
\;\ge\; \frac{m(L - p_k) + p_k}{m}
|
|
\;=\; L - \Bigl(1 - \frac1m\Bigr) p_k .
|
|
\]
|
|
Mit $p_k \le \mathrm{OPT}(I)$:
|
|
$\mathrm{OPT}(I) \ge \mathrm{LS}(I) - (1 - \frac1m)\,\mathrm{OPT}(I)$, also
|
|
$\mathrm{LS}(I) \le \bigl(2 - \frac1m\bigr)\,\mathrm{OPT}(I)$. \hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{ListScheduling: scharfe Worst-Case-Instanzen}{Klausur SS24-H, A1c+d, 2+2 P.}
|
|
ListScheduling hat Güte $2 - \frac1m$.
|
|
\begin{enumerate}
|
|
\item[a)] Geben Sie eine Instanz für $m = 2$ an, bei der ListScheduling die
|
|
Güte $2 - \frac1m$ erreicht (mit OPT und LS-Wert).
|
|
\item[b)] Dasselbe für $m = 3$.
|
|
\end{enumerate}
|
|
|
|
\emph{Hinweis:} ListScheduling legt jeden Job in der gegebenen Reihenfolge auf
|
|
die aktuell am wenigsten belastete Maschine.
|
|
|
|
\musterkopf{Scharfe Instanz bauen}
|
|
Baut eine Instanz, die die Güte-Schranke exakt erreicht.
|
|
\begin{itemize}
|
|
\item Zwinge den Algorithmus, alle Maschinen gleich zu füllen.
|
|
\item Setze zum Schluss einen großen Brocken obendrauf.
|
|
\item OPT verteilt anders: Brocken allein, Kleinteile gleichmäßig.
|
|
\item Rate $\mathrm{ALG}/\mathrm{OPT}$ ausrechnen -- sie trifft die Schranke exakt.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{a)} $m = 2$: Jobs $(1, 1, 2)$ in dieser Reihenfolge. LS verteilt die
|
|
Einsen auf beide Maschinen, die 2 kommt obendrauf: $\mathrm{LS} = 3$. Optimal:
|
|
$\{2\}$ / $\{1,1\}$ mit $\mathrm{OPT} = 2$. Rate $3/2 = 2 - \frac12$.
|
|
|
|
\textbf{b)} $m = 3$: sechs Einser-Jobs, dann ein Job der Größe 3. LS verteilt
|
|
die Einsen gleichmäßig (je 2), die 3 kommt obendrauf: $\mathrm{LS} = 5$.
|
|
Optimal: 3 allein, die Einsen auf zwei Maschinen: $\mathrm{OPT} = 3$. Rate
|
|
$5/3 = 2 - \frac13$.
|
|
\begin{center}
|
|
\begin{tikzpicture}[x=0.6cm,y=1cm]
|
|
\node at (3.3,1.85) {\small a)\; $m=2$: Jobs $(1,1,2)$};
|
|
\node[left] at (-0.2,1.025) {\small $M_1$};
|
|
\draw[fill=black!10] (0,0.75) rectangle (1,1.3); \node at (0.5,1.025) {\small $1$};
|
|
\draw[fill=black!25] (1,0.75) rectangle (3,1.3); \node at (2,1.025) {\small $2$};
|
|
\node[left] at (-0.2,0.275) {\small $M_2$};
|
|
\draw[fill=black!10] (0,0) rectangle (1,0.55); \node at (0.5,0.275) {\small $1$};
|
|
\draw[dashed,thin] (3,-0.1) -- (3,1.3);
|
|
\node at (1.5,-0.55) {\small $\mathrm{LS}=3$};
|
|
\begin{scope}[xshift=3.3cm]
|
|
\draw[fill=black!25] (0,0.75) rectangle (2,1.3); \node at (1,1.025) {\small $2$};
|
|
\draw[fill=black!10] (0,0) rectangle (1,0.55); \node at (0.5,0.275) {\small $1$};
|
|
\draw[fill=black!10] (1,0) rectangle (2,0.55); \node at (1.5,0.275) {\small $1$};
|
|
\draw[dashed,thin] (2,-0.1) -- (2,1.3);
|
|
\node at (1,-0.55) {\small $\mathrm{OPT}=2$};
|
|
\end{scope}
|
|
\end{tikzpicture}\hspace{1.8cm}%
|
|
\begin{tikzpicture}[x=0.6cm,y=1cm]
|
|
\node at (4.4,2.6) {\small b)\; $m=3$: sechs Einsen, dann eine $3$};
|
|
\node[left] at (-0.2,1.775) {\small $M_1$};
|
|
\draw[fill=black!10] (0,1.5) rectangle (1,2.05); \node at (0.5,1.775) {\small $1$};
|
|
\draw[fill=black!10] (1,1.5) rectangle (2,2.05); \node at (1.5,1.775) {\small $1$};
|
|
\draw[fill=black!25] (2,1.5) rectangle (5,2.05); \node at (3.5,1.775) {\small $3$};
|
|
\node[left] at (-0.2,1.025) {\small $M_2$};
|
|
\draw[fill=black!10] (0,0.75) rectangle (1,1.3); \node at (0.5,1.025) {\small $1$};
|
|
\draw[fill=black!10] (1,0.75) rectangle (2,1.3); \node at (1.5,1.025) {\small $1$};
|
|
\node[left] at (-0.2,0.275) {\small $M_3$};
|
|
\draw[fill=black!10] (0,0) rectangle (1,0.55); \node at (0.5,0.275) {\small $1$};
|
|
\draw[fill=black!10] (1,0) rectangle (2,0.55); \node at (1.5,0.275) {\small $1$};
|
|
\draw[dashed,thin] (5,-0.1) -- (5,2.05);
|
|
\node at (2.5,-0.55) {\small $\mathrm{LS}=5$};
|
|
\begin{scope}[xshift=4.2cm]
|
|
\draw[fill=black!25] (0,1.5) rectangle (3,2.05); \node at (1.5,1.775) {\small $3$};
|
|
\foreach \x in {0,1,2} {
|
|
\draw[fill=black!10] (\x,0.75) rectangle (\x+1,1.3); \node at (\x+0.5,1.025) {\small $1$};
|
|
\draw[fill=black!10] (\x,0) rectangle (\x+1,0.55); \node at (\x+0.5,0.275) {\small $1$};}
|
|
\draw[dashed,thin] (3,-0.1) -- (3,2.05);
|
|
\node at (1.5,-0.55) {\small $\mathrm{OPT}=3$};
|
|
\end{scope}
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
\hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{Fragen über Fragen II}{Präsenz 11.1}
|
|
Wahr oder falsch?
|
|
\begin{enumerate}
|
|
\item[a)] Für $L \in \NP$ gilt: aus $L \redp \problem{3-SAT}$ folgt, dass $L$
|
|
NP-vollständig ist.
|
|
\item[b)] Gilt $L \redp \problem{3-SAT}$ und $\problem{3-SAT} \redp L$, dann
|
|
ist $L$ NP-vollständig.
|
|
\item[c)] Sei $L$ NP-vollständig. Dann gilt $L \in P \iff P = NP$.
|
|
\item[d)] Es ist möglich, dass $\problem{3-SAT} \in P$ und
|
|
$\problem{Clique} \notin P$.
|
|
\end{enumerate}
|
|
|
|
\musterkopf{Implikationslogik}
|
|
Wahr/Falsch über P, NP und Reduktionen: Definitionen einsetzen, Richtungen prüfen.
|
|
\begin{itemize}
|
|
\item Aussage in Definitionen übersetzen ($\redp$, NP-schwer, NP-vollständig).
|
|
\item Richtung der Reduktion prüfen: wer reduziert auf wen?
|
|
\item Für \glqq falsch\grqq: Gegenbeispiel (triviale Sprache $\emptyset$/$\Sigma^*$, offene $P \ne NP$-Frage) oder Annahme per bekannter Reduktion zum Widerspruch führen.
|
|
\item Für \glqq wahr\grqq: mit dem Verkettungs-Muster in 2--3 Sätzen beweisen.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{a)} Falsch. Gegenbeispiel $L = \emptyset \in \NP$: $L \redp
|
|
\problem{3-SAT}$ sagt nur, dass sich $L$ \emph{auf} 3-SAT reduzieren lässt --
|
|
nicht umgekehrt, also keine Schwere.
|
|
|
|
\textbf{b)} Wahr. $\problem{3-SAT} \redp L$ gibt die NP-Schwere: 3-SAT ist
|
|
NP-vollständig und $\redp$ ist transitiv. $L \redp \problem{3-SAT}$ gibt
|
|
$L \in \NP$. Das ist die Definition von NP-vollständig.
|
|
|
|
\textbf{c)} Wahr. Jedes $L' \in \NP$ reduziert auf $L$; liegt $L$ in $P$, dann
|
|
auch jedes $L'$ -- also $P = NP$. Umgekehrt folgt aus $P = NP$ sofort
|
|
$L \in P$, da $L \in \NP$.
|
|
|
|
\textbf{d)} Falsch. \problem{Clique} $\in \NP$ reduziert auf das
|
|
NP-vollständige \problem{3-SAT}; aus $\problem{3-SAT} \in P$ folgt also
|
|
$\problem{Clique} \in P$. \hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
% ##################################################################
|
|
\section{Konstruktions-Familien: an einem Beispiel lernen, dann ableiten}
|
|
% ##################################################################
|
|
|
|
% ==================================================================
|
|
\katkopf{FeedbackVertexSet ist NP-vollständig}{Hausaufgaben 9.2 und 10.1, je 5 P.}
|
|
\textbf{Problem \problem{FeedbackVertexSet}:} Gegeben ein \emph{gerichteter}
|
|
Graph $G = (V,E)$ und $k$; gibt es $X \subseteq V$ mit $|X| \le k$, sodass
|
|
$G \setminus X$ kreisfrei ist?
|
|
|
|
Zeigen Sie, dass \problem{FeedbackVertexSet} NP-vollständig ist.
|
|
\emph{Hinweis:} Reduzieren Sie \problem{VertexCover} auf
|
|
\problem{FeedbackVertexSet}.
|
|
|
|
\bspkopf{FeedbackVertexSet NP-vollständig}
|
|
\textbf{Instanz.} \problem{VertexCover} am Pfad $1$--$2$--$3$ mit $k=1$.
|
|
\begin{center}
|
|
\begin{tikzpicture}
|
|
\begin{scope}
|
|
\node[knoten] (a1) at (0,0) {1};
|
|
\node[kndick] (a2) at (1.5,0) {2};
|
|
\node[knoten] (a3) at (3,0) {3};
|
|
\draw (a1)--(a2) (a2)--(a3);
|
|
\node[font=\footnotesize] at (1.5,-1.0) {$G$: VC $\{2\}$, $k=1$};
|
|
\end{scope}
|
|
\draw[->,thick] (3.9,0) -- (5.3,0);
|
|
\begin{scope}[xshift=6.2cm]
|
|
\node[knoten] (b1) at (0,0) {1};
|
|
\node[kndick] (b2) at (1.5,0) {2};
|
|
\node[knoten] (b3) at (3,0) {3};
|
|
\draw[->] (b1) to[bend left=35] (b2);
|
|
\draw[->] (b2) to[bend left=35] (b1);
|
|
\draw[->] (b2) to[bend left=35] (b3);
|
|
\draw[->] (b3) to[bend left=35] (b2);
|
|
\node[font=\footnotesize] at (1.5,-1.0) {$G'$: FVS $\{2\}$, $k=1$};
|
|
\end{scope}
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{Kern.} Jede Kante $\{u,v\}$ wird zu zwei antiparallelen Bögen
|
|
$(u,v),(v,u)$; $k$ bleibt. In $G'$ entstehen die $2$-Kreise
|
|
$1\rightleftarrows 2$ und $2\rightleftarrows 3$; das Vertex Cover
|
|
$\{2\}$ trifft beide, ist also ein Feedback Vertex Set mit
|
|
$|X| = 1 \le k$.
|
|
|
|
|
|
\musterkopf{Kanten-Gadget}
|
|
Reduktion durch lokalen Ersatz: jede Kante wird durch ein kleines Bauteil ersetzt.
|
|
\begin{itemize}
|
|
\item Knoten übernehmen; pro Kante ein festes Gadget einsetzen (zwei Bögen, ein Dreieck, \dots).
|
|
\item Parameter $k$ unverändert oder einfach angepasst.
|
|
\item Beweis hin: die Lösung deckt alle Gadgets, weil sie alle Kanten deckt.
|
|
\item Beweis zurück: das Gadget erzwingt einen Kantenendpunkt -- ggf.\ Austauschargument (Neuknoten durch Altknoten ersetzen).
|
|
\item Laufzeit: pro Kante konstant viel -- $O(|E|)$.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{$\in$ NP:} Eingabe: gerichteter Graph $G = (V,E)$, Zahl $k$ und
|
|
Zertifikat $X \subseteq V$. Der Verifizierer arbeitet wie folgt:
|
|
\begin{itemize}
|
|
\item Falls $|X| > k$, lehne ab.
|
|
\item Prüfe per topologischer Sortierung, ob $G \setminus X$ kreisfrei ist.
|
|
\item Lehne ab, falls $G \setminus X$ einen Kreis enthält.
|
|
\item Sonst akzeptiere.
|
|
\end{itemize}
|
|
Existiert ein Feedback Vertex Set $X$ mit $|X| \le k$, dann gibt es ein
|
|
Zertifikat dafür. Dieses wird vom Verifizierer akzeptiert und sonst abgelehnt.
|
|
Größenprüfung und topologische Sortierung laufen in $O(|V| + |E|)$.
|
|
Also gilt $\problem{FeedbackVertexSet} \in \NP$.
|
|
|
|
\textbf{NP-schwer:} Zeige, dass \problem{FeedbackVertexSet} NP-schwer ist
|
|
durch die Reduktion
|
|
$\problem{VertexCover} \redp \problem{FeedbackVertexSet}$.
|
|
\problem{VertexCover} ist bereits als NP-vollständig bekannt.
|
|
|
|
\textbf{Konstruktion:} Sei $(G = (V,E), k)$ eine \problem{VertexCover}-Instanz.
|
|
Wir konstruieren daraus eine \problem{FeedbackVertexSet}-Instanz
|
|
$(G' = (V', E'),\, k')$ durch:
|
|
\begin{itemize}
|
|
\item $V' = V$
|
|
\item $E' = \{(u,v), (v,u) \mid \{u,v\} \in E\}$
|
|
\item $k' = k$
|
|
\end{itemize}
|
|
So wird jede ungerichtete Kante zu zwei antiparallelen Bögen.
|
|
\begin{center}
|
|
\begin{tikzpicture}
|
|
\node[knoten] (u1) at (0,0) {$u$};
|
|
\node[knoten] (v1) at (2.2,0) {$v$};
|
|
\draw (u1)--(v1);
|
|
\node[font=\footnotesize] at (1.1,-1.0) {Kante $\{u,v\}$ in $G$};
|
|
\draw[->,thick] (3.4,0) -- (5.0,0);
|
|
\node[knoten] (u2) at (6.2,0) {$u$};
|
|
\node[knoten] (v2) at (8.4,0) {$v$};
|
|
\draw[->] (u2) to[bend left=30] (v2);
|
|
\draw[->] (v2) to[bend left=30] (u2);
|
|
\node[font=\footnotesize] at (7.3,-1.0) {B\"ogen $(u,v)$ und $(v,u)$ in $G'$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{Beweis VertexCover nach FeedbackVertexSet:}
|
|
\begin{itemize}
|
|
\item Sei $C$ ein Vertex Cover von $G$ mit $|C| \le k$.
|
|
\item Somit hat jede Kante aus $G$ einen Endpunkt in $C$.
|
|
\item Also hat $G \setminus C$ keine Kanten mehr.
|
|
\item Dann hat auch $G' \setminus C$ keine Bögen und damit keine Kreise.
|
|
\item Also ist $C$ ein Feedback Vertex Set für $G'$ mit $|C| \le k'$.
|
|
\end{itemize}
|
|
|
|
\textbf{Beweis FeedbackVertexSet nach VertexCover:}
|
|
\begin{itemize}
|
|
\item Sei $X$ ein Feedback Vertex Set von $G'$ mit $|X| \le k'$.
|
|
\item Dann ist $G' \setminus X$ kreisfrei.
|
|
\item Angenommen, $X$ wäre kein Vertex Cover.
|
|
\item Dann gäbe es eine Kante $\{u,v\} \in E$ mit $u, v \notin X$.
|
|
\item Somit wären $u$ und $v$ noch in $G' \setminus X$ vorhanden.
|
|
\item Die Bögen $(u,v)$ und $(v,u)$ würden einen Kreis bilden.
|
|
\item Das wäre ein Widerspruch dazu, dass $G' \setminus X$ kreisfrei ist.
|
|
\item Also ist $X$ ein Vertex Cover von $G$ mit $|X| \le k$.
|
|
\end{itemize}
|
|
|
|
\textbf{Laufzeit:} Pro Kante zwei antiparallele Bögen anlegen -- $O(|E|)$.
|
|
|
|
Da $\problem{FeedbackVertexSet} \in \NP$ und NP-schwer ist, folgt:
|
|
\problem{FeedbackVertexSet} ist NP-vollständig. \hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{3-COLOR mit Minimalgrad 3 ist NP-vollständig}{Klausur SS23-H, A5b, 4 P.}
|
|
Beweisen Sie die NP-Vollständigkeit von \problem{3-COLOR}, wobei jeder Knoten
|
|
im Graphen mindestens Grad 3 hat.
|
|
|
|
\bspkopf{3-COLOR mit Minimalgrad 3}
|
|
\textbf{Instanz.} \problem{3-COLOR} am Graphen $G$ aus dem einzelnen
|
|
Knoten $v$, also $\deg(v) = 0 < 3$.
|
|
\begin{center}
|
|
\begin{tikzpicture}
|
|
\begin{scope}
|
|
\node[kndick,font=\small] (lv) at (0,0) {$v$};
|
|
\node[font=\footnotesize] at (0,-1.9) {$\deg(v)=0<3$ in $G$};
|
|
\end{scope}
|
|
\draw[->,thick] (1.1,0) -- (2.3,0);
|
|
\begin{scope}[xshift=6.4cm]
|
|
\node[kndick,font=\small] (v) at (0,0) {$v$};
|
|
\node[knoten,minimum size=5.5mm,font=\small] (p) at (-1.2,0) {$p$};
|
|
\node[knoten,minimum size=5.5mm,font=\small] (q) at (-2.2,0.6) {$q$};
|
|
\node[knoten,minimum size=5.5mm,font=\small] (r) at (-2.2,-0.6) {$r$};
|
|
\node[knoten,minimum size=5.5mm,font=\small] (s) at (-3.2,0) {$s$};
|
|
\draw (p)--(q) (p)--(r) (q)--(r) (q)--(s) (r)--(s);
|
|
\draw (v)--(p);
|
|
\draw (v) .. controls (-1.2,-1.5) and (-2.8,-1.5) .. (s);
|
|
\node[knoten,minimum size=5.5mm,font=\small] (p2) at (1.2,0) {$p'$};
|
|
\node[knoten,minimum size=5.5mm,font=\small] (q2) at (2.2,0.6) {$q'$};
|
|
\node[knoten,minimum size=5.5mm,font=\small] (r2) at (2.2,-0.6) {$r'$};
|
|
\node[knoten,minimum size=5.5mm,font=\small] (s2) at (3.2,0) {$s'$};
|
|
\draw (p2)--(q2) (p2)--(r2) (q2)--(r2) (q2)--(s2) (r2)--(s2);
|
|
\draw (v)--(p2);
|
|
\draw (v) .. controls (1.2,-1.5) and (2.8,-1.5) .. (s2);
|
|
\node[font=\footnotesize, text width=8.6cm, align=center] at (0,-2.2)
|
|
{$\deg(v)=0+4=4$; alle Gadget-Knoten haben Grad $3$};
|
|
\end{scope}
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{Kern.} An jeden Knoten mit Grad $< 3$ werden zwei
|
|
Diamant-Gadgets ($K_4$ ohne die Kante $\{p,s\}$) über $\{v,p\}$ und
|
|
$\{v,s\}$ angehängt. Eine 3-Färbung überträgt sich auf $G'$:
|
|
$f(v) = 1$, je Gadget $p = s = 2$, $q = 1$, $r = 3$.
|
|
|
|
|
|
\musterkopf{Knoten-Gadget}
|
|
Reduktion durch lokalen Ersatz am Knoten: jeder Knoten bekommt ein Bauteil, das eine Zusatzeigenschaft erzwingt.
|
|
\begin{itemize}
|
|
\item Pro Knoten ein festes Gadget anhängen oder ersetzen (Diamant, Zwilling, $K_{4,3}$).
|
|
\item Das Gadget erzwingt lokal die Zusatzbedingung (Mindestgrad, Portale, Pfadenden).
|
|
\item Beweis hin: die Lösung setzt sich aufs Gadget fort -- Gadget separat lösen.
|
|
\item Beweis zurück: die Gadget-Eigenschaft zwingt die Lösung aufs Original zurück.
|
|
\item Laufzeit: pro Knoten konstant viel -- $O(|V|)$.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{$\in$ NP:} Eingabe: Graph $G = (V,E)$ und Zertifikat
|
|
$f: V \to \{1,2,3\}$. Der Verifizierer arbeitet wie folgt:
|
|
\begin{itemize}
|
|
\item Prüfe für jede Kante $\{u,v\} \in E$, ob $f(u) \ne f(v)$ gilt.
|
|
\item Lehne ab, falls eine Kante gleich gefärbte Endpunkte hat.
|
|
\item Sonst akzeptiere.
|
|
\end{itemize}
|
|
Existiert eine 3-Färbung, dann gibt es ein Zertifikat dafür. Dieses wird vom
|
|
Verifizierer akzeptiert und sonst abgelehnt. Prüfung aller Kanten --
|
|
$O(|E|)$. Also liegt die Grad-3-Variante in $\NP$.
|
|
|
|
\textbf{NP-schwer:} Zeige die NP-Schwere durch Reduktion von \problem{3-COLOR}
|
|
auf die Grad-3-Variante. \problem{3-COLOR} ist bereits als NP-vollständig
|
|
bekannt.
|
|
|
|
\textbf{Konstruktion:} Sei $G = (V,E)$ eine \problem{3-COLOR}-Instanz.
|
|
Wir konstruieren daraus einen Graphen $G'$ mit Minimalgrad 3 durch:
|
|
\begin{itemize}
|
|
\item Benutze das Diamant-Gadget $D$: Knoten $p,q,r,s$ mit den Kanten
|
|
$pq, pr, qr, qs, rs$, also $K_4$ ohne die Kante $\{p,s\}$.
|
|
\item Hänge an jeden Knoten $v$ mit $\deg(v) < 3$ \emph{zwei} eigene
|
|
Gadgets an.
|
|
\item Verbinde $v$ je Gadget über die Kanten $\{v,p\}$ und $\{v,s\}$.
|
|
\end{itemize}
|
|
Dann steigt $\deg(v)$ um 4. Alle Gadget-Knoten haben Grad 3: $q$ und $r$ über
|
|
drei Gadget-Kanten, $p$ und $s$ über zwei Gadget-Kanten plus die Kante zu $v$.
|
|
\begin{center}
|
|
\begin{tikzpicture}
|
|
\begin{scope}
|
|
\node[knoten] (lx) at (0,1.6) {$x$};
|
|
\node[kndick] (lv) at (0,0) {$v$};
|
|
\draw (lx)--(lv);
|
|
\node[font=\footnotesize] at (0,-2.3) {$\deg(v)=1<3$ in $G$};
|
|
\end{scope}
|
|
\draw[->,thick] (1.2,0.4) -- (2.4,0.4);
|
|
\begin{scope}[xshift=6.6cm]
|
|
\node[knoten] (x) at (0,1.6) {$x$};
|
|
\node[kndick] (v) at (0,0) {$v$};
|
|
\draw (x)--(v);
|
|
\node[knoten,minimum size=5.5mm] (p) at (-1.2,0) {$p$};
|
|
\node[knoten,minimum size=5.5mm] (q) at (-2.2,0.7) {$q$};
|
|
\node[knoten,minimum size=5.5mm] (r) at (-2.2,-0.7) {$r$};
|
|
\node[knoten,minimum size=5.5mm] (s) at (-3.2,0) {$s$};
|
|
\draw (p)--(q) (p)--(r) (q)--(r) (q)--(s) (r)--(s);
|
|
\draw (v)--(p);
|
|
\draw (v) .. controls (-1.2,-1.6) and (-2.8,-1.6) .. (s);
|
|
\node[knoten,minimum size=5.5mm] (p2) at (1.2,0) {$p'$};
|
|
\node[knoten,minimum size=5.5mm] (q2) at (2.2,0.7) {$q'$};
|
|
\node[knoten,minimum size=5.5mm] (r2) at (2.2,-0.7) {$r'$};
|
|
\node[knoten,minimum size=5.5mm] (s2) at (3.2,0) {$s'$};
|
|
\draw (p2)--(q2) (p2)--(r2) (q2)--(r2) (q2)--(s2) (r2)--(s2);
|
|
\draw (v)--(p2);
|
|
\draw (v) .. controls (1.2,-1.6) and (2.8,-1.6) .. (s2);
|
|
\node[font=\footnotesize, text width=8.6cm, align=center] at (0,-2.55)
|
|
{in $G'$: zwei Diamant-Gadgets ($K_4$ ohne Kante $\{p,s\}$) an $v$ \"uber
|
|
$\{v,p\}$ und $\{v,s\}$; $\deg(v)$ steigt um 4, alle Gadget-Knoten
|
|
haben Grad 3};
|
|
\end{scope}
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{Beweis 3-COLOR nach Grad-3-Variante:}
|
|
\begin{itemize}
|
|
\item Sei $f$ eine 3-Färbung von $G$.
|
|
\item Erweitere $f$ auf jedes Gadget an $v$: Setze $p = s = c$ für eine
|
|
Farbe $c \ne f(v)$.
|
|
\item Das ist erlaubt, denn $p$ und $s$ sind nicht benachbart.
|
|
\item $q$ und $r$ sind zu $p$ und $s$ adjazent, aber $p$ und $s$ tragen
|
|
dieselbe Farbe.
|
|
\item Somit bleiben für $q$ und $r$ zwei Farben frei.
|
|
\item Färbe $q$ und $r$ mit diesen beiden Farben.
|
|
\item Also sind alle Kanten von $G'$ gültig gefärbt, und $G'$ ist 3-färbbar.
|
|
\end{itemize}
|
|
|
|
\textbf{Beweis Grad-3-Variante nach 3-COLOR:}
|
|
\begin{itemize}
|
|
\item Sei $f'$ eine 3-Färbung von $G'$.
|
|
\item Die angehängten Gadgets lassen die Originalkanten unverändert, also
|
|
gilt $E \subseteq E'$.
|
|
\item Somit ist die Einschränkung von $f'$ auf $V$ eine 3-Färbung von $G$.
|
|
\end{itemize}
|
|
|
|
\textbf{Laufzeit:} Pro untergradigem Knoten zwei Gadgets konstanter Größe
|
|
anlegen -- $O(|V|)$.
|
|
|
|
Da die Grad-3-Variante in $\NP$ liegt und NP-schwer ist, folgt: Sie ist
|
|
NP-vollständig. \hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{SAT $\redp$ 3-SAT}{Klausur SS24-N, A2, 10 P.}
|
|
Beweisen Sie: \problem{3-SAT} ist NP-vollständig. Zeigen Sie dafür
|
|
$\problem{SAT} \redp \problem{3-SAT}$; $\problem{3-SAT} \in \NP$ dürfen Sie
|
|
annehmen.
|
|
|
|
\bspkopf{SAT $\redp$ 3-SAT: eine 5er-Klausel zerlegt}
|
|
\textbf{Instanz.} Die Klausel $C=(y_1\vee y_2\vee y_3\vee y_4\vee y_5)$,
|
|
also $\ell=5$ mit neuen Variablen $x_1,x_2$.
|
|
|
|
\textbf{Kern.} $C$ wird ersetzt durch die Kette
|
|
\[
|
|
\underbrace{(y_1\vee y_2\vee x_1)}_{K_1}\wedge
|
|
\underbrace{(\neg x_1\vee y_3\vee x_2)}_{K_2}\wedge
|
|
\underbrace{(\neg x_2\vee y_4\vee y_5)}_{K_3}.
|
|
\]
|
|
Ist $C$ erfüllt, etwa durch $y_3$, dann erfüllt $x_1=\true$, $x_2=\false$
|
|
die Kette: $K_1$ durch $x_1$, $K_2$ durch $y_3$, $K_3$ durch $\neg x_2$.
|
|
|
|
|
|
\musterkopf{Klausel-Splitting}
|
|
Lange Klauseln in Dreier-Klauseln zerlegen: Hilfsvariablen reichen die Wahrheit weiter.
|
|
\begin{itemize}
|
|
\item Lange Klauseln in Ketten zerlegen; kurze Klauseln ($\le 3$ Literale) bleiben unverändert.
|
|
\item Frische Hilfsvariablen verbinden die Kettenglieder.
|
|
\item Beweis hin: ein wahres Originalliteral macht die Kette erfüllbar -- Hilfsvariablen passend setzen.
|
|
\item Beweis zurück: Hilfsvariablen allein erfüllen nicht alle Glieder -- ein Originalliteral ist wahr.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{Konstruktion:} Ersetze jede Klausel $(y_1 \vee \dots \vee y_\ell)$ mit
|
|
$\ell > 3$ durch die Kette
|
|
\[
|
|
(y_1 \vee y_2 \vee x_1) \wedge (\neg x_1 \vee y_3 \vee x_2) \wedge \dots
|
|
\wedge (\neg x_{\ell-3} \vee y_{\ell-1} \vee y_\ell)
|
|
\]
|
|
mit neuen Hilfsvariablen $x_1, \dots, x_{\ell-3}$ (pro Klausel eigene). Kurze
|
|
Klauseln bleiben unverändert.
|
|
\begin{center}
|
|
\begin{tikzpicture}
|
|
\node[draw,rounded corners,inner sep=5pt] (orig) at (0,2.0)
|
|
{$(y_1 \vee y_2 \vee y_3 \vee y_4 \vee y_5)$};
|
|
\draw[->,thick] (0,1.5) -- (0,0.7)
|
|
node[midway,right,font=\footnotesize] {$\ell=5$: neue Variablen $x_1,x_2$};
|
|
\node[draw,rounded corners,inner sep=5pt] (b1) at (-3.7,0)
|
|
{$(y_1 \vee y_2 \vee x_1)$};
|
|
\node at (-1.9,0) {$\wedge$};
|
|
\node[draw,rounded corners,inner sep=5pt] (b2) at (0,0)
|
|
{$(\neg x_1 \vee y_3 \vee x_2)$};
|
|
\node at (1.95,0) {$\wedge$};
|
|
\node[draw,rounded corners,inner sep=5pt] (b3) at (3.85,0)
|
|
{$(\neg x_2 \vee y_4 \vee y_5)$};
|
|
\draw[black!60] (b1.south) to[bend right=40]
|
|
node[below,font=\footnotesize] {$x_1$ geteilt} (b2.south);
|
|
\draw[black!60] (b2.south) to[bend right=40]
|
|
node[below,font=\footnotesize] {$x_2$ geteilt} (b3.south);
|
|
\node[font=\footnotesize] at (0,-1.9)
|
|
{Nachbarklauseln teilen die Hilfsvariable: links positiv ($x_i$), rechts negiert ($\neg x_i$)};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{Beweis hin:}
|
|
\begin{itemize}
|
|
\item Sei die Originalklausel erfüllt, etwa $y_i$ wahr.
|
|
\item Setze $x_1 = \dots = x_{i-2} = \true$ und
|
|
$x_{i-1} = \dots = x_{\ell-3} = \false$.
|
|
\item Dann sind die Kettenklauseln vor der Klausel mit $y_i$ durch ihr
|
|
$x$-Literal erfüllt.
|
|
\item Die Klausel mit $y_i$ ist durch $y_i$ erfüllt.
|
|
\item Die restlichen Kettenklauseln sind durch ihr $\neg x$-Literal erfüllt.
|
|
\item Also ist jede Kettenklausel erfüllt.
|
|
\end{itemize}
|
|
|
|
\textbf{Beweis zurück:}
|
|
\begin{itemize}
|
|
\item Sei die Kette erfüllt.
|
|
\item Angenommen, alle $y_i$ wären falsch.
|
|
\item Dann erzwingt die erste Klausel $x_1 = \true$.
|
|
\item Damit erzwingt die zweite Klausel $x_2 = \true$, induktiv folgt
|
|
$x_{\ell-3} = \true$.
|
|
\item Dann ist die letzte Klausel
|
|
$(\neg x_{\ell-3} \vee y_{\ell-1} \vee y_\ell)$ falsch -- Widerspruch.
|
|
\item Also ist ein $y_i$ wahr und die Originalklausel erfüllt.
|
|
\end{itemize}
|
|
|
|
\textbf{Laufzeit:} Jede Klausel der Länge $\ell \ge 3$ wird zu $\ell-2$
|
|
Dreier-Klauseln, kurze bleiben unverändert -- gesamt $O(n)$ bei
|
|
Eingabelänge $n$.
|
|
|
|
Da \problem{SAT} NP-vollständig ist, $\problem{SAT} \redp \problem{3-SAT}$
|
|
gilt und $\problem{3-SAT} \in \NP$, ist \problem{3-SAT} NP-vollständig.
|
|
\hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{CliqueAndIndependentSet ist NP-schwer}{Klausur SS24-H, A3a, 5 P.}
|
|
\textbf{Problem \problem{CliqueAndIndependentSet}:} Gegeben $G = (V,E)$ und
|
|
$k \ge 1$. Gibt es in $G$ sowohl ein Independent Set (eine Menge von Knoten,
|
|
die paarweise nicht adjazent sind, d.\,h.\ zwischen denen es keine Kanten
|
|
gibt) der Größe $k$ als auch eine Clique der Größe $k$? Zeigen Sie die
|
|
NP-Schwere durch Reduktion eines bekannten NP-schweren Problems.
|
|
|
|
\bspkopf{CliqueAndIndependentSet NP-schwer}
|
|
\textbf{Instanz.} \problem{Clique} am Dreieck $\{1,2,3\}$ mit $k=3$.
|
|
\begin{center}
|
|
\begin{tikzpicture}
|
|
\node[kndick] (a1) at (90:1) {1};
|
|
\node[kndick] (a2) at (210:1) {2};
|
|
\node[kndick] (a3) at (330:1) {3};
|
|
\draw[thick] (a1)--(a2) (a2)--(a3) (a3)--(a1);
|
|
\node[knoten] (u1) at (2.4,0.7) {$u_1$};
|
|
\node[knoten] (u2) at (3.4,0.7) {$u_2$};
|
|
\node[knoten] (u3) at (2.9,-0.4) {$u_3$};
|
|
\node[font=\footnotesize] at (0,-1.7) {$3$-Clique};
|
|
\node[font=\footnotesize] at (2.9,-1.2) {Independent Set $\{u_1,u_2,u_3\}$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{Kern.} Es kommen $k=3$ neue isolierte Knoten $u_1,u_2,u_3$
|
|
hinzu; $k$ bleibt. In $G'$ ist $\{1,2,3\}$ weiterhin eine $3$-Clique,
|
|
und $\{u_1,u_2,u_3\}$ ist ein Independent Set der Größe $3$.
|
|
|
|
|
|
\musterkopf{Knoten anhängen (Padding)}
|
|
Neue Knoten oder Teile anhängen, die die Zusatzforderung gratis erfüllen.
|
|
\begin{itemize}
|
|
\item Originalinstanz unverändert lassen; passende Teile anhängen (isolierte Knoten, universeller Knoten, $K_k$).
|
|
\item Parameter anpassen ($k$ bleibt, $k+1$, \dots).
|
|
\item Beweis hin: Originallösung $+$ angehängte Teile $=$ neue Lösung.
|
|
\item Beweis zurück: die angehängten Teile leisten nicht mehr als geplant -- die Lösung steckt im Original. Ggf.\ Austauschargument.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{NP-schwer:} Zeige, dass \problem{CliqueAndIndependentSet} NP-schwer
|
|
ist durch die Reduktion
|
|
$\problem{Clique} \redp \problem{CliqueAndIndependentSet}$.
|
|
\problem{Clique} ist bereits als NP-vollständig bekannt, also insbesondere
|
|
NP-schwer.
|
|
|
|
\textbf{Konstruktion:} Sei $(G = (V,E), k)$ eine \problem{Clique}-Instanz,
|
|
o.B.d.A.\ $k \ge 2$. (Bei $k = 1$ ist ein einzelner Knoten zugleich Clique und
|
|
Independent Set.) Wir konstruieren daraus eine
|
|
\problem{CliqueAndIndependentSet}-Instanz $(G', k)$ durch:
|
|
\begin{itemize}
|
|
\item $G' = (V \cup \{u_1,\dots,u_k\},\, E)$ mit $k$ neuen isolierten
|
|
Knoten $u_1, \dots, u_k$
|
|
\item $k$ bleibt unverändert
|
|
\end{itemize}
|
|
|
|
\textbf{Beweis Clique nach CliqueAndIndependentSet:}
|
|
\begin{itemize}
|
|
\item Sei $C$ eine $k$-Clique in $G$.
|
|
\item Da keine Kanten entfernt wurden, ist $C$ auch eine $k$-Clique in $G'$.
|
|
\item Die Knoten $u_1, \dots, u_k$ sind isoliert, also paarweise nicht
|
|
adjazent.
|
|
\item Somit ist $\{u_1, \dots, u_k\}$ ein Independent Set der Größe $k$
|
|
in $G'$.
|
|
\item Also gibt es in $G'$ sowohl eine $k$-Clique als auch ein Independent
|
|
Set der Größe $k$.
|
|
\end{itemize}
|
|
|
|
\textbf{Beweis CliqueAndIndependentSet nach Clique:}
|
|
\begin{itemize}
|
|
\item Sei $(G', k)$ eine Ja-Instanz, dann enthält $G'$ insbesondere eine
|
|
$k$-Clique $C'$.
|
|
\item Da $k \ge 2$, hat jeder Knoten in $C'$ mindestens einen Nachbarn
|
|
in $C'$.
|
|
\item Die Knoten $u_1, \dots, u_k$ sind isoliert, haben also keine Nachbarn.
|
|
\item Somit gilt $C' \subseteq V$.
|
|
\item Also ist $C'$ eine $k$-Clique in $G$.
|
|
\end{itemize}
|
|
|
|
\textbf{Laufzeit:} $k$ isolierte Knoten $u_1, \dots, u_k$ anhängen --
|
|
$O(k) \subseteq O(|V|)$.
|
|
|
|
Da \problem{Clique} NP-schwer ist und
|
|
$\problem{Clique} \redp \problem{CliqueAndIndependentSet}$ gilt, folgt:
|
|
\problem{CliqueAndIndependentSet} ist NP-schwer. \hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{SubsetSum $\redp$ Partition}{Vorlesung (Skript)}
|
|
\textbf{Problem \problem{Partition}:} Gegeben Zahlen $c_1, \dots, c_n$. Gibt
|
|
es $S$ mit $\sum_{j\in S} c_j = \frac12 \sum_{j=1}^{n} c_j$?
|
|
|
|
\textbf{Problem \problem{SubsetSum}:} Gegeben Zahlen $c_1, \dots, c_n$ und
|
|
$K$. Gibt es $S$ mit $\sum_{j\in S} c_j = K$?
|
|
|
|
Zeigen Sie, dass \problem{Partition} NP-vollständig ist.
|
|
\emph{Hinweis:} Reduzieren Sie \problem{SubsetSum} auf \problem{Partition}.
|
|
|
|
\bspkopf{SubsetSum $\redp$ Partition: Zahlen einsetzen}
|
|
\textbf{Instanz.} $c = (3,5,8,4)$, $K = 12$ mit Lösung $\{3,5,4\}$:
|
|
$3+5+4 = 12$.
|
|
|
|
\textbf{Kern.} Die Reduktion hängt mit $N = \sum c_j + 1 = 21$ die
|
|
Zusatzzahlen $a = N-K = 9$ und $b = K+1 = 13$ an; wegen $a+b = N+1 > N$
|
|
trennen sich $a$ und $b$ in jeder Lösung. Neue Zahlen $(3,5,8,4,9,13)$ mit
|
|
Hälfte $N = 21$: Die Seite $\{3,5,4\} \cup \{a\}$ summiert $3+5+4+9 = 21$
|
|
-- die Ja-Instanz bleibt Ja.
|
|
|
|
|
|
\musterkopf{Zahlen-Padding}
|
|
Zahlen hinzufügen, die das Zahlenproblem in die gewünschte Form zwingen.
|
|
\begin{itemize}
|
|
\item Ausgleichszahlen so wählen, dass sie nicht auf dieselbe Seite passen (ihre Summe übersteigt die Zielhälfte).
|
|
\item Sie erzwingen die Zielstruktur (gleiche Hälften, feste Kardinalität, festes erstes Element).
|
|
\item Beweis hin: Lösung $+$ Ausgleichszahlen aufteilen, Summen nachrechnen.
|
|
\item Beweis zurück: die Größe erzwingt die Trennung der Ausgleichszahlen -- der Rest ist die Originallösung.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{$\in$ NP:} Eingabe: Zahlen $c_1, \dots, c_n$ und Zertifikat
|
|
$S \subseteq [n]$.
|
|
|
|
Der Verifizierer arbeitet wie folgt:
|
|
\begin{itemize}
|
|
\item Berechne die Gesamtsumme $\Sigma = \sum_{j=1}^{n} c_j$.
|
|
\item Prüfe $\sum_{j\in S} c_j = \Sigma/2$; lehne sonst ab.
|
|
\item Sonst akzeptiere.
|
|
\end{itemize}
|
|
Existiert eine Partitionslösung, dann ist eine ihrer Seiten ein Zertifikat,
|
|
das akzeptiert wird. Sonst wird jedes Zertifikat abgelehnt. Zwei Summen
|
|
bilden und vergleichen -- $O(n)$. Also gilt
|
|
$\problem{Partition} \in \NP$.
|
|
|
|
\textbf{Konstruktion:} Sei $(c_1, \dots, c_n, K)$ eine
|
|
\problem{SubsetSum}-Instanz. Setze $N := \sum_{j=1}^{n} c_j + 1$ und hänge
|
|
zwei Zahlen als Items $n{+}1$ und $n{+}2$ an:
|
|
\[
|
|
c_{n+1} := N - K, \qquad c_{n+2} := K + 1.
|
|
\]
|
|
Die neue Gesamtsumme ist $(N-1) + (N-K) + (K+1) = 2N$, die Hälfte also $N$.
|
|
|
|
\textbf{Schlüsselbeobachtung:} $c_{n+1} + c_{n+2} = N + 1 > N$ -- in jeder
|
|
Partitionslösung liegen die beiden Zusatzzahlen auf \emph{verschiedenen}
|
|
Seiten.
|
|
|
|
\textbf{Beweis hin:}
|
|
\begin{itemize}
|
|
\item Sei $S \subseteq [n]$ eine Menge mit $\sum_{j\in S} c_j = K$.
|
|
\item Setze $S' = S \cup \{n{+}1\}$.
|
|
\item Dann gilt $\sum_{j\in S'} c_j = K + (N-K) = N$.
|
|
\item Also ist $S'$ eine Seite mit halber Gesamtsumme -- eine
|
|
Partitionslösung.
|
|
\end{itemize}
|
|
|
|
\textbf{Beweis zurück:}
|
|
\begin{itemize}
|
|
\item Sei $S' \subseteq [n{+}2]$ eine Seite mit $\sum_{j \in S'} c_j = N$.
|
|
\item Nach der Schlüsselbeobachtung liegen $n{+}1$ und $n{+}2$ auf
|
|
verschiedenen Seiten.
|
|
\item O.B.d.A.\ gilt $n{+}1 \in S'$ und $n{+}2 \notin S'$.
|
|
\item Setze $S = S' \setminus \{n{+}1\}$, also $S \subseteq [n]$.
|
|
\item Dann gilt $\sum_{j \in S} c_j = N - (N-K) = K$ -- also ist $S$ eine
|
|
SubsetSum-Lösung.
|
|
\end{itemize}
|
|
|
|
\textbf{Laufzeit:} Gesamtsumme berechnen und zwei Zahlen anhängen -- $O(n)$.
|
|
|
|
Da \problem{SubsetSum} NP-vollständig ist und $\problem{Partition} \in \NP$,
|
|
ist \problem{Partition} NP-vollständig. \hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{SubsetSum mit Teilbarkeit ist NP-vollständig}{Klausur SS23-H, A5a, 4 P.}
|
|
Beweisen Sie die NP-Vollständigkeit von \problem{SubsetSum}, bei dem jede
|
|
Itemgröße durch 3 oder durch 7 teilbar ist.
|
|
|
|
\bspkopf{SubsetSum mit Teilbarkeit}
|
|
\textbf{Instanz.} \problem{SubsetSum}-Instanz $c=(2,3,5)$, $K=5$; Lösung
|
|
$S=\{1,2\}$ mit $2+3=5$.
|
|
|
|
\textbf{Kern.} Multipliziere alle Größen und $K$ mit $3$: $c'=(6,9,15)$,
|
|
$K'=15$ -- jede Größe ist durch $3$ teilbar. Dieselbe Auswahl liefert
|
|
$6+9=15=K'$.
|
|
|
|
|
|
|
|
\musterkopf{Skalieren/Einbetten}
|
|
Alle Zahlen mit $c$ multiplizieren oder Parameter gleichsetzen -- die Lösungen bleiben exakt dieselben.
|
|
\begin{itemize}
|
|
\item Transformation: $c_i' := c \cdot c_i$ und $K' := c \cdot K$ (bzw.\ Parameter des Zielproblems gleichsetzen).
|
|
\item Die Zusatzeigenschaft folgt direkt aus dem Faktor (teilbar, keine Zweierpotenz).
|
|
\item Beweis hin und zurück: Summen skalieren mit -- Division durch $c$ führt zurück.
|
|
\item Laufzeit: eine Multiplikation pro Zahl -- $O(n)$.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{$\in$ NP:} Eingabe: Zahlen $c_1, \dots, c_n$, Zielwert $K$ und
|
|
Zertifikat $S \subseteq [n]$. Der Verifizierer arbeitet wie folgt:
|
|
\begin{itemize}
|
|
\item Prüfe für jede Größe $c_i$, ob sie durch 3 oder durch 7 teilbar
|
|
ist; lehne sonst ab.
|
|
\item Prüfe, ob $\sum_{i\in S} c_i = K$ gilt; lehne sonst ab.
|
|
\item Sonst akzeptiere.
|
|
\end{itemize}
|
|
\textbf{Korrektheit:} Ist die Instanz eine gültige Variante mit Lösung $S$,
|
|
dann gibt es ein Zertifikat dafür. Dieses wird vom Verifizierer akzeptiert
|
|
und sonst abgelehnt.
|
|
|
|
\textbf{Laufzeit:} Teilbarkeitstests, Summieren und Vergleichen -- $O(n)$.
|
|
Also liegt die Teilbarkeits-Variante in $\NP$.
|
|
|
|
\textbf{NP-schwer:} Zeige, dass die Variante NP-schwer ist durch die
|
|
Reduktion $\problem{SubsetSum} \redp$ Teilbarkeits-Variante.
|
|
\problem{SubsetSum} ist bereits als NP-vollständig bekannt.
|
|
|
|
\textbf{Konstruktion:} Sei $(c_1, \dots, c_n, K)$ eine
|
|
\problem{SubsetSum}-Instanz. Setze $c_i' := 3c_i$ und $K' := 3K$. Alle Größen
|
|
sind durch 3 teilbar -- die Instanz ist gültig.
|
|
|
|
\textbf{Beweis SubsetSum nach Variante:}
|
|
\begin{itemize}
|
|
\item Sei $S$ eine Lösung mit $\sum_{i\in S} c_i = K$.
|
|
\item Dann gilt
|
|
$\sum_{i\in S} c_i' = \sum_{i\in S} 3c_i
|
|
= 3 \sum_{i\in S} c_i = 3K = K'$.
|
|
\item Also ist $S$ eine Lösung der neuen Instanz.
|
|
\end{itemize}
|
|
|
|
\textbf{Beweis Variante nach SubsetSum:}
|
|
\begin{itemize}
|
|
\item Sei $S$ eine Lösung mit $\sum_{i\in S} c_i' = K'$.
|
|
\item Wegen $c_i' = 3c_i$ heißt das
|
|
$3 \sum_{i\in S} c_i = 3K$.
|
|
\item Division durch 3 liefert $\sum_{i\in S} c_i = K$.
|
|
\item Also ist $S$ eine Lösung der Original-Instanz.
|
|
\end{itemize}
|
|
|
|
\textbf{Laufzeit:} jede der $n$ Zahlen und $K$ mit 3 multiplizieren --
|
|
$O(n)$.
|
|
|
|
Da die Variante in $\NP$ liegt und NP-schwer ist, folgt: Sie ist
|
|
NP-vollständig. \hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{AtMostTwoPerSize-SubsetSum ist NP-schwer}{Klausur SS24-N, A3b, 5 P.}
|
|
\textbf{Problem \problem{AtMostTwoPerSize-SubsetSum}:} Zielwert $T > 0$, $n$
|
|
Items mit Größen $a_i \in \mathbb{N}_{>0}$; jede Größe tritt höchstens zweimal
|
|
auf. Gibt es $S$ mit $\sum_{i\in S} a_i = T$? Zeigen Sie die NP-Schwere durch
|
|
Reduktion eines bekannten NP-schweren Problems.
|
|
|
|
\emph{Hinweis:} Bei \problem{3-ExactCover} sind ein Universum $U$ mit
|
|
$|U| = 3m$ und Dreiermengen $S_1, \dots, S_n \subseteq U$ gegeben; gefragt ist
|
|
eine Auswahl von Mengen, die jedes Element \emph{genau einmal} überdeckt. Die
|
|
Vorlesung reduziert \problem{3-EC} auf \problem{SubsetSum} über die Kodierung
|
|
$c_j = \sum_{u_i \in S_j} (n+1)^{i-1}$ mit Ziel
|
|
$K = \sum_{j=0}^{3m-1} (n+1)^j$.
|
|
|
|
\bspkopf{AtMostTwoPerSize-SubsetSum}
|
|
\textbf{Instanz.} \problem{3-ExactCover} mit $U=\{u_1,\dots,u_6\}$ und den
|
|
Mengen $S_1=\{u_1,u_2,u_3\}$, $S_2=\{u_4,u_5,u_6\}$, $S_3=\{u_1,u_2,u_4\}$;
|
|
exakte Überdeckung $\{S_1,S_2\}$.
|
|
|
|
\textbf{Kern.} Kodiere jede Menge in Basis $n+1=4$:
|
|
$c_j=\sum_{u_i\in S_j}4^{\,i-1}$, Ziel $K=\sum_{j=0}^{5}4^{\,j}=1365$.
|
|
\begin{center}
|
|
\small
|
|
\begin{tabular}{l cccccc r}
|
|
\toprule
|
|
& \multicolumn{6}{c}{Ziffer zu $u_i$ (Basis $4$)} & \\
|
|
\cmidrule(lr){2-7}
|
|
& $u_6$ & $u_5$ & $u_4$ & $u_3$ & $u_2$ & $u_1$ & $c_j$ \\
|
|
\midrule
|
|
$S_1=\{u_1,u_2,u_3\}$ & 0 & 0 & 0 & 1 & 1 & 1 & $21$ \\
|
|
$S_2=\{u_4,u_5,u_6\}$ & 1 & 1 & 1 & 0 & 0 & 0 & $1344$ \\
|
|
$S_3=\{u_1,u_2,u_4\}$ & 0 & 0 & 1 & 0 & 1 & 1 & $69$ \\
|
|
\midrule
|
|
Ziel $K$ & 1 & 1 & 1 & 1 & 1 & 1 & $1365$ \\
|
|
\bottomrule
|
|
\end{tabular}
|
|
\end{center}
|
|
Verschiedene Mengen wählen verschiedene Potenzen, also sind $c_1,c_2,c_3$
|
|
paarweise verschieden -- jede Größe tritt nur einmal auf. Die Überdeckung
|
|
$\{S_1,S_2\}$ liefert $c_1+c_2=21+1344=1365=K$.
|
|
|
|
|
|
\musterkopf{Basis-Kodierung}
|
|
Kombinatorik in Ziffern: jedes Element bekommt eine Stelle in einer großen Basis.
|
|
\begin{itemize}
|
|
\item Basis größer als jede mögliche Ziffernsumme wählen -- kein Übertrag.
|
|
\item Objekt $\to$ Zahl: Ziffer 1 an den Stellen seiner Elemente.
|
|
\item Ziel $K$: an jeder Stelle die geforderte Ziffer.
|
|
\item Kein Übertrag $\Rightarrow$ die Auswahl erfüllt jede Stelle einzeln $\leftrightarrow$ exakte Überdeckung.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{Konstruktion:} Sei $(U, S_1, \dots, S_n)$ eine
|
|
\problem{3-ExactCover}-Instanz mit $U = \{u_1, \dots, u_{3m}\}$, o.B.d.A.\
|
|
$S_j$ paarweise verschieden (Duplikate vorab löschen). Wir konstruieren
|
|
daraus in Basis $n+1$ eine SubsetSum-Instanz durch:
|
|
\begin{itemize}
|
|
\item $c_j = \sum_{u_i \in S_j} (n+1)^{i-1}$ für $j = 1, \dots, n$ --
|
|
Ziffer 1 an den Stellen der drei Elemente von $S_j$
|
|
\item $K = \sum_{j=0}^{3m-1} (n+1)^j$ -- an jeder Stelle eine 1
|
|
\end{itemize}
|
|
|
|
\textbf{Beweis \problem{3-ExactCover} nach
|
|
\problem{AtMostTwoPerSize-SubsetSum}:}
|
|
\begin{itemize}
|
|
\item Sei $\mathcal{S}$ eine exakte Überdeckung.
|
|
\item Dann wird jedes Element $u_i$ von genau einer Menge in $\mathcal{S}$
|
|
überdeckt.
|
|
\item Somit kommt in der Summe $\sum_{S_j \in \mathcal{S}} c_j$ jede Potenz
|
|
$(n+1)^{i-1}$ genau einmal vor.
|
|
\item Also gilt
|
|
\[
|
|
\sum_{S_j \in \mathcal{S}} c_j \;=\; \sum_{j=0}^{3m-1} (n+1)^j \;=\; K.
|
|
\]
|
|
\end{itemize}
|
|
|
|
\textbf{Beweis \problem{AtMostTwoPerSize-SubsetSum} nach
|
|
\problem{3-ExactCover}:}
|
|
\begin{itemize}
|
|
\item Sei $S$ eine Auswahl mit $\sum_{j\in S} c_j = K$.
|
|
\item An jeder Ziffernstelle addieren sich höchstens $n$ Einsen, denn es
|
|
gibt nur $n$ Mengen.
|
|
\item Da die Basis $n+1$ ist, entsteht beim Addieren kein Übertrag.
|
|
\item In $K$ hat jede der $3m$ Ziffernstellen den Wert 1.
|
|
\item Somit trägt zu jeder Ziffernstelle genau eine gewählte Menge bei.
|
|
\item Also überdecken die gewählten Mengen jedes Element genau einmal.
|
|
\item Damit ist die Auswahl eine exakte Überdeckung.
|
|
\end{itemize}
|
|
|
|
\textbf{Laufzeit:} Duplikate durch paarweisen Vergleich der $n$ Mengen
|
|
entfernen -- $O(n^2)$ Vergleiche. Pro Menge drei Potenzen von $n+1$ addieren
|
|
und $K$ aus $3m$ Potenzen aufsummieren -- $O(n+m)$ Additionen polynomiell
|
|
langer Zahlen.
|
|
|
|
Da \problem{3-ExactCover} NP-schwer ist, ist
|
|
\problem{AtMostTwoPerSize-SubsetSum} NP-schwer. \hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{VertexCover ist NP-vollständig}{Präsenz 10.2 / Hausaufgabe 9.1}
|
|
Zeigen Sie, dass \problem{VertexCover} NP-vollständig ist.
|
|
\emph{Hinweis:} Reduzieren Sie \problem{Clique} auf \problem{VertexCover}.
|
|
|
|
\bspkopf{VertexCover NP-vollständig}
|
|
\textbf{Instanz.} \problem{Clique} am folgenden Graphen $G$ mit $n=4$
|
|
Knoten.
|
|
\begin{center}
|
|
\begin{tikzpicture}
|
|
\begin{scope}
|
|
\node[kndick] (a1) at (0,1.4) {1};
|
|
\node[kndick] (a2) at (-1.2,0) {2};
|
|
\node[kndick] (a3) at (1.2,0) {3};
|
|
\node[knoten] (a4) at (0,-1.4) {4};
|
|
\draw[thick] (a1)--(a2) (a1)--(a3) (a2)--(a3);
|
|
\draw (a1)--(a4);
|
|
\node[font=\footnotesize] at (0,-2.2) {$G$: Clique $\{1,2,3\}$, $k=3$};
|
|
\end{scope}
|
|
\draw[->,thick] (2.1,0) -- (3.7,0)
|
|
node[midway,above,font=\footnotesize] {komplement.};
|
|
\begin{scope}[xshift=5.8cm]
|
|
\node[knoten] (b1) at (0,1.4) {1};
|
|
\node[knoten] (b2) at (-1.2,0) {2};
|
|
\node[knoten] (b3) at (1.2,0) {3};
|
|
\node[kndick] (b4) at (0,-1.4) {4};
|
|
\draw (b2)--(b4) (b3)--(b4);
|
|
\node[font=\footnotesize] at (0,-2.2) {$G'$: VC $\{4\}$, $k'=1$};
|
|
\end{scope}
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{Kern.} Komplementieren liefert $G'$ mit genau den Nicht-Kanten
|
|
von $G$ und $k' = n-k = 1$. Die Clique $\{1,2,3\}$ wird zum Vertex Cover
|
|
$V\setminus C=\{4\}$: Knoten $4$ deckt beide Kanten von $G'$.
|
|
|
|
|
|
\musterkopf{Umdeuten/Komplement}
|
|
Gleiche Instanz, neue Brille: Komplement von Graph oder Lösung.
|
|
\begin{itemize}
|
|
\item Instanz komplementieren (Kanten $\leftrightarrow$ Nicht-Kanten) oder die Lösung als Rest $V \setminus C$ lesen.
|
|
\item Parameter umrechnen ($k' = n - k$).
|
|
\item Beweis hin und zurück: Definitionen ineinander übersetzen -- Clique $\leftrightarrow$ unabhängig $\leftrightarrow$ überdeckend.
|
|
\item Laufzeit: Komplement bilden -- $O(|V|^2)$.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{$\in$ NP:} Eingabe: Graph $G = (V,E)$, Zahl $k$ und Zertifikat
|
|
$C \subseteq V$. Der Verifizierer arbeitet wie folgt:
|
|
\begin{itemize}
|
|
\item Falls $|C| > k$, lehne ab.
|
|
\item Prüfe für jede Kante $\{u,v\} \in E$, ob $u \in C$ oder $v \in C$ gilt.
|
|
\item Lehne ab, falls das für eine Kante fehlschlägt.
|
|
\item Sonst akzeptiere.
|
|
\end{itemize}
|
|
Existiert ein Vertex Cover $C$ mit $|C| \le k$, dann gibt es ein Zertifikat
|
|
dafür. Dieses wird vom Verifizierer akzeptiert und sonst abgelehnt.
|
|
Größen- und Kantenprüfung laufen in $O(|V| + |E|)$.
|
|
Also gilt $\problem{VertexCover} \in \NP$.
|
|
|
|
\textbf{NP-schwer:} Zeige, dass \problem{VertexCover} NP-schwer ist durch die
|
|
Reduktion $\problem{Clique} \redp \problem{VertexCover}$. \problem{Clique}
|
|
ist bereits als NP-vollständig bekannt.
|
|
|
|
\textbf{Konstruktion:} Sei $(G = (V,E), k)$ eine \problem{Clique}-Instanz mit
|
|
$n = |V|$ (o.B.d.A.\ $k \le n$). Wir konstruieren daraus eine
|
|
\problem{VertexCover}-Instanz $(G' = (V, E'),\, k')$ durch:
|
|
\begin{itemize}
|
|
\item $E' = \binom{V}{2} \setminus E$, also genau die Nicht-Kanten von $G$
|
|
\item $k' = n - k$
|
|
\end{itemize}
|
|
So wird $G$ zum Komplementgraphen $G'$ invertiert.
|
|
\begin{center}
|
|
\begin{tikzpicture}
|
|
\begin{scope}
|
|
\node[kndick] (a1) at (90:1.3) {1};
|
|
\node[kndick] (a2) at (162:1.3) {2};
|
|
\node[kndick] (a3) at (18:1.3) {3};
|
|
\node[knoten] (a4) at (234:1.3) {4};
|
|
\node[knoten] (a5) at (306:1.3) {5};
|
|
\draw[thick] (a1)--(a2) (a1)--(a3) (a2)--(a3);
|
|
\draw (a1)--(a4) (a3)--(a5);
|
|
\node[font=\footnotesize] at (0,-2.1) {Clique $C=\{1,2,3\}$ in $G$};
|
|
\end{scope}
|
|
\draw[->,thick] (2.2,0) -- (3.8,0)
|
|
node[midway,above,font=\footnotesize] {komplementieren};
|
|
\begin{scope}[xshift=6.4cm]
|
|
\node[knoten] (b1) at (90:1.3) {1};
|
|
\node[knoten] (b2) at (162:1.3) {2};
|
|
\node[knoten] (b3) at (18:1.3) {3};
|
|
\node[kndick] (b4) at (234:1.3) {4};
|
|
\node[kndick] (b5) at (306:1.3) {5};
|
|
\draw (b1)--(b5) (b2)--(b4) (b2)--(b5) (b3)--(b4) (b4)--(b5);
|
|
\node[font=\footnotesize] at (0,-2.1)
|
|
{VC $V\setminus C=\{4,5\}$ in $G'$, $\ n-k = 5-3 = 2$};
|
|
\end{scope}
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{Beweis Clique nach VertexCover:}
|
|
\begin{itemize}
|
|
\item Sei $C$ eine Clique in $G$ mit $|C| \ge k$.
|
|
\item Setze $W = V \setminus C$, dann gilt $|W| \le n - k = k'$.
|
|
\item In $G$ sind alle Kanten innerhalb von $C$ vorhanden.
|
|
\item Somit hat $G'$ keine Kante mit beiden Endpunkten in $C$ -- also ist
|
|
$C$ unabhängig in $G'$.
|
|
\item Also hat jede Kante von $G'$ einen Endpunkt in $W$.
|
|
\item Damit ist $W$ ein Vertex Cover von $G'$ mit $|W| \le k'$.
|
|
\end{itemize}
|
|
|
|
\textbf{Beweis VertexCover nach Clique:}
|
|
\begin{itemize}
|
|
\item Sei $W$ ein Vertex Cover von $G'$ mit $|W| \le k'$.
|
|
\item Setze $C = V \setminus W$, dann gilt $|C| \ge n - k' = k$.
|
|
\item Sei $\{u,v\} \subseteq C$ ein beliebiges Knotenpaar.
|
|
\item Da $u, v \notin W$ und $W$ jede Kante von $G'$ deckt, gilt
|
|
$\{u,v\} \notin E'$.
|
|
\item Somit gilt $\{u,v\} \in E$, denn $E'$ enthält genau die Nicht-Kanten
|
|
von $G$.
|
|
\item Also ist $C$ eine Clique in $G$ mit $|C| \ge k$.
|
|
\end{itemize}
|
|
|
|
\textbf{Laufzeit:} Alle Knotenpaare durchgehen und die Kanten invertieren --
|
|
$O(|V|^2)$.
|
|
|
|
Da $\problem{VertexCover} \in \NP$ und NP-schwer ist, folgt:
|
|
\problem{VertexCover} ist NP-vollständig. \hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{TSP ist nicht approximierbar}{Klausur SS23-H, A5c, 7 P.}
|
|
\textbf{Problem \problem{TSP}:} Gegeben $n$ Städte mit beliebigen Distanzen
|
|
$d(u,v) > 0$ -- \emph{allgemeines} TSP, die Dreiecksungleichung wird
|
|
\emph{nicht} vorausgesetzt. Gesucht ist eine Rundtour minimaler Länge durch
|
|
alle Städte. Ein Algorithmus $A$ hat Güte $\alpha$, wenn
|
|
$A(I) \le \alpha \cdot \mathrm{OPT}(I)$ für alle Instanzen $I$ gilt.
|
|
|
|
Zeigen Sie: Für kein $\alpha > 1$ gibt es einen Approximationsalgorithmus mit
|
|
Güte $\alpha$ für \problem{TSP}, außer $P = NP$.
|
|
|
|
\bspkopf{TSP ist nicht approximierbar}
|
|
\textbf{Instanz.} \problem{HamiltonianCycle}-Graphen mit $n=4$ Knoten,
|
|
angenommene Güte $\alpha=2$: Kante $\to$ Distanz $1$, Nicht-Kante $\to$
|
|
$\alpha n+1=9$ (gestrichelt).
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=1.05]
|
|
\begin{scope}
|
|
\node[knoten,font=\small] (1) at (0,1.3) {$1$};
|
|
\node[knoten,font=\small] (2) at (1.3,1.3) {$2$};
|
|
\node[knoten,font=\small] (3) at (1.3,0) {$3$};
|
|
\node[knoten,font=\small] (4) at (0,0) {$4$};
|
|
\draw[thick] (1)--(2) node[midway,fill=white,inner sep=1pt,font=\scriptsize]{$1$};
|
|
\draw[thick] (2)--(3) node[midway,fill=white,inner sep=1pt,font=\scriptsize]{$1$};
|
|
\draw[thick] (3)--(4) node[midway,fill=white,inner sep=1pt,font=\scriptsize]{$1$};
|
|
\draw[thick] (4)--(1) node[midway,fill=white,inner sep=1pt,font=\scriptsize]{$1$};
|
|
\draw[dashed,black!55] (1)--(3) node[pos=0.3,fill=white,inner sep=1pt,font=\scriptsize]{$9$};
|
|
\draw[dashed,black!55] (2)--(4) node[pos=0.3,fill=white,inner sep=1pt,font=\scriptsize]{$9$};
|
|
\node[font=\footnotesize] at (0.65,-0.9) {Ja: $\OPT=4$};
|
|
\end{scope}
|
|
\begin{scope}[xshift=4.6cm]
|
|
\node[knoten,font=\small] (1) at (0,1.3) {$1$};
|
|
\node[knoten,font=\small] (2) at (1.3,1.3) {$2$};
|
|
\node[knoten,font=\small] (3) at (1.3,0) {$3$};
|
|
\node[knoten,font=\small] (4) at (0,0) {$4$};
|
|
\draw[thick] (1)--(2) node[midway,fill=white,inner sep=1pt,font=\scriptsize]{$1$};
|
|
\draw[thick] (2)--(3) node[midway,fill=white,inner sep=1pt,font=\scriptsize]{$1$};
|
|
\draw[thick] (3)--(4) node[midway,fill=white,inner sep=1pt,font=\scriptsize]{$1$};
|
|
\draw[thick] (2)--(4) node[pos=0.3,fill=white,inner sep=1pt,font=\scriptsize]{$1$};
|
|
\draw[dashed,black!55] (1)--(3) node[pos=0.3,fill=white,inner sep=1pt,font=\scriptsize]{$9$};
|
|
\draw[dashed,black!55] (1)--(4) node[near start,fill=white,inner sep=1pt,font=\scriptsize]{$9$};
|
|
\node[font=\footnotesize] at (0.65,-0.9) {Nein: $\OPT\ge12$};
|
|
\end{scope}
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
\textbf{Kern.} Links gibt es einen Hamiltonkreis: $\OPT=n=4$, also
|
|
$A(I)\le\alpha n=8$. Rechts hat Knoten $1$ Grad $1$, also keinen: jede Tour
|
|
benutzt eine Nicht-Kante, $\OPT\ge 9+3\cdot 1=12>8$, somit $A(I)>8$. Der
|
|
Test \glqq$A(I)\le 8$?\grqq{} entscheidet \problem{HamiltonianCycle}.
|
|
|
|
|
|
\musterkopf{Gap strecken}
|
|
Approximation ausschließen: Ja und Nein so weit auseinanderziehen, dass ein Approximierer sie trennen würde.
|
|
\begin{itemize}
|
|
\item Ja-Fall billig kodieren (Kante $\to$ Distanz 1, Tour der Länge $n$).
|
|
\item Nein-Fall teuer machen (Nicht-Kante $\to$ Distanz $\alpha n + 1$).
|
|
\item Ein $\alpha$-Approximierer bliebe im Ja-Fall unter der Nein-Schwelle.
|
|
\item Er entschiede das NP-schwere Problem exakt -- Widerspruch, außer $P = NP$.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
Angenommen, es gäbe einen polynomiellen Algorithmus $A$ mit
|
|
$A(I) \le \alpha \cdot \mathrm{OPT}(I)$ für ein festes $\alpha > 1$. Wir lösen
|
|
damit \problem{HamiltonianCycle} in Polynomialzeit:
|
|
|
|
\textbf{Konstruktion:} Zu $G = (V,E)$ mit $n = |V|$ baue die TSP-Instanz mit
|
|
Städten $V$ und
|
|
\[
|
|
d(u,v) = \begin{cases} 1 & \{u,v\} \in E,\\ \alpha n + 1 & \text{sonst.}
|
|
\end{cases}
|
|
\]
|
|
|
|
\textbf{Fall 1: $G$ hat einen Hamiltonkreis.} Dann ist $\mathrm{OPT} = n$
|
|
(Tour nur über echte Kanten), also $A(I) \le \alpha n$.
|
|
|
|
\textbf{Fall 2: $G$ hat keinen Hamiltonkreis.} Dann benutzt jede Tour
|
|
mindestens eine Nicht-Kante, also
|
|
$\mathrm{OPT} \ge (\alpha n + 1) + (n-1) > \alpha n$, und damit auch
|
|
$A(I) > \alpha n$.
|
|
|
|
Der Vergleich \glqq$A(I) \le \alpha n$?\grqq{} entscheidet also
|
|
\problem{HamiltonianCycle} in Polynomialzeit. Da \problem{HamiltonianCycle}
|
|
NP-vollständig ist, folgt $P = NP$. Also existiert ein solcher Algorithmus nur,
|
|
wenn $P = NP$. \hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{$k$-CLIQUE-DEG-3 ist NP-vollständig}{Klausur SS25-H, A3, 2+8 P.}
|
|
\textbf{Problem $k$-\problem{CLIQUE-DEG-3}:} Gegeben $G = (V,E)$ mit
|
|
$\deg(v) \ge 3$ für alle $v \in V$, und $k \in \mathbb{N}_{>0}$. Existiert eine
|
|
Clique $C$ mit $|C| \ge k$?
|
|
\begin{enumerate}
|
|
\item[a)] Zeigen Sie, dass $k$-\problem{Clique} für $k \in \{1,2,3,4\}$
|
|
polynomiell lösbar ist.
|
|
\item[b)] Zeigen Sie, dass $k$-\problem{CLIQUE-DEG-3} NP-vollständig ist.
|
|
\end{enumerate}
|
|
|
|
\bspkopf{$k$-CLIQUE-DEG-3}
|
|
\textbf{Instanz.} $k$-\problem{Clique} am folgenden $G$: ein $K_5$ auf
|
|
$\{1,\dots,5\}$ plus Pendant-Knoten $6$ mit $\deg(6) = 1 < 3$, gesucht
|
|
$k = 5$.
|
|
\begin{center}
|
|
\begin{tikzpicture}[scale=0.95]
|
|
\foreach \i in {1,...,5}
|
|
\node[knoten,font=\small] (v\i) at ({90+(\i-1)*72}:1.15) {$\i$};
|
|
\foreach \a/\b in {1/2,1/3,1/4,1/5,2/3,2/4,2/5,3/4,3/5,4/5}
|
|
\draw (v\a)--(v\b);
|
|
\node[knoten,font=\small] (v6) at (2.5,1.9) {$6$};
|
|
\draw (v1)--(v6);
|
|
\node[knoten,minimum size=5mm,font=\scriptsize] (a) at (3.9,2.5) {$a_6$};
|
|
\node[knoten,minimum size=5mm,font=\scriptsize] (b) at (4.5,1.75) {$b_6$};
|
|
\node[knoten,minimum size=5mm,font=\scriptsize] (c) at (3.8,1.2) {$c_6$};
|
|
\draw[black!55] (v6)--(a) (v6)--(b) (v6)--(c) (a)--(b) (a)--(c) (b)--(c);
|
|
\node[font=\footnotesize, text width=8.5cm, align=center] at (1.2,-1.9)
|
|
{gezeichnet: das private $K_4$ an Knoten $6$; an jedem der Knoten
|
|
$1,\dots,5$ hängt ebenso eines};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{Kern.} An jeden Knoten $v$ wird ein privates $K_4$ auf
|
|
$\{v,a_v,b_v,c_v\}$ angehängt; $k$ bleibt. In $G'$ haben alle Knoten
|
|
Grad $\ge 3$, und die $5$-Clique $\{1,\dots,5\}$ bleibt erhalten.
|
|
Gadget-Cliquen haben Größe $\le 4 < k$, erzeugen also keine neue
|
|
$5$-Clique.
|
|
|
|
|
|
\musterkopf{Spezialfall vorab lösen}
|
|
Kleine Parameter direkt lösen, damit die Reduktion nur den harten Fall behandeln muss.
|
|
\begin{itemize}
|
|
\item Fallunterscheidung: für $k \le c$ ist das Problem polynomiell lösbar (alle Mengen testen).
|
|
\item Antwort als feste triviale Ja- bzw.\ Nein-Instanz ausgeben.
|
|
\item Für große $k$: die Instanz (angepasst) durchreichen.
|
|
\item Korrektheit und Laufzeit in beiden Zweigen begründen.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{a)} Algorithmus für festes $k \le 4$:
|
|
\begin{itemize}
|
|
\item Teste jede Knotenmenge $C \subseteq V$ mit $|C| = k$.
|
|
\item Prüfe per Adjazenzmatrix, ob alle Paare in $C$ verbunden sind.
|
|
\item Akzeptiere, sobald eine Menge alle Prüfungen besteht; sonst lehne ab.
|
|
\end{itemize}
|
|
\textbf{Korrektheit:} Der Algorithmus testet alle Kandidaten. Er akzeptiert
|
|
also genau dann, wenn eine $k$-Clique existiert.
|
|
|
|
\textbf{Laufzeit:} Es gibt $\binom{|V|}{k} = O(|V|^k) \subseteq O(|V|^4)$
|
|
Mengen. Pro Menge höchstens $\binom{4}{2} = 6$ Paar-Prüfungen in $O(1)$ --
|
|
gesamt $O(|V|^4)$, also polynomiell lösbar.
|
|
|
|
\textbf{b)} \textbf{$\in$ NP:} Eingabe: Graph $G = (V,E)$, Zahl $k$ und
|
|
Zertifikat $C \subseteq V$. Der Verifizierer arbeitet wie folgt:
|
|
\begin{itemize}
|
|
\item Prüfe für jeden Knoten $v \in V$, ob $\deg(v) \ge 3$ gilt; lehne
|
|
sonst ab.
|
|
\item Falls $|C| < k$, lehne ab.
|
|
\item Prüfe für jedes Paar $\{x,y\} \subseteq C$, ob $\{x,y\} \in E$ gilt.
|
|
\item Lehne ab, falls für ein Paar $\{x,y\} \notin E$ gilt.
|
|
\item Sonst akzeptiere.
|
|
\end{itemize}
|
|
\textbf{Korrektheit:} Ist die Instanz gültig und hat $G$ eine Clique $C$ mit
|
|
$|C| \ge k$, dann gibt es ein Zertifikat dafür. Dieses wird vom Verifizierer
|
|
akzeptiert und sonst abgelehnt.
|
|
|
|
\textbf{Laufzeit:} Gradprüfung $O(|V| + |E|)$, Größen- und Paar-Prüfung
|
|
$O(|V|^2)$ -- gesamt $O(|V|^2)$. Also gilt
|
|
$k\text{-}\problem{CLIQUE-DEG-3} \in \NP$.
|
|
|
|
\textbf{NP-schwer:} Zeige, dass $k$-\problem{CLIQUE-DEG-3} NP-schwer ist durch
|
|
die Reduktion
|
|
$k\text{-}\problem{Clique} \redp k\text{-}\problem{CLIQUE-DEG-3}$.
|
|
$k$-\problem{Clique} ist bereits als NP-vollständig bekannt.
|
|
|
|
\textbf{Konstruktion:} Sei $(G = (V,E), k)$ eine $k$-\problem{Clique}-Instanz,
|
|
o.B.d.A.\ $k \ge 5$. Wir konstruieren daraus eine
|
|
$k$-\problem{CLIQUE-DEG-3}-Instanz $(G', k)$ durch:
|
|
\begin{itemize}
|
|
\item $V' = V \cup \{a_v, b_v, c_v \mid v \in V\}$
|
|
\item $E' = E \cup \{\{x,y\} \mid v \in V,\ x, y \in \{v, a_v, b_v, c_v\},\
|
|
x \ne y\}$
|
|
\item $k' = k$
|
|
\end{itemize}
|
|
Dann gilt $\deg(v) \ge 3$ für alle Knoten: Jedes $v \in V$ hat die drei
|
|
Nachbarn $a_v, b_v, c_v$, und Gadget-Knoten haben Grad genau 3. Die Instanz
|
|
ist gültig.
|
|
\begin{center}
|
|
\begin{tikzpicture}
|
|
\begin{scope}
|
|
\node[knoten] (lx) at (-1.2,1.2) {$x$};
|
|
\node[knoten] (ly) at (1.2,1.2) {$y$};
|
|
\node[kndick] (lv) at (0,0) {$v$};
|
|
\draw (lv)--(lx) (lv)--(ly);
|
|
\node[font=\footnotesize, text width=3cm, align=center] at (0,-2.9)
|
|
{Knoten $v$ in $G$};
|
|
\end{scope}
|
|
\draw[->,thick] (2.0,-0.4) -- (3.2,-0.4);
|
|
\begin{scope}[xshift=6.4cm]
|
|
\node[knoten] (x) at (-1.2,1.2) {$x$};
|
|
\node[knoten] (y) at (1.2,1.2) {$y$};
|
|
\node[kndick] (v) at (0,0) {$v$};
|
|
\draw[black!50] (v)--(x) (v)--(y);
|
|
\node[kndick,font=\small] (a) at (-1.1,-1.75) {$a_v$};
|
|
\node[kndick,font=\small] (b) at (1.1,-1.75) {$b_v$};
|
|
\node[kndick,font=\small] (c) at (0,-1.05) {$c_v$};
|
|
\draw[thick] (v)--(a) (v)--(b) (a)--(b) (c)--(v) (c)--(a) (c)--(b);
|
|
\node[font=\footnotesize, text width=7.6cm, align=center] at (0,-2.9)
|
|
{in $G'$: privates $K_4$ auf $\{v,a_v,b_v,c_v\}$; $a_v,b_v,c_v$ sind
|
|
nur mit $v$ und untereinander verbunden (Grad genau 3)};
|
|
\end{scope}
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{Beweis $k$-Clique nach $k$-CLIQUE-DEG-3} (Fall $k \ge 5$):
|
|
\begin{itemize}
|
|
\item Sei $C$ eine $k$-Clique in $G$.
|
|
\item Da keine Kanten entfernt wurden, ist $C$ auch eine $k$-Clique in $G'$.
|
|
\end{itemize}
|
|
|
|
\textbf{Beweis $k$-CLIQUE-DEG-3 nach $k$-Clique} (Fall $k \ge 5$):
|
|
\begin{itemize}
|
|
\item Sei $C'$ eine $k$-Clique in $G'$.
|
|
\item Jeder Knoten in $C'$ hat mindestens $k-1 \ge 4$ Nachbarn in $C'$.
|
|
\item Gadget-Knoten haben Grad 3. Somit liegt keiner in $C'$.
|
|
\item Also gilt $C' \subseteq V$.
|
|
\item Da zwischen Knoten aus $V$ keine neuen Kanten hinzugekommen sind,
|
|
ist $C'$ eine $k$-Clique in $G$.
|
|
\end{itemize}
|
|
Im Fall $k \le 4$ wird $(G, k)$ direkt gelöst, und die ausgegebene triviale
|
|
Instanz hat dieselbe Antwort.
|
|
|
|
\textbf{Laufzeit:} Pro Knoten ein Gadget konstanter Größe anlegen --
|
|
$O(|V|)$. Im Fall $k \le 4$ alle Knotenmengen testen -- $O(|V|^4)$.
|
|
|
|
Da $k\text{-}\problem{CLIQUE-DEG-3} \in \NP$ und NP-schwer ist, folgt:
|
|
$k$-\problem{CLIQUE-DEG-3} ist NP-vollständig. \hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
% ##################################################################
|
|
\section{Verfahren und Einzelmuster: einzeln lernen}
|
|
% ##################################################################
|
|
|
|
% ==================================================================
|
|
\katkopf{Knapsack: Greedy und ModifiedGreedy}{Klausur SS23-H, A1, 3+2+5 P.}
|
|
Rucksack-Instanz mit Kapazität $B = 16$, Items als $(p_i, w_i)$:
|
|
\[
|
|
I = [(1,4),\,(1,1),\,(1,3),\,(11,13),\,(3,3),\,(5,6),\,(1,5)]
|
|
\]
|
|
\begin{enumerate}
|
|
\item[a)] Wenden Sie Greedy an (mit Begründung der Auswahl). Lösungswert?
|
|
\item[b)] Wenden Sie ModifiedGreedy an. Wie ändert sich die Lösung?
|
|
\item[c)] Güte von ModifiedGreedy? Idee zur Verbesserung auf $\frac32$ bzw.\
|
|
$\frac43$?
|
|
\end{enumerate}
|
|
|
|
\emph{Hinweis:} Greedy sortiert die Items absteigend nach Profitdichte
|
|
$p_i/w_i$ und packt in dieser Reihenfolge jedes Item ein, das noch passt.
|
|
ModifiedGreedy gibt das Bessere aus Greedy-Lösung und profitreichstem
|
|
Einzel-Item aus.
|
|
|
|
\musterkopf{Verfahren Greedy/ModifiedGreedy}
|
|
Knapsack-Heuristik: nach Profitdichte packen; MGA sichert mit dem besten Einzel-Gegenstand ab.
|
|
\begin{itemize}
|
|
\item Nach $p_i/w_i$ absteigend sortieren.
|
|
\item Der Reihe nach packen, was noch passt; Rest überspringen.
|
|
\item $\mathrm{MGA} = \max\{\text{Greedy-Wert},\ \text{bester Einzel-Gegenstand}\}$.
|
|
\item In der Klausur: Schrittfolge mit Restkapazität notieren.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{a)} Profitdichten $p_i/w_i$: $0{,}25;\ 1;\ 0{,}33;\ 0{,}85;\ 1;\
|
|
0{,}83;\ 0{,}2$. Absteigend sortiert: $(1,1), (3,3), (11,13), (5,6), (1,3),
|
|
(1,4), (1,5)$. Einpacken (Restkapazität beachten):
|
|
\begin{itemize}
|
|
\item $(1,1)$ einpacken -- Restkapazität 15.
|
|
\item $(3,3)$ einpacken -- Restkapazität 12.
|
|
\item $(11,13)$ passt nicht ($13 > 12$).
|
|
\item $(5,6)$ einpacken -- Restkapazität 6.
|
|
\item $(1,3)$ einpacken -- Restkapazität 3.
|
|
\item $(1,4)$ und $(1,5)$ passen nicht.
|
|
\end{itemize}
|
|
$\mathrm{GA} = 1 + 3 + 5 + 1 = 10$.
|
|
|
|
\textbf{b)} ModifiedGreedy vergleicht zwei Kandidaten:
|
|
\begin{itemize}
|
|
\item Greedy-Wert: $\mathrm{GA} = 10$.
|
|
\item Profitreichstes Einzel-Item: $(11,13)$ mit Profit $11$.
|
|
\item $\mathrm{MGA} = \max\{10,\ 11\} = 11$.
|
|
\end{itemize}
|
|
Die Lösung wechselt von $\{(1,1), (3,3), (5,6), (1,3)\}$ zum einzelnen
|
|
Item $(11,13)$.
|
|
\begin{center}
|
|
\begin{tikzpicture}[x=0.65cm,y=1cm]
|
|
\node[left] at (-0.3,2.7) {\small Greedy};
|
|
\draw[fill=black!10] (0,2.4) rectangle (1,3.0);
|
|
\node at (0.5,2.7) {\scriptsize $1/1$};
|
|
\draw[fill=black!25] (1,2.4) rectangle (4,3.0);
|
|
\node at (2.5,2.7) {\scriptsize $3/3$};
|
|
\draw[fill=black!10] (4,2.4) rectangle (10,3.0);
|
|
\node at (7,2.7) {\scriptsize $5/6$};
|
|
\draw[fill=black!25] (10,2.4) rectangle (13,3.0);
|
|
\node at (11.5,2.7) {\scriptsize $1/3$};
|
|
\draw (13,2.4) rectangle (16,3.0);
|
|
\node[right] at (16.2,2.7) {\small $\mathrm{GA}=10$};
|
|
\node[left] at (-0.3,1.5) {\small MGA};
|
|
\draw[fill=black!25] (0,1.2) rectangle (13,1.8);
|
|
\node at (6.5,1.5) {\scriptsize $11/13$};
|
|
\draw (13,1.2) rectangle (16,1.8);
|
|
\node[right] at (16.2,1.5) {\small $\mathrm{MGA}=11$};
|
|
\node[left] at (-0.3,0.3) {\small OPT};
|
|
\draw[fill=black!25] (0,0) rectangle (13,0.6);
|
|
\node at (6.5,0.3) {\scriptsize $11/13$};
|
|
\draw[fill=black!10] (13,0) rectangle (16,0.6);
|
|
\node at (14.5,0.3) {\scriptsize $3/3$};
|
|
\node[right] at (16.2,0.3) {\small $\mathrm{OPT}=14$};
|
|
\draw[thin] (0,-0.35) -- (16,-0.35);
|
|
\draw[thin] (0,-0.42) -- (0,-0.28);
|
|
\draw[thin] (16,-0.42) -- (16,-0.28);
|
|
\node[below] at (0,-0.42) {\small $0$};
|
|
\node[below] at (16,-0.42) {\small $B=16$};
|
|
\node at (8,-1.1) {\small Segmentbeschriftung: $p_i/w_i$, Breite $=$ Gewicht $w_i$};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{c)} ModifiedGreedy hat Güte 2.
|
|
|
|
Verbesserung durch $k$-Enumeration (Sahni):
|
|
\begin{itemize}
|
|
\item Probiere jede Vorauswahl aus höchstens $k$ Items.
|
|
\item Fülle jede Vorauswahl mit Greedy auf.
|
|
\item Gib die beste gefundene Lösung aus.
|
|
\end{itemize}
|
|
Das liefert Güte $1 + \frac1k$: $\frac32$ für $k = 2$ und $\frac43$ für
|
|
$k = 3$. \hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{LPT anwenden}{Klausur SS24-H, A1a+b, 4+2 P.}
|
|
Jobs $p = (5, 3, 7, 8, 1, 4, 2)$, $m = 3$.
|
|
\begin{enumerate}
|
|
\item[a)] Wenden Sie LPT an (Zwischenschritte, Reihenfolge, Schedule
|
|
grafisch).
|
|
\item[b)] Approximative Güte von LPT?
|
|
\end{enumerate}
|
|
|
|
\emph{Hinweis:} ListScheduling legt jeden Job in der gegebenen Reihenfolge auf
|
|
die aktuell am wenigsten belastete Maschine. LPT ist ListScheduling nach
|
|
absteigender Sortierung der Bearbeitungszeiten.
|
|
|
|
\musterkopf{Verfahren LPT/ListScheduling}
|
|
Scheduling-Heuristik: jeden Job auf die aktuell leerste Maschine; LPT sortiert vorher absteigend.
|
|
\begin{itemize}
|
|
\item (LPT) Jobs absteigend sortieren.
|
|
\item Je Job die Maschine mit kleinster Last wählen.
|
|
\item Lastvektor nach jedem Schritt notieren; Makespan $=$ größte Last.
|
|
\item Schedule als Balkendiagramm zeichnen.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{a)} Absteigend sortiert: $8, 7, 5, 4, 3, 2, 1$ (also
|
|
$J_4, J_3, J_1, J_6, J_2, J_7, J_5$). Platzierung auf die jeweils leerste
|
|
Maschine:
|
|
\begin{itemize}
|
|
\item $8 \to M_1$: $(8,0,0)$, \quad $7 \to M_2$: $(8,7,0)$, \quad $5 \to M_3$: $(8,7,5)$,
|
|
\item $4 \to M_3$: $(8,7,9)$, \quad $3 \to M_2$: $(8,10,9)$, \quad $2 \to M_1$: $(10,10,9)$,
|
|
\quad $1 \to M_3$: $(10,10,10)$.
|
|
\end{itemize}
|
|
\begin{center}
|
|
\begin{tikzpicture}[x=0.7cm,y=1cm]
|
|
\node[left] at (-0.2,1.775) {\small $M_1$};
|
|
\draw[fill=black!10] (0,1.5) rectangle (8,2.05);
|
|
\node at (4,1.775) {\small $J_4\,(8)$};
|
|
\draw[fill=black!25] (8,1.5) rectangle (10,2.05);
|
|
\node at (9,1.775) {\small $2$};
|
|
\node[left] at (-0.2,1.025) {\small $M_2$};
|
|
\draw[fill=black!10] (0,0.75) rectangle (7,1.3);
|
|
\node at (3.5,1.025) {\small $J_3\,(7)$};
|
|
\draw[fill=black!25] (7,0.75) rectangle (10,1.3);
|
|
\node at (8.5,1.025) {\small $3$};
|
|
\node[left] at (-0.2,0.275) {\small $M_3$};
|
|
\draw[fill=black!10] (0,0) rectangle (5,0.55);
|
|
\node at (2.5,0.275) {\small $J_1\,(5)$};
|
|
\draw[fill=black!25] (5,0) rectangle (9,0.55);
|
|
\node at (7,0.275) {\small $4$};
|
|
\draw[fill=black!10] (9,0) rectangle (10,0.55);
|
|
\node at (9.5,0.275) {\small $1$};
|
|
\draw[->,thin] (0,-0.35) -- (10.8,-0.35) node[below] {\small $t$};
|
|
\foreach \x in {0,5,10} {
|
|
\draw[thin] (\x,-0.42) -- (\x,-0.28);
|
|
\node[below] at (\x,-0.45) {\small $\x$};}
|
|
\draw[dashed,thin] (10,-0.28) -- (10,2.05);
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
Makespan $= 10$.
|
|
|
|
\textbf{b)} LPT hat Güte $\frac43 - \frac1{3m}$. \hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{$\Delta$TSP1 anwenden + Verständnisfragen}{Klausuren SS25-N A1 und SS24-N A1}
|
|
Gegeben sei folgender Graph $G = (V,E)$:
|
|
\begin{center}
|
|
\begin{tikzpicture}[gw/.style={fill=white,inner sep=1pt,font=\small}]
|
|
\node[knoten] (A) at ( 90:2.1) {$A$};
|
|
\node[knoten] (B) at ( 18:2.1) {$B$};
|
|
\node[knoten] (C) at ( -54:2.1) {$C$};
|
|
\node[knoten] (D) at (-126:2.1) {$D$};
|
|
\node[knoten] (E) at ( 162:2.1) {$E$};
|
|
\draw (A) -- (B) node[gw,midway] {1};
|
|
\draw (B) -- (C) node[gw,midway] {2};
|
|
\draw (C) -- (D) node[gw,midway] {1};
|
|
\draw (D) -- (E) node[gw,midway] {2};
|
|
\draw (E) -- (A) node[gw,midway] {2};
|
|
\draw (A) -- (C) node[gw,pos=0.25] {2};
|
|
\draw (A) -- (D) node[gw,pos=0.25] {3};
|
|
\draw (B) -- (D) node[gw,pos=0.25] {3};
|
|
\draw (B) -- (E) node[gw,pos=0.25] {3};
|
|
\draw (C) -- (E) node[gw,pos=0.25] {3};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
\begin{enumerate}
|
|
\item[a)] Wenden Sie $\Delta$TSP1 auf den Graphen $G$ ab Startknoten $C$
|
|
an; geben Sie alle Zwischengraphen und die Länge der Rundreise an.
|
|
\item[b)] Was berechnet $\Delta$TSP1, und welche Bedingungen muss der
|
|
Graph erfüllen?
|
|
\item[c)] Begründen Sie die approximative Güte 2.
|
|
\item[d)] Ist das Entscheidungsproblem zum TSP in $P$? Kurze Begründung.
|
|
\item[e)] Wahr oder falsch: \glqq Güte $1{,}5$ bedeutet
|
|
$\frac{d(R)}{\mathrm{OPT}(I)} \ge 1{,}5$ für eine Instanz $I$.\grqq{}
|
|
Kurze Begründung.
|
|
\end{enumerate}
|
|
|
|
\emph{Hinweis ($\Delta$TSP1):} (1) MST $T$ berechnen; (2) alle MST-Kanten
|
|
verdoppeln; (3) Eulerkreis ab Startknoten; (4) Abkürzen: bereits besuchte
|
|
Knoten überspringen.
|
|
|
|
\musterkopf{Verfahren $\Delta$TSP1}
|
|
MST-Verdopplung: Baum $\to$ Eulerkreis $\to$ Abkürzen; Güte 2.
|
|
\begin{itemize}
|
|
\item MST berechnen (Kruskal: Kanten nach Gewicht sortiert nennen).
|
|
\item Alle MST-Kanten verdoppeln -- alle Grade werden gerade.
|
|
\item Eulerkreis ab Startknoten notieren.
|
|
\item Abkürzen: besuchte Knoten überspringen; Tour und Länge angeben.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{a)}
|
|
\begin{itemize}
|
|
\item[(1)] MST (Kruskal): $A$--$B$ (1), $C$--$D$ (1), $B$--$C$ (2), $A$--$E$ (2);
|
|
Gewicht 6.
|
|
\item[(2)] Verdoppeln: Multigraph, Gewicht 12 -- alle Grade gerade.
|
|
\item[(3)] Eulerkreis ab $C$: $[C,B,A,E,A,B,C,D,C]$.
|
|
\item[(4)] Abkürzen: Tour $[C,B,A,E,D,C]$, Länge \textbf{8}.
|
|
\end{itemize}
|
|
\begin{center}
|
|
\begin{tikzpicture}[gw/.style={fill=white,inner sep=1pt,font=\scriptsize},
|
|
hell/.style={draw=black!20}]
|
|
\node[knoten] (A) at ( 90:1.2) {$A$};
|
|
\node[knoten] (B) at ( 18:1.2) {$B$};
|
|
\node[knoten] (C) at ( -54:1.2) {$C$};
|
|
\node[knoten] (D) at (-126:1.2) {$D$};
|
|
\node[knoten] (E) at ( 162:1.2) {$E$};
|
|
\foreach \u/\v in {A/C,A/D,B/D,B/E,C/E,D/E} \draw[hell] (\u) -- (\v);
|
|
\draw[very thick] (A) -- (B) node[gw,midway] {1};
|
|
\draw[very thick] (C) -- (D) node[gw,midway] {1};
|
|
\draw[very thick] (B) -- (C) node[gw,midway] {2};
|
|
\draw[very thick] (A) -- (E) node[gw,midway] {2};
|
|
\node at (0,-1.9) {\scriptsize (1) MST, Gewicht 6};
|
|
\end{tikzpicture}\hspace{2mm}%
|
|
\begin{tikzpicture}
|
|
\node[knoten] (A) at ( 90:1.2) {$A$};
|
|
\node[knoten] (B) at ( 18:1.2) {$B$};
|
|
\node[knoten] (C) at ( -54:1.2) {$C$};
|
|
\node[knoten] (D) at (-126:1.2) {$D$};
|
|
\node[knoten] (E) at ( 162:1.2) {$E$};
|
|
\foreach \u/\v in {A/B,C/D,B/C,A/E}{
|
|
\draw[thick] (\u) to[bend left=12] (\v);
|
|
\draw[thick] (\u) to[bend right=12] (\v);}
|
|
\node at (0,-1.9) {\scriptsize (2) verdoppelt, Gewicht 12};
|
|
\end{tikzpicture}\hspace{2mm}%
|
|
\begin{tikzpicture}[nr/.style={fill=white,inner sep=1pt,font=\scriptsize}]
|
|
\node[knoten] (A) at ( 90:1.2) {$A$};
|
|
\node[knoten] (B) at ( 18:1.2) {$B$};
|
|
\node[knoten] (C) at ( -54:1.2) {$C$};
|
|
\node[knoten] (D) at (-126:1.2) {$D$};
|
|
\node[knoten] (E) at ( 162:1.2) {$E$};
|
|
\draw[->] (C) to[bend left=18] node[nr] {1} (B);
|
|
\draw[->] (B) to[bend left=18] node[nr] {2} (A);
|
|
\draw[->] (A) to[bend left=18] node[nr] {3} (E);
|
|
\draw[->] (E) to[bend left=18] node[nr] {4} (A);
|
|
\draw[->] (A) to[bend left=18] node[nr] {5} (B);
|
|
\draw[->] (B) to[bend left=18] node[nr] {6} (C);
|
|
\draw[->] (C) to[bend left=18] node[nr] {7} (D);
|
|
\draw[->] (D) to[bend left=18] node[nr] {8} (C);
|
|
\node at (0,-1.9) {\scriptsize (3) Eulerkreis ab $C$};
|
|
\end{tikzpicture}\hspace{2mm}%
|
|
\begin{tikzpicture}[gw/.style={fill=white,inner sep=1pt,font=\scriptsize},
|
|
hell/.style={draw=black!20}]
|
|
\node[knoten] (A) at ( 90:1.2) {$A$};
|
|
\node[knoten] (B) at ( 18:1.2) {$B$};
|
|
\node[knoten] (C) at ( -54:1.2) {$C$};
|
|
\node[knoten] (D) at (-126:1.2) {$D$};
|
|
\node[knoten] (E) at ( 162:1.2) {$E$};
|
|
\foreach \u/\v in {A/C,A/D,B/D,B/E,C/E} \draw[hell] (\u) -- (\v);
|
|
\draw[very thick,->] (C) -- (B) node[gw,midway] {2};
|
|
\draw[very thick,->] (B) -- (A) node[gw,midway] {1};
|
|
\draw[very thick,->] (A) -- (E) node[gw,midway] {2};
|
|
\draw[very thick,->] (E) -- (D) node[gw,midway] {2};
|
|
\draw[very thick,->] (D) -- (C) node[gw,midway] {1};
|
|
\node at (0,-1.9) {\scriptsize (4) Tour, L\"ange 8};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{b)} $\Delta$TSP1 berechnet eine Rundreise (TSP-Tour). Der Graph
|
|
muss vollständig sein, die Distanzen symmetrisch und die Dreiecksungleichung
|
|
$d(i,j) \le d(i,k) + d(k,j)$ erfüllen -- sonst kann das Abkürzen die Tour
|
|
verlängern.
|
|
|
|
\textbf{c)} Güte 2, in drei Schritten:
|
|
\begin{itemize}
|
|
\item Entfernt man aus einer optimalen Tour eine Kante, entsteht ein
|
|
Spannbaum. $T$ ist ein minimaler Spannbaum, also
|
|
$w(T) \le \mathrm{OPT}$.
|
|
\item Der Eulerkreis nutzt jede MST-Kante zweimal. Seine Länge ist
|
|
$2\,w(T) \le 2\,\mathrm{OPT}$.
|
|
\item Abkürzen verlängert wegen der Dreiecksungleichung nicht.
|
|
\end{itemize}
|
|
Also gilt $d(R) \le 2\,\mathrm{OPT}$.
|
|
|
|
\textbf{d)} Nein (außer $P = NP$): Das TSP-Entscheidungsproblem ist
|
|
NP-vollständig -- \problem{HamiltonianCycle} reduziert darauf (Kanten Distanz
|
|
1, Nicht-Kanten $|V|{+}1$, $L = |V|$). Läge es in $P$, folgte $P = NP$.
|
|
|
|
\textbf{e)} Falsch. Multiplikative Güte $\alpha$ ist eine \emph{obere}
|
|
Schranke für alle Instanzen: $d(R) \le \alpha \cdot \mathrm{OPT}(I)$ für
|
|
\emph{jede} Instanz $I$ -- nicht eine untere Schranke $\ge$ für eine Instanz.
|
|
\hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{Christofides anwenden ($K_4$)}{Klausuren SS25-H A1 und SS23-N A1}
|
|
Gegeben sei folgender Graph $G = (V,E)$:
|
|
\begin{center}
|
|
\begin{tikzpicture}[gw/.style={fill=white,inner sep=1pt,font=\small}]
|
|
\node[knoten] (a) at (0,2.4) {$a$};
|
|
\node[knoten] (b) at (2.4,2.4) {$b$};
|
|
\node[knoten] (d) at (2.4,0) {$d$};
|
|
\node[knoten] (c) at (0,0) {$c$};
|
|
\draw (a) -- (b) node[gw,midway] {1};
|
|
\draw (b) -- (d) node[gw,midway] {3};
|
|
\draw (d) -- (c) node[gw,midway] {4};
|
|
\draw (c) -- (a) node[gw,midway] {2};
|
|
\draw (a) -- (d) node[gw,pos=0.3] {4};
|
|
\draw (b) -- (c) node[gw,pos=0.3] {3};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
\begin{enumerate}
|
|
\item[a)] Wenden Sie Christofides ($\Delta$TSP2) auf den Graphen $G$ mit
|
|
Startknoten $a$ an; geben Sie alle Zwischengraphen an, auch Schritte ohne
|
|
Änderung.
|
|
\item[b)] Was berechnet Christofides? Nennen Sie die zwei
|
|
Zusatzeigenschaften der Eingabe, die er braucht, mit je einer verletzenden
|
|
Eingabe. Geben Sie die Güte an.
|
|
\end{enumerate}
|
|
|
|
\emph{Hinweis (Christofides):} (1) MST $T$ berechnen; (2) $X$ = Knoten mit
|
|
ungeradem Grad in $T$; (3) minimales perfektes Matching $K$ auf $X$;
|
|
(4) Eulerkreis im Multigraphen $T + K$; (5) Abkürzen.
|
|
|
|
\musterkopf{Verfahren Christofides}
|
|
Wie $\Delta$TSP1, aber statt Verdopplung ein Matching auf den ungeraden Knoten; Güte $\frac32$.
|
|
\begin{itemize}
|
|
\item MST berechnen.
|
|
\item $X$ $=$ Knoten mit ungeradem Grad im MST.
|
|
\item Minimales perfektes Matching auf $X$ hinzufügen.
|
|
\item Eulerkreis ab Startknoten, dann abkürzen; Tour und Länge angeben.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{a)}
|
|
\begin{itemize}
|
|
\item[(1)] MST (Kruskal): $\{a,b\}$ (1), $\{a,c\}$ (2), $\{b,d\}$ (3);
|
|
Gewicht 6.
|
|
\item[(2)] Ungerade Grade im MST: $a{:}\,2$, $b{:}\,2$, $c{:}\,1$, $d{:}\,1$
|
|
$\Rightarrow X = \{c,d\}$.
|
|
\item[(3)] Minimales perfektes Matching auf $X$: einzige Möglichkeit
|
|
$K = \{\{c,d\}\}$, Kosten 4.
|
|
\item[(4)] Multigraph $T + K$: alle Grade gerade. Eulerkreis ab $a$:
|
|
$[a, b, d, c, a]$, Kosten $1 + 3 + 4 + 2 = 10$.
|
|
\item[(5)] Abkürzen: kein Knoten doppelt -- keine Änderung (wird aber
|
|
geprüft). Tour $R = [a, b, d, c, a]$, Länge 10.
|
|
\end{itemize}
|
|
\begin{center}
|
|
\begin{tikzpicture}[gw/.style={fill=white,inner sep=1pt,font=\scriptsize},
|
|
hell/.style={draw=black!20}]
|
|
\node[knoten] (a) at (0,1.7) {$a$};
|
|
\node[knoten] (b) at (1.7,1.7) {$b$};
|
|
\node[knoten] (d) at (1.7,0) {$d$};
|
|
\node[knoten] (c) at (0,0) {$c$};
|
|
\foreach \u/\v in {c/d,a/d,b/c} \draw[hell] (\u) -- (\v);
|
|
\draw[very thick] (a) -- (b) node[gw,midway] {1};
|
|
\draw[very thick] (a) -- (c) node[gw,midway] {2};
|
|
\draw[very thick] (b) -- (d) node[gw,midway] {3};
|
|
\node at (0.85,-0.75) {\scriptsize (1) MST, Gewicht 6};
|
|
\end{tikzpicture}\hspace{3mm}%
|
|
\begin{tikzpicture}[hell/.style={draw=black!20}]
|
|
\node[knoten] (a) at (0,1.7) {$a$};
|
|
\node[knoten] (b) at (1.7,1.7) {$b$};
|
|
\node[kndick] (d) at (1.7,0) {$d$};
|
|
\node[kndick] (c) at (0,0) {$c$};
|
|
\foreach \u/\v in {c/d,a/d,b/c} \draw[hell] (\u) -- (\v);
|
|
\draw[very thick] (a) -- (b);
|
|
\draw[very thick] (a) -- (c);
|
|
\draw[very thick] (b) -- (d);
|
|
\node at (0.85,-0.75) {\scriptsize (2) $X=\{c,d\}$};
|
|
\end{tikzpicture}\hspace{3mm}%
|
|
\begin{tikzpicture}[gw/.style={fill=white,inner sep=1pt,font=\scriptsize}]
|
|
\node[knoten] (a) at (0,1.7) {$a$};
|
|
\node[knoten] (b) at (1.7,1.7) {$b$};
|
|
\node[kndick] (d) at (1.7,0) {$d$};
|
|
\node[kndick] (c) at (0,0) {$c$};
|
|
\draw[very thick] (a) -- (b);
|
|
\draw[very thick] (a) -- (c);
|
|
\draw[very thick] (b) -- (d);
|
|
\draw[very thick,dashed] (c) -- (d) node[gw,midway] {4};
|
|
\node at (0.85,-0.75) {\scriptsize (3) Matching $\{c,d\}$};
|
|
\end{tikzpicture}\hspace{3mm}%
|
|
\begin{tikzpicture}[gw/.style={fill=white,inner sep=1pt,font=\scriptsize},
|
|
hell/.style={draw=black!20}]
|
|
\node[knoten] (a) at (0,1.7) {$a$};
|
|
\node[knoten] (b) at (1.7,1.7) {$b$};
|
|
\node[knoten] (d) at (1.7,0) {$d$};
|
|
\node[knoten] (c) at (0,0) {$c$};
|
|
\foreach \u/\v in {a/d,b/c} \draw[hell] (\u) -- (\v);
|
|
\draw[very thick,->] (a) -- (b) node[gw,midway] {1};
|
|
\draw[very thick,->] (b) -- (d) node[gw,midway] {3};
|
|
\draw[very thick,->] (d) -- (c) node[gw,midway] {4};
|
|
\draw[very thick,->] (c) -- (a) node[gw,midway] {2};
|
|
\node at (0.85,-0.75) {\scriptsize (4) Tour, L\"ange 10};
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{b)} Christofides berechnet eine TSP-Rundreise. Benötigt werden
|
|
\emph{Symmetrie} ($d(u,v) = d(v,u)$) und die
|
|
\emph{Dreiecksungleichung} ($d(u,v) \le d(u,w) + d(w,v)$). Verletzende
|
|
Eingaben: $d(a,b) = 1$, $d(b,a) = 5$ (asymmetrisch); bzw.\ $d(a,b) = 10$,
|
|
$d(a,c) = d(c,b) = 1$ ($\Delta$-Ungleichung verletzt). Güte: $\frac32$.
|
|
\hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{Parallel-Task-Scheduling}{Klausur SS25-H, A5, 1+1+8+(10) P.}
|
|
Jobs belegen $q_j \in [m]$ Maschinen gleichzeitig für Zeit $p_j$.
|
|
ListScheduling platziert die Jobs der Reihe nach zum frühestmöglichen
|
|
Zeitpunkt auf den $q_j$ am wenigsten belasteten Maschinen.
|
|
\begin{enumerate}
|
|
\item[a)] Anwendung: $m = 3$; Jobs $(p, q)$: $(1,1), (1,3), (2,2), (3,1)$.
|
|
Geben Sie den Schedule an.
|
|
\item[b)] Worst-Case-Güte für $q_j = 1$?
|
|
\item[c)] Zeigen Sie $\mathrm{LS}(I) \le \mathrm{OPT}(I) + \frac12 p_{\max}$
|
|
für alle $I$ mit $\frac m3 < q_j \le \frac m2$.
|
|
\item[d)] \textbf{Bonus:} Güte für $\frac{m}{k+1} < q_j \le \frac mk$
|
|
($k \ge 2$)? Beweis.
|
|
\end{enumerate}
|
|
|
|
\musterkopf{Verfahren Parallel-Task-ListScheduling}
|
|
ListScheduling für Jobs, die mehrere Maschinen gleichzeitig belegen.
|
|
\begin{itemize}
|
|
\item Je Job den frühesten Zeitpunkt suchen, an dem die $q_j$ leersten Maschinen frei sind.
|
|
\item Lastvektor nach jedem Job notieren, Schedule als Zeitdiagramm zeichnen.
|
|
\item Für Schranken: Moment vor dem Makespan-Job betrachten -- Auslastungsargument.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{a)} Start mit Lasten $C = (0,0,0)$:
|
|
\begin{itemize}
|
|
\item Job 1 $(1,1)$: startet bei 0 auf einer Maschine -- $C = (1,0,0)$.
|
|
\item Job 2 $(1,3)$: braucht alle 3 Maschinen, frühester Start
|
|
$\max C = 1$, läuft $[1,2]$ -- $C = (2,2,2)$.
|
|
\item Job 3 $(2,2)$: Start 2 auf zwei Maschinen, läuft $[2,4]$ --
|
|
$C = (4,4,2)$.
|
|
\item Job 4 $(3,1)$: leerste Maschine hat Last 2, Start 2, läuft $[2,5]$ --
|
|
$C = (5,4,4)$.
|
|
\end{itemize}
|
|
\textbf{Makespan 5.}
|
|
\begin{center}
|
|
\begin{tikzpicture}[x=1.3cm,y=1cm]
|
|
\node[left] at (-0.15,2.0) {\small $M_1$};
|
|
\node[left] at (-0.15,1.2) {\small $M_2$};
|
|
\node[left] at (-0.15,0.4) {\small $M_3$};
|
|
\draw[black!40,thin] (0,0.8) rectangle (1,1.6);
|
|
\draw[black!40,thin] (0,0) rectangle (1,0.8);
|
|
\draw[black!40,thin] (4,1.6) rectangle (5,2.4);
|
|
\draw[black!40,thin] (4,0.8) rectangle (5,1.6);
|
|
\draw[fill=black!10] (0,1.6) rectangle (1,2.4);
|
|
\node at (0.5,2.0) {\small $J_1$};
|
|
\draw[fill=black!25] (1,0) rectangle (2,2.4);
|
|
\node at (1.5,1.2) {\small $J_2$};
|
|
\draw[fill=black!10] (2,0.8) rectangle (4,2.4);
|
|
\node at (3,1.6) {\small $J_3$};
|
|
\draw[fill=black!25] (2,0) rectangle (5,0.8);
|
|
\node at (3.5,0.4) {\small $J_4$};
|
|
\draw[dashed,thin] (5,-0.35) -- (5,2.6);
|
|
\node[above] at (5,2.6) {\small $C_{\max}=5$};
|
|
\draw[->,thin] (0,-0.35) -- (5.6,-0.35) node[below] {\small $t$};
|
|
\foreach \x in {0,1,2,3,4,5} {
|
|
\draw[thin] (\x,-0.42) -- (\x,-0.28);
|
|
\node[below] at (\x,-0.45) {\small $\x$};}
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{b)} Für $q_j = 1$ ist es das klassische ListScheduling: Güte
|
|
$2 - \frac1m$.
|
|
|
|
\textbf{c)} Sei $j$ ein Job, der den Makespan bestimmt, mit Startzeit
|
|
$s = \mathrm{LS} - p_j$. Zu jedem Zeitpunkt $t < s$ sind weniger als $q_j \le
|
|
\frac m2$ Maschinen frei (sonst wäre $j$ früher platziert worden), also mehr
|
|
als $\frac m2$ belegt. Jeder Job belegt höchstens $\frac m2$ Maschinen, also laufen mindestens
|
|
zwei Jobs. Jeder belegt \emph{mehr} als $\frac m3$, also laufen höchstens zwei. Also laufen in $[0, s)$ stets \emph{genau zwei} Jobs.
|
|
Damit ist
|
|
\[
|
|
2s = \int_0^s \#\text{laufende Jobs}\, dt \;\le\; \sum_i p_i - p_j .
|
|
\]
|
|
Im Optimum laufen ebenfalls nie drei Jobs gleichzeitig (drei Jobs belegen
|
|
zusammen mehr als $3 \cdot \frac m3 = m$ Maschinen -- mehr als vorhanden),
|
|
also $\sum_i p_i \le 2\,\mathrm{OPT}$. Einsetzen:
|
|
$s \le \frac12(\sum_i p_i - p_j) \le \mathrm{OPT} - \frac12 p_j$, folglich
|
|
\[
|
|
\mathrm{LS} = s + p_j \;\le\; \mathrm{OPT} + \tfrac12 p_j
|
|
\;\le\; \mathrm{OPT} + \tfrac12 p_{\max}.
|
|
\]
|
|
|
|
\textbf{d)} Güte $2 - \frac1k$, analog zu c). Vor dem Start von $j$ sind mehr
|
|
als $m - \frac mk = \frac{(k-1)m}{k}$ Maschinen belegt. Jeder Job belegt
|
|
$\le \frac mk$, also laufen mindestens $k$ Jobs. Jeder belegt
|
|
$> \frac{m}{k+1}$, also höchstens $k$. Es laufen also stets genau $k$ Jobs, und
|
|
$k s \le \sum_i p_i - p_j$. Im Optimum laufen $\le k$ Jobs parallel, also
|
|
$\sum_i p_i \le k\,\mathrm{OPT}$. Daraus $s \le \mathrm{OPT} - \frac1k p_j$,
|
|
und mit $p_{\max} \le \mathrm{OPT}$ folgt
|
|
\[
|
|
\mathrm{LS} \;\le\; \mathrm{OPT} + \bigl(1 - \tfrac1k\bigr) p_j
|
|
\;\le\; \mathrm{OPT} + \bigl(1 - \tfrac1k\bigr) p_{\max}
|
|
\;\le\; \bigl(2 - \tfrac1k\bigr)\,\mathrm{OPT}.
|
|
\]
|
|
\hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{Strip Packing: NFDH}{Klausur SS25-N, A5, 2+3+5+(10) P.}
|
|
\problem{StripPacking}: Rechtecke (nach Höhe absteigend sortiert) in einen
|
|
Streifen der Breite 1 packen, Höhe minimieren. NFDH packt stufenweise von
|
|
links; passt ein Rechteck nicht mehr, beginnt eine neue Stufe.
|
|
\begin{enumerate}
|
|
\item[a)] Instanz: fünf Rechtecke der Höhe 1 mit Breiten
|
|
$\frac12, \frac14, \frac12, \frac14, \frac12$; NFDH braucht Höhe 3. Geben Sie
|
|
eine optimale Packung und die Approximationsrate an.
|
|
\item[b)] Zeigen Sie: Es gibt $L_n$ mit
|
|
$\lim_{n\to\infty} \mathrm{NFDH}(L_n)/\mathrm{OPT}(L_n) = 2$.
|
|
\item[c)] Zeigen Sie für Instanzen mit $h(r_i) = 1$:
|
|
$\mathrm{NFDH}(L) \le 2\,\mathrm{OPT}(L) + 1$.
|
|
\item[d)] \textbf{Bonus:} Zeigen Sie dieselbe Schranke für $h(r_i) \le 1$.
|
|
\end{enumerate}
|
|
|
|
\musterkopf{Verfahren NFDH}
|
|
Shelf-Packing: nach Höhe sortiert stufenweise packen; Schranke über Flächenargument.
|
|
\begin{itemize}
|
|
\item Rechtecke nach Höhe absteigend sortieren.
|
|
\item Stufe von links füllen; passt eines nicht mehr, neue Stufe darüber öffnen.
|
|
\item Gesamthöhe $=$ Summe der Stufenhöhen.
|
|
\item Schranke: zwei aufeinanderfolgende Stufen füllen zusammen mehr als Breite 1 -- daraus die untere Flächenschranke.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{a)} Optimal: Stufe 1 mit $\frac12 + \frac12 = 1$ (Rechtecke 1 und 3),
|
|
Stufe 2 mit $\frac12 + \frac14 + \frac14 = 1$ (Rechtecke 5, 2, 4) -- Höhe
|
|
$\mathrm{OPT} = 2$. Rate: $\frac{3}{2}$.
|
|
\begin{center}
|
|
\begin{tikzpicture}[x=4.2cm,y=0.85cm]
|
|
\draw[thin] (0,3.35) -- (0,0) -- (1,0) -- (1,3.35);
|
|
\draw[fill=black!25] (0,0) rectangle (0.5,1);
|
|
\node at (0.25,0.5) {\small $r_1\,(\tfrac12)$};
|
|
\draw[fill=black!10] (0.5,0) rectangle (0.75,1);
|
|
\node at (0.625,0.5) {\scriptsize $r_2\,(\tfrac14)$};
|
|
\draw[fill=black!25] (0,1) rectangle (0.5,2);
|
|
\node at (0.25,1.5) {\small $r_3\,(\tfrac12)$};
|
|
\draw[fill=black!10] (0.5,1) rectangle (0.75,2);
|
|
\node at (0.625,1.5) {\scriptsize $r_4\,(\tfrac14)$};
|
|
\draw[fill=black!25] (0,2) rectangle (0.5,3);
|
|
\node at (0.25,2.5) {\small $r_5\,(\tfrac12)$};
|
|
\draw[dashed,thin] (0,3) -- (1,3);
|
|
\node[right] at (1.03,3) {\small $\mathrm{NFDH}=3$};
|
|
\node at (0.5,-0.55) {\small Breite $1$};
|
|
\begin{scope}[xshift=8.8cm]
|
|
\draw[thin] (0,3.35) -- (0,0) -- (1,0) -- (1,3.35);
|
|
\draw[fill=black!25] (0,0) rectangle (0.5,1);
|
|
\node at (0.25,0.5) {\small $r_1\,(\tfrac12)$};
|
|
\draw[fill=black!25] (0.5,0) rectangle (1,1);
|
|
\node at (0.75,0.5) {\small $r_3\,(\tfrac12)$};
|
|
\draw[fill=black!25] (0,1) rectangle (0.5,2);
|
|
\node at (0.25,1.5) {\small $r_5\,(\tfrac12)$};
|
|
\draw[fill=black!10] (0.5,1) rectangle (0.75,2);
|
|
\node at (0.625,1.5) {\scriptsize $r_2\,(\tfrac14)$};
|
|
\draw[fill=black!10] (0.75,1) rectangle (1,2);
|
|
\node at (0.875,1.5) {\scriptsize $r_4\,(\tfrac14)$};
|
|
\draw[dashed,thin] (0,2) -- (1,2);
|
|
\node[right] at (1.03,2) {\small $\mathrm{OPT}=2$};
|
|
\node at (0.5,-0.55) {\small Breite $1$};
|
|
\end{scope}
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{b)} $L_n$ ($n = 2t$): alle Höhen 1; Breiten abwechselnd $1$ und
|
|
$\varepsilon$. NFDH: Jedes Breite-1-Rechteck füllt seine Stufe komplett, jedes
|
|
$\varepsilon$-Rechteck eröffnet eine neue Stufe, auf die das nächste
|
|
Breite-1-Rechteck nicht mehr passt -- $2t$ Stufen, $\mathrm{NFDH} = 2t$.
|
|
Optimal: die $t$ Breite-1-Rechtecke je eigene Stufe, alle $t$
|
|
$\varepsilon$-Rechtecke zusammen auf eine Stufe -- $\mathrm{OPT} \le t + 1$.
|
|
Rate $\frac{2t}{t+1} \to 2$.
|
|
\begin{center}
|
|
\begin{tikzpicture}[x=4.0cm,y=0.55cm]
|
|
\draw[thin] (0,6.5) -- (0,0) -- (1,0) -- (1,6.5);
|
|
\foreach \y in {0,2,4} {
|
|
\draw[fill=black!25] (0,\y) rectangle (1,\y+1);
|
|
\node at (0.5,\y+0.5) {\small $1$};
|
|
\draw[fill=black!10] (0,\y+1) rectangle (0.06,\y+2);
|
|
\node[right] at (0.09,\y+1.5) {\small $\varepsilon$};}
|
|
\draw[dashed,thin] (0,6) -- (1,6);
|
|
\node[right] at (1.03,6) {\small $\mathrm{NFDH}=2t$};
|
|
\node at (0.5,-1.0) {\small NFDH: jede Stufe ein Rechteck};
|
|
\begin{scope}[xshift=8.8cm]
|
|
\draw[thin] (0,6.5) -- (0,0) -- (1,0) -- (1,6.5);
|
|
\foreach \y in {0,1,2} {
|
|
\draw[fill=black!25] (0,\y) rectangle (1,\y+1);
|
|
\node at (0.5,\y+0.5) {\small $1$};}
|
|
\foreach \x in {0,0.09,0.18}
|
|
\draw[fill=black!10] (\x,3) rectangle (\x+0.06,4);
|
|
\node[right] at (0.28,3.5) {\small $t$ mal $\varepsilon$};
|
|
\draw[dashed,thin] (0,4) -- (1,4);
|
|
\node[right] at (1.03,4) {\small $\mathrm{OPT}\le t+1$};
|
|
\node at (0.5,-1.0) {\small OPT: alle $\varepsilon$ auf eine Stufe};
|
|
\end{scope}
|
|
\end{tikzpicture}
|
|
\end{center}
|
|
|
|
\textbf{c)} Seien $W_1, \dots, W_S$ die Gesamtbreiten der NFDH-Stufen;
|
|
$\mathrm{NFDH} = S$. Für $i < S$ gilt $W_i + W_{i+1} > 1$: Das erste Rechteck
|
|
der Stufe $i{+}1$ (Breite $\le W_{i+1}$) passte nicht mehr auf Stufe $i$.
|
|
Summieren über $i = 1, \dots, S-1$:
|
|
\[
|
|
2 \sum_i W_i \;\ge\; \sum_{i=1}^{S-1} (W_i + W_{i+1}) \;>\; S - 1 .
|
|
\]
|
|
Die Gesamtfläche ist $\sum_i W_i$ (Höhen 1) und passt in einen Streifen der
|
|
Breite 1: $\mathrm{OPT} \ge \sum_i W_i$. Also $2\,\mathrm{OPT} > S - 1$,
|
|
d.\,h.\ $\mathrm{NFDH} = S \le 2\,\mathrm{OPT} + 1$.
|
|
|
|
\textbf{d)} Zu zeigen ist $\mathrm{NFDH}(L) \le 2\,\mathrm{OPT}(L) + 1$
|
|
auch für Höhen $h(r_i) \le 1$. Sei $H_i$ die Höhe der Stufe $i$ ($=$ Höhe
|
|
ihres ersten Rechtecks), $W_i$ ihre Gesamtbreite und $A_i$ ihre
|
|
Rechteck-Gesamtfläche.
|
|
|
|
\textbf{Erstens:} Jedes Rechteck der Stufe $i$ hat Höhe $\ge H_{i+1}$
|
|
(absteigende Sortierung). Die Rechtecke der Stufe $i$ haben zusammen die
|
|
Breite $W_i$, also
|
|
\[
|
|
A_i \;\ge\; W_i \cdot H_{i+1} .
|
|
\]
|
|
|
|
\textbf{Zweitens:} Das \emph{erste} Rechteck der Stufe $i{+}1$ passte nicht
|
|
mehr auf Stufe $i$. Es hat also Breite $> 1 - W_i$ und Höhe $H_{i+1}$,
|
|
folglich
|
|
\[
|
|
\text{Fläche des ersten Rechtecks von Stufe } i{+}1 \;>\; (1 - W_i)\, H_{i+1} .
|
|
\]
|
|
|
|
\textbf{Kombination:} Zerlege $H_{i+1}$ in die beiden Anteile und setze
|
|
Erstens und Zweitens ein:
|
|
\[
|
|
H_{i+1} \;=\; W_i H_{i+1} + (1 - W_i) H_{i+1}
|
|
\;<\; A_i + \bigl(\text{Fläche des ersten Rechtecks von Stufe } i{+}1\bigr).
|
|
\]
|
|
|
|
\textbf{Summierung:} Summiere die Kombination über $i \ge 1$. Dabei zählt
|
|
jede Stufe höchstens zweimal: einmal als $A_i$ und einmal über ihr erstes
|
|
Rechteck. Also
|
|
\[
|
|
\sum_{i \ge 2} H_i \;<\; 2 \cdot \text{Gesamtfläche} \;\le\; 2\,\mathrm{OPT} .
|
|
\]
|
|
|
|
\textbf{Fazit:} Die erste Stufe hat Höhe $H_1 \le 1$. Damit folgt
|
|
\[
|
|
\mathrm{NFDH} \;=\; \sum_i H_i \;\le\; 2\,\mathrm{OPT} + 1 .
|
|
\]
|
|
\hfill$\square$
|
|
|
|
\newpage
|
|
% ==================================================================
|
|
\katkopf{TM für Palindrome}{Hausaufgabe 10.2, 5 P.}
|
|
Entwerfen Sie eine Turingmaschine (Einband-TM) für
|
|
$L = \{w \in \Sigma^* \mid w \text{ ist ein Palindrom}\}$ und geben Sie die
|
|
Laufzeit an (mit Begründung von Korrektheit und Laufzeit).
|
|
|
|
\bspkopf{TM für Palindrome}
|
|
\textbf{Instanz.} Eingabe $w=\mathtt{abba}$ (ein Palindrom).
|
|
|
|
\textbf{Kern.} Die Maschine vergleicht wiederholt den ersten und den letzten
|
|
unmarkierten Buchstaben und ersetzt gleiche Paare durch $x$. Der Bandinhalt
|
|
läuft über $\mathtt{abba}\to\mathtt{xbbx}\to\mathtt{xxxx}$; kein unmarkierter
|
|
Buchstabe bleibt übrig -- die Maschine akzeptiert.
|
|
|
|
|
|
\musterkopf{Maschine bauen}
|
|
TM konstruieren: Bandbewegungen als Schleife beschreiben, Laufzeit über Durchläufe zählen.
|
|
\begin{itemize}
|
|
\item Invariante festlegen: Was ist nach jedem Durchlauf erledigt?
|
|
\item Schleife beschreiben: markieren, laufen, vergleichen, zurück.
|
|
\item Abbruchfälle klar benennen: akzeptieren/verwerfen.
|
|
\item Laufzeit $=$ Anzahl Durchläufe $\times$ Bandlänge.
|
|
\end{itemize}
|
|
|
|
\lsg
|
|
\textbf{Die Maschine:}
|
|
\begin{enumerate}
|
|
\item[(1)] Falls kein Wort auf dem Band steht, akzeptiere.
|
|
\item[(2)] Falls nur ein Buchstabe auf dem Band steht, akzeptiere.
|
|
\item[(3)] Lies den ersten Buchstaben, bewege den Kopf zum letzten. Sind beide
|
|
verschieden, verwirf. Sonst ersetze beide durch ein neues Symbol $x$ (erst den
|
|
letzten, dann zurück zum ersten).
|
|
\item[(4)] Gehe zu Schritt (1).
|
|
\end{enumerate}
|
|
|
|
\textbf{Korrektheit:} \emph{Invariante:} Nach jedem Durchlauf ist das äußerste unmarkierte Buchstabenpaar als gleich bestätigt und markiert. Der noch unmarkierte Rest ist genau dann ein Palindrom, wenn $w$ eines ist. Bei Ungleichheit eines Paares ist $w$ kein Palindrom -- verwerfen. Sonst bleibt am Ende in der Mitte ein oder kein Buchstabe übrig -- beides ist ein Palindrom, akzeptieren.
|
|
|
|
\textbf{Laufzeit:} Die Schritte (1)--(3) kosten je $O(n)$. Pro Durchlauf
|
|
werden zwei Buchstaben gestrichen, also gibt es höchstens
|
|
$\lfloor n/2 \rfloor$ Durchläufe. Insgesamt $O(n^2)$. \hfill$\square$
|
|
|
|
\end{document}
|