\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}
