\documentclass[11pt]{article}
\input{style_guide.tex}

\linespread{1.05}
\setlength{\parskip}{0.4em}

\title{\textbf{\Huge Die 7 Aufgabentypen}\\[0.5em]
\large Musterlösungen, Rezepte und Bewertungshinweise\\
\normalsize \textit{Analyse von Algorithmen und Komplexität} -- CAU Kiel, SS 2026\\[0.2em]
\normalsize Schritt 3: die Muster kennen und richtig anwenden}
\author{}
\date{}

\begin{document}
\maketitle
\thispagestyle{empty}

\begin{center}\itshape\large
Jeder Klausur-Aufgabentyp einmal vorgemacht --\\
mit Rezept, kompletter Musterlösung und dem, worauf der Korrektor achtet.
\end{center}

\vfill

\noindent\textbf{Wofür dieses Heft.}
Du hast das Fundament verstanden. Jetzt lernst du, es \emph{anzuwenden}. Alle
bisherigen Klausuren, Haus- und Präsenzaufgaben lassen sich auf \textbf{sieben
Aufgabentypen} zurückführen. Zu jedem zeigt dieses Heft: ein \emph{Rezept}
(Schritt für Schritt), eine \emph{vollständig gelöste} Musteraufgabe im richtigen
Stil, die \emph{Bewertungslogik} und die \emph{häufigen Fehler}.

\medskip
\noindent\textbf{Die Reihenfolge ist Absicht.}
Die Typen bauen aufeinander auf. Arbeite sie von vorne nach hinten durch:

\begin{center}\small
\begin{tabular}{rll}
\toprule
\# & Aufgabentyp & baut auf \\
\midrule
1 & NP-Zugehörigkeit zeigen & Grundbaustein\\
2 & Reduktion konstruieren (NP-Schwere) & braucht 1\\
3 & Wahr oder falsch? & festigt 1+2\\
4 & ETH-Schranke herleiten & braucht 2\\
5 & Approximationsalgorithmus anwenden & neues Teilgebiet\\
6 & Güte beweisen + Worst-Case-Instanz & braucht 5\\
7 & Turingmaschine entwerfen & eigenständig\\
\bottomrule
\end{tabular}
\end{center}

\medskip
\noindent\textbf{Der Stil ist echt.}
Die Musterlösungen sind im Stil bewerteter Abgaben gehalten: knapp, formal,
jeder Schritt sichtbar begründet. Die Bewertungshinweise stammen aus echten
Punkteschemata und Korrektor-Anmerkungen.

\vfill
\newpage
\tableofcontents
\newpage

% ##################################################################
\section{NP-Zugehörigkeit zeigen}
% ##################################################################

\begin{ziel}
Der erste und einfachste Typ. Du zeigst, dass ein Problem in $\NP$ liegt --
indem du ein Zertifikat angibst und beschreibst, wie man es prüft. Dieser
Baustein steckt später in \emph{jedem} NP-Vollständigkeitsbeweis.
\end{ziel}

\subsection{Woran du diesen Typ erkennst}

Die Aufgabe klingt so (wörtlich aus der Klausur SS23): \glqq Zeigen Sie auf
\emph{verschiedene Weisen}, dass das Problem in NP liegt: (a) geben Sie ein
Zertifikat an, (b) beschreiben Sie einen Verifizierer mit konkreter Laufzeit,
(c) beschreiben Sie in Worten eine nichtdeterministische Turingmaschine.\grqq

\subsection{Das Rezept}

\begin{rezept}{Der NP-Dreischritt}
\textbf{(a) Zertifikat.} Nenne die \glqq Lösung\grqq{} als Objekt (Teilmenge,
Belegung, Reihenfolge). Sage, wie sie kodiert ist und dass sie \emph{polynomiell
lang} ist.\\[0.4em]
\textbf{(b) Verifizierer.} Ein deterministischer Algorithmus, der (Instanz,
Zertifikat) bekommt. Hake drei Punkte ab:
\begin{enumerate}
\item \emph{Beschreibung}: Welche Prüfungen laufen in welcher Reihenfolge?
\item \emph{Korrektheit -- beide Richtungen}: Ja-Instanz $\Rightarrow$ es gibt ein
akzeptiertes Zertifikat; Nein-Instanz $\Rightarrow$ keines wird akzeptiert.
\item \emph{Laufzeit}: konkret in $O$-Notation, nicht nur \glqq polynomiell\grqq.
\end{enumerate}
\textbf{(c) NTM.} \glqq Rate und prüfe.\grqq{} Rate das Zertifikat Stück für
Stück nichtdeterministisch, prüfe dann deterministisch wie in (b).
\end{rezept}

\subsection{Musteraufgabe}

\begin{aufgabe}{Longest Path (Klausur SS23, Aufgabe 2)}
Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Gibt es einen \emph{einfachen}
Pfad (kein Knoten doppelt) der Länge $\ge k$? Zeigen Sie auf drei Weisen, dass
\problem{Longest Path} in $\NP$ liegt.
\end{aufgabe}

\begin{loesung}
\textbf{(a) Zertifikat.} Eine Folge von $k+1$ paarweise verschiedenen Knoten
$(v_0, v_1, \dots, v_k)$ -- der behauptete Pfad. Jeder Knoten braucht
$O(\log |V|)$ Bits, die Folge also $O(k \log |V|)$ Bits. Das ist polynomiell in
der Eingabegröße.

\medskip
\textbf{(b) Verifizierer.} Er bekommt $(G, k)$ und ein Zertifikat
$(v_0, \dots, v_k)$ und prüft:
\begin{itemize}
\item ob alle $v_i$ \emph{paarweise verschieden} sind -- $O(k^2)$ Vergleiche
(oder $O(k \log k)$ durch Sortieren);
\item ob $\{v_i, v_{i+1}\} \in E$ für alle $i = 0, \dots, k-1$ gilt -- das sind
$k$ Nachschläge in der Adjazenzmatrix zu je $O(1)$, also $O(k)$.
\end{itemize}
Akzeptiere genau dann, wenn beide Prüfungen bestehen.

\emph{Korrektheit (beide Richtungen).} Hat $G$ einen einfachen Pfad der Länge
$\ge k$, so bilden seine ersten $k+1$ Knoten ein Zertifikat, das akzeptiert
wird. Wird umgekehrt ein Zertifikat akzeptiert, so ist es eine Folge verschiedener
Knoten mit lauter echten Kanten -- also ein einfacher Pfad der Länge $k$.

\emph{Laufzeit.} Gesamt $O(k^2) \subseteq O(|V|^2)$, polynomiell. Somit ist dies
ein polynomieller Verifizierer, und $\problem{Longest Path} \in \NP$.

\medskip
\textbf{(c) NTM.} Rate nacheinander $k+1$ Knoten auf ein Arbeitsband
($O(k \log |V|)$ nichtdeterministische Schritte). Prüfe danach
\emph{deterministisch} die Verschiedenheit und die Kantenbedingung wie in (b).
Laufzeit: Raten $O(k \log |V|)$ plus Prüfen $\poly(|V|)$ -- insgesamt
polynomiell.
\hfill$\square$
\end{loesung}

\subsection{Bewertung und häufige Fehler}

\begin{bewertung}
Typisches Punkteschema pro Teil: \emph{Beschreibung} 2\,P., \emph{Korrektheit}
1\,P., \emph{Laufzeit} 1\,P. Der Korrektor will sehen:
\begin{itemize}
\item eine \emph{konkrete} $O$-Notation -- \glqq polynomiell\grqq{} allein reicht
nicht;
\item \emph{beide} Korrektheitsrichtungen, nicht nur \glqq Pfad $\Rightarrow$
Zertifikat\grqq;
\item dass die \emph{Kardinalität} ($|C| \le k$ bzw.\ Länge $\ge k$) mitgeprüft
wird.
\end{itemize}
\end{bewertung}

\begin{stolper}
Die drei Klassiker: (1) nur \glqq polynomiell\grqq{} schreiben, wo eine konkrete
Schranke verlangt ist. (2) Die Rückrichtung der Korrektheit weglassen. (3) Beim
Verifizierer vergessen, die Größe zu prüfen -- ein Zertifikat könnte sonst
\glqq zu klein\grqq{} oder \glqq zu groß\grqq{} sein und würde trotzdem akzeptiert.
\end{stolper}

\subsection{Zweite Variante (kurz): Knapsack $\in$ NP}

Damit du das Muster auf ein Zahlenproblem überträgst:

\begin{loesung}
\textbf{Zertifikat:} eine Teilmenge $S \subseteq \{1,\dots,n\}$ der Gegenstände
(ein Bit pro Gegenstand). \textbf{Verifizierer:} berechne $\sum_{i \in S} w_i$
und $\sum_{i \in S} p_i$, prüfe $\sum_{i \in S} w_i \le B$ und
$\sum_{i \in S} p_i \ge P$; akzeptiere entsprechend. Beide Summen und Vergleiche
in $O(n)$. \textbf{Korrektheit:} Existiert eine zulässige Auswahl mit genügend
Profit, wird sie akzeptiert; sonst keine. Also $\problem{Knapsack} \in \NP$.
\hfill$\square$
\end{loesung}

% ##################################################################
\section{Reduktion konstruieren (NP-Schwere)}
% ##################################################################

\begin{ziel}
Der zentrale und häufigste Klausurtyp. Du beweist, dass ein \emph{neues} Problem
schwer ist, indem du ein bekannt schweres Problem darauf reduzierst. Fast immer
ist das neue Problem eine \emph{Variante} eines Standardproblems.
\end{ziel}

\subsection{Woran du diesen Typ erkennst}

\glqq Zeigen Sie, dass \problem{X} NP-vollständig (oder NP-schwer) ist.\grqq{}
Meist ist \problem{X} ein leicht abgewandeltes bekanntes Problem -- mit einer
Zusatzeigenschaft, gerichtet statt ungerichtet, mit einer Nebenbedingung.

\subsection{Das Rezept}

\begin{rezept}{NP-Vollständigkeit in 6 Schritten}
\textbf{1. $\in$ NP.} Verifizierer angeben (oft: \glqq wie beim Originalproblem\grqq).
Bei reiner NP-\emph{Schwere} entfällt dieser Schritt.\\[0.3em]
\textbf{2. Quellproblem wählen.} Ein bekanntes NP-vollständiges $X$, das dem Ziel
$Y$ ähnlich ist. \textbf{Richtung: $X \redp Y$} (bekannt $\redp$ neu).\\[0.3em]
\textbf{3. Konstruktion.} Wie wird aus einer $X$-Instanz eine $Y$-Instanz?
Präzise, mit \emph{allen} Parametern -- auch die Schranke $k$ anpassen!\\[0.3em]
\textbf{4. Polynomialität.} Ein Satz: \glqq Die Konstruktion läuft in
$O(\cdot)$.\grqq\\[0.3em]
\textbf{5. Korrektheit, beide Richtungen.} $\Rightarrow$: Ja-Instanz von $X$
liefert Ja-Instanz von $Y$. $\Leftarrow$: Ja-Instanz von $Y$ liefert Ja-Instanz
von $X$.\\[0.3em]
\textbf{6. Schlusssatz.} \glqq Da $X$ NP-vollständig, $X \redp Y$ und
$Y \in \NP$: $Y$ ist NP-vollständig.\grqq
\end{rezept}

\subsection{Musteraufgabe 1}

\begin{aufgabe}{Feedback Vertex Set (Hausaufgabe 10.1)}
\problem{Feedback Vertex Set (FVS)}: Gegeben ein \emph{gerichteter} Graph
$G = (V,E)$ und $k$. Gibt es $X \subseteq V$ mit $|X| \le k$, sodass
$G \setminus X$ \emph{kreisfrei} ist? Zeigen Sie: \problem{FVS} ist
NP-vollständig.
\end{aufgabe}

\begin{loesung}
\textbf{1. $\in$ NP.} Zertifikat $X \subseteq V$. Der Verifizierer prüft
$|X| \le k$ und ob $G \setminus X$ kreisfrei ist -- Letzteres mit dem
Algorithmus zur \emph{topologischen Sortierung} (findet genau dann eine
Sortierung, wenn der Graph kreisfrei ist). Beides in $O(|V| + |E|)$, also
$\problem{FVS} \in \NP$.

\medskip
\textbf{2. Quellproblem.} \problem{Vertex Cover} ist NP-vollständig. Wir zeigen
$\problem{VC} \redp \problem{FVS}$.

\medskip
\textbf{3. Konstruktion.} Sei $(G = (V,E), k)$ eine \problem{VC}-Instanz
(ungerichtet). Baue den gerichteten Graphen $G' = (V, E')$ mit
\[
E' = \{\, (u,v),\ (v,u) \ \mid\ \{u,v\} \in E \,\},
\]
also: \emph{jede ungerichtete Kante wird zu zwei antiparallelen Bögen} (einem
gerichteten Kreis der Länge 2). Die Schranke bleibt $k' = k$. Ausgabe $(G', k)$.

\begin{center}
\setlength{\unitlength}{1cm}
\begin{picture}(9,1.7)(0,-0.4)
\put(0.6,0.5){\circle*{0.14}}\put(0.3,0.7){\small $u$}
\put(2.6,0.5){\circle*{0.14}}\put(2.75,0.7){\small $v$}
\put(0.6,0.5){\line(1,0){2}}
\put(1.2,-0.05){\small ungerichtet in $G$}
\put(3.3,0.45){\small $\leadsto$}
\put(5.0,0.5){\circle*{0.14}}\put(4.7,0.7){\small $u$}
\put(7.0,0.5){\circle*{0.14}}\put(7.15,0.7){\small $v$}
\put(5.15,0.68){\vector(1,0){1.7}}
\put(6.85,0.32){\vector(-1,0){1.7}}
\put(5.0,-0.05){\small zwei antiparallele Bögen in $G'$}
\end{picture}
\end{center}

\textbf{4. Polynomialität.} Pro Kante werden zwei Bögen erzeugt, also
$O(|E|)$ -- polynomiell.

\medskip
\textbf{5. Korrektheit.}
\begin{itemize}
\item[$\Rightarrow$] Sei $C$ ein Vertex Cover mit $|C| \le k$. Dann berührt $C$
jede Kante, also enthält $G \setminus C$ keine Kante. Damit enthält
$G' \setminus C$ keinen Bogen und erst recht keinen Kreis -- $C$ ist ein FVS.
\item[$\Leftarrow$] Sei $X$ ein FVS mit $|X| \le k$. Angenommen, $X$ wäre
\emph{kein} Vertex Cover. Dann gäbe es eine Kante $\{u,v\} \in E$ mit
$u \notin X$ und $v \notin X$. In $G'$ bleiben dann beide Bögen $(u,v)$ und
$(v,u)$ übrig -- also der Kreis $(u, v, u)$ in $G' \setminus X$. Das ist ein
Widerspruch dazu, dass $X$ ein FVS ist. Also ist $X$ ein Vertex Cover.
\end{itemize}

\textbf{6. Schluss.} Da \problem{VC} NP-vollständig ist, $\problem{VC} \redp
\problem{FVS}$ gilt und $\problem{FVS} \in \NP$, ist \problem{FVS}
NP-vollständig. \hfill$\square$
\end{loesung}

\subsection{Musteraufgabe 2 (kurz): Clique $\redp$ Vertex Cover}

Die kürzeste Reduktion überhaupt -- reine Komplement-Umformung, kein Gadget.

\begin{loesung}
\textbf{Konstruktion.} Aus der \problem{Clique}-Instanz $(G, k)$ mit $n = |V|$
mache die \problem{VC}-Instanz $(\bar G, n - k)$: nimm den Komplementgraphen und
setze die Schranke auf $n - k$.

\textbf{Korrektheit.}
$\Rightarrow$ Ist $C$ eine Clique der Größe $\ge k$ in $G$, so ist $C$ ein
Independent Set in $\bar G$, und $V \setminus C$ ein Vertex Cover in $\bar G$
der Größe $\le n - k$.
$\Leftarrow$ Ist $D$ ein Vertex Cover der Größe $\le n-k$ in $\bar G$, so ist
$V \setminus D$ ein Independent Set der Größe $\ge k$ in $\bar G$ -- also eine
Clique der Größe $\ge k$ in $G$.

\textbf{Laufzeit.} Komplementgraph in $O(n^2)$. \hfill$\square$
\end{loesung}

\subsection{Bewertung und häufige Fehler}

\begin{bewertung}
Punkteschema (aus Hausaufgabe 11.1): Verifizierer $1{+}0{,}5{+}0{,}5$\,P.;
Angabe der Reduktion 1\,P.; \emph{Korrektheit 3\,P.} -- davon \textbf{1,5 pro
Richtung}; Laufzeit 1\,P.; Beweisführung 1\,P. Merke: Die Rückrichtung zu
vergessen kostet also glatt 1,5 Punkte.
\end{bewertung}

\begin{stolper}
\textbf{Die vier teuren Fehler:}
\begin{itemize}
\item \emph{Falsche Richtung.} Immer \textbf{bekannt $\redp$ neu}
($X_{\text{bekannt}} \redp Y_{\text{neu}}$), nie umgekehrt.
\item \emph{Rückrichtung vergessen} -- kostet 1,5 von 5 Punkten.
\item \emph{Zusatzeigenschaft nicht hergestellt.} Prüfe, dass jede konstruierte
$Y$-Instanz die geforderte Sonderstruktur wirklich hat (universeller Knoten,
Grad-Bedingung, \dots).
\item \textbf{Nicht \emph{alle} Fälle in der Korrektheit.} Siehe der echte
Punktabzug unten.
\end{itemize}
\end{stolper}

\begin{bewertung}
\textbf{Echter Punktabzug (Hausaufgabe 11.1, 9/10).} Bei der Reduktion
$\problem{VC} \redp \Delta\text{-}\problem{Cover}$ (jede Kante $e=\{u,v\}$ wird
zum Dreieck $\{v_e, u, v\}$ aufgeblasen) stand im Beweis: \glqq \emph{jedes}
Dreieck in $G'$ hat die Form $\{v_e, u, v\}$\grqq. Das ist falsch: Weil
$E \subseteq E'$ gilt, \emph{erbt} $G'$ auch alle Dreiecke, die $G$ schon hatte
(drei paarweise verbundene Original-Knoten). Diese haben \emph{nicht} die
Gadget-Form. Der Beweis muss zusätzlich zeigen, dass auch so ein geerbtes
Dreieck $\{a,b,c\}$ vom Cover getroffen wird -- was aus dem Vertex Cover folgt
(die Kante $\{a,b\}$ ist gedeckt, also $a \in C$ oder $b \in C$).
\emph{Lehre: In der Korrektheit immer \textbf{alle} Objekte abdecken, auch die
aus dem Originalgraphen geerbten.}
\end{bewertung}

% ##################################################################
\section{Wahr oder falsch? Mit Begründung}
% ##################################################################

\begin{ziel}
Dieser Typ testet, ob du die Begriffe wirklich beherrschst. Du bekommst mehrere
Aussagen über P, NP, Reduktionen und Vollständigkeit und musst jede als wahr
oder falsch \emph{begründen}. Er festigt genau das, was du in Kapitel 1 und 2
gelernt hast.
\end{ziel}

\subsection{Das Rezept}

\begin{rezept}{So knackst du jede Aussage}
\textbf{1.} Führe die Aussage auf die \emph{Definitionen} zurück. Zwei
Merksätze reichen fast immer:
\begin{itemize}
\item \emph{NP-schwer} = untere Schranke (\glqq mindestens so schwer wie alles in
NP\grqq). \emph{$\in$ NP} = obere Schranke.
\item $A \redp B$ heißt \glqq $B$ mindestens so schwer wie $A$\grqq. Die Richtung
ist alles.
\end{itemize}
\textbf{2.} Ist die Aussage \emph{falsch}, gib ein \textbf{konkretes
Gegenbeispiel} (oft $L = \emptyset$ oder ein triviales $L \in \Pclass$).\\
\textbf{3.} Ist sie \emph{wahr}, begründe in einem Satz aus der Definition.
\end{rezept}

\subsection{Musteraufgabe}

\begin{aufgabe}{Fragen über Fragen (Präsenz 11.1)}
Entscheide jeweils wahr/falsch und begründe. Sei $L$ eine Sprache.
\begin{enumerate}
\item[(a)] $L \in \NP$ und $L \redp \problem{3-SAT}$ $\Rightarrow$ $L$ ist
NP-vollständig.
\item[(b)] $L \redp \problem{3-SAT}$ und $\problem{3-SAT} \redp L$ $\Rightarrow$
$L$ ist NP-vollständig.
\item[(c)] $L$ NP-vollständig $\Rightarrow$ ($L \in \Pclass \iff \Pclass = \NP$).
\item[(d)] Es ist möglich, dass $\problem{3-SAT} \in \Pclass$ und
$\problem{Clique} \notin \Pclass$.
\end{enumerate}
\end{aufgabe}

\begin{loesung}
\textbf{(a) Falsch.} $L \redp \problem{3-SAT}$ heißt nur, dass sich $L$ \emph{auf}
3-SAT reduziert -- das macht $L$ \emph{nicht} schwer, sondern höchstens
\glqq so leicht wie 3-SAT\grqq. Gegenbeispiel: $L = \emptyset$. Es liegt in
$\NP$ und ist auf 3-SAT reduzierbar, aber sicher nicht NP-vollständig. Für
NP-Schwere bräuchte man die \emph{andere} Richtung $\problem{3-SAT} \redp L$.

\medskip
\textbf{(b) Wahr.} Das ist genau die Definition. Aus $\problem{3-SAT} \redp L$
folgt, dass $L$ NP-schwer ist (3-SAT ist NP-vollständig, Schwere vererbt sich).
Aus $L \redp \problem{3-SAT}$ folgt $L \in \NP$ (denn 3-SAT $\in \NP$, und die
Reduktion überträgt die Zugehörigkeit). Schwer und in NP $=$ NP-vollständig.

\medskip
\textbf{(c) Wahr.} Ist $L$ NP-vollständig, so reduziert sich jedes
$L' \in \NP$ auf $L$. Läge $L$ in $\Pclass$, wäre damit jedes $L' \in \Pclass$,
also $\Pclass = \NP$. Umgekehrt folgt aus $\Pclass = \NP$ trivial
$L \in \Pclass$. (Das ist der zentrale Satz über NP-vollständige Probleme.)

\medskip
\textbf{(d) Falsch.} \problem{Clique} lässt sich auf \problem{3-SAT} reduzieren
(3-SAT ist NP-vollständig, also ist jedes NP-Problem auf es reduzierbar). Läge
\problem{3-SAT} in $\Pclass$, folgte über diese Reduktion auch
$\problem{Clique} \in \Pclass$. Die beschriebene Situation kann es also nicht
geben. \hfill$\square$
\end{loesung}

\subsection{Zweite Variante (kurz): Präsenz 10.1}

\begin{loesung}
\textbf{(i)} \glqq Löst eine NDTM ein Problem in Polyzeit, dann auch eine
gewöhnliche DTM.\grqq{} -- \emph{Nicht beweisbar wahr}: Das würde $\Pclass = \NP$
bedeuten, und das ist offen.\\[0.3em]
\textbf{(ii)} \glqq $A$ NP-schwer $\Rightarrow A \in \Pclass$ ausgeschlossen /
$A \in \NP$.\grqq{} -- \emph{Falsch}: NP-schwer sagt nichts über die
Zugehörigkeit zu NP. Das \problem{Halteproblem} ist NP-schwer, liegt aber nicht
in $\NP$ (es ist nicht einmal entscheidbar). \hfill$\square$
\end{loesung}

\subsection{Bewertung und häufige Fehler}

\begin{bewertung}
Hier zählt \emph{ausschließlich die Begründung}, nicht das Kreuz. Ein richtiges
\glqq falsch\grqq{} ohne Gegenbeispiel gibt kaum Punkte. Nenne bei falschen
Aussagen immer ein \emph{konkretes} Gegenbeispiel; bei wahren die \emph{eine}
Definition, aus der es folgt.
\end{bewertung}

\begin{stolper}
Der Dauerbrenner ist die \emph{Reduktionsrichtung}. \glqq $L \redp \problem{3-SAT}$\grqq{}
macht $L$ nicht schwer -- es macht $L$ höchstens leicht. Verwechselst du die
Richtung, drehst du fast jede Aussage ins Gegenteil.
\end{stolper}

% ##################################################################
\section{ETH-Schranke herleiten}
% ##################################################################

\begin{ziel}
Die typische \emph{letzte} Klausuraufgabe. Aus einer \emph{vorgegebenen}
Reduktion leitest du untere Laufzeitschranken her -- unter Annahme der
Exponentialzeit-Hypothese (ETH). Du musst hier keine Reduktion erfinden, sondern
sauber \emph{rechnen} und argumentieren.
\end{ziel}

\subsection{Woran du diesen Typ erkennst}

\glqq Gegeben die Reduktion \dots. Zeigen Sie unter Annahme der ETH, dass
\problem{X} nicht in Zeit $2^{o(p)} \cdot \poly$ lösbar ist -- für die Parameter
$p \in \{\dots\}$.\grqq{} Meist sind mehrere Parameter gefragt (Universumsgröße,
Mengenzahl, $k$), und bei manchen brauchst du das Sparsification-Lemma, bei
anderen nicht.

\subsection{Das Rezept}

\begin{rezept}{ETH-Schranke in 3 Schritten}
\textbf{1. Parameter durch $n$ und $m$ ausdrücken.} Drücke jede gefragte
Instanzgröße (Knoten, Mengen, $k$, \dots) durch die Variablenzahl $n$ und die
Klauselzahl $m$ der 3-SAT-Formel aus. Nutze $n \le 3m$.\\[0.3em]
\textbf{2. Kontrapositions-Baustein hinschreiben.} Für jeden Parameter $p$:
\begin{quote}\small\itshape
Angenommen, es gäbe einen Algorithmus, der \problem{X} in
$2^{o(p)} \cdot |I|^{O(1)}$ löst. Zusammen mit der Reduktion ergäbe das einen
Algorithmus für 3-SAT in $2^{o(\,\cdot\,)}$. Nach der ETH (bzw.\ dem
Sparsification-Lemma) ist das ausgeschlossen -- Widerspruch.
\end{quote}
\textbf{3. Das Sparsification-Lemma nur zitieren, wenn nötig.} Hängt $p$ an $n$,
brauchst du es \emph{nicht} (die ETH spricht direkt über $n$). Hängt $p$ an $m$,
\emph{musst} du es zitieren (die ETH allein verbietet $2^{o(m)}$ nicht).
\end{rezept}

\subsection{Musteraufgabe}

\begin{aufgabe}{Lower Bounds für Hitting Set (Hausaufgabe 12.2)}
\problem{Hitting Set}: Universum $U$, Mengen $F_1, \dots, F_r \subseteq U$,
Zahl $k$. Gibt es $S \subseteq U$, $|S| \le k$, das jede Menge trifft
($S \cap F_i \ne \emptyset$)? \emph{Gegeben} ist die Reduktion
$\problem{3-SAT} \redp \problem{Hitting Set}$:
\begin{itemize}
\item $U = \{x_1, \bar x_1, \dots, x_n, \bar x_n\}$ (alle Literale),
\item für jede Variable $i$ die Menge $F_i = \{x_i, \bar x_i\}$,
\item für jede Klausel $j$ die Menge $F_{n+j} = \{\text{Literale von } C_j\}$,
\item $k = n$.
\end{itemize}
Geben Sie (1) die Parameter $|U|, r, k$ an und leiten Sie (2) unter der ETH die
unteren Schranken bezüglich $|U|$, $r$ und $k$ her.
\end{aufgabe}

\begin{loesung}
\textbf{Teil 1 -- Parameter.} Es gilt
\[
|U| = 2n, \qquad r = n + m, \qquad k = n.
\]

\textbf{Teil 2 -- untere Schranken.}

\emph{Bezüglich $|U|$: kein $2^{o(|U|)}$.} Angenommen, ein Algorithmus löste
\problem{Hitting Set} in $2^{o(|U|)} \cdot \poly$. Wegen $|U| = 2n$ wäre das
$2^{o(n)}$. Über die Reduktion ergäbe das einen $2^{o(n)}$-Algorithmus für
3-SAT -- Widerspruch \emph{direkt} zur ETH. (Kein Sparsification-Lemma nötig, da
$|U|$ nur an $n$ hängt.)

\medskip
\emph{Bezüglich $r$: kein $2^{o(r)}$.} Hier ist $r = n + m$. Wegen $n \le 3m$
gilt $r \le 4m = O(m)$. Ein $2^{o(r)}$-Algorithmus wäre also ein
$2^{o(m)}$-Algorithmus und ergäbe über die Reduktion einen
$2^{o(m)}$-Algorithmus für 3-SAT. Nach dem \textbf{Sparsification-Lemma} ist das
unter der ETH ausgeschlossen -- Widerspruch. (Hier ist das Lemma
\emph{zwingend}, weil der Parameter an $m$ hängt.)

\medskip
\emph{Bezüglich $k$: kein $2^{o(k)}$.} Wegen $k = n$ ist das genau wie im ersten
Fall: $2^{o(k)} = 2^{o(n)}$ ergäbe $2^{o(n)}$ für 3-SAT -- direkter Widerspruch
zur ETH. \hfill$\square$
\end{loesung}

\subsection{Bewertung und häufige Fehler}

\begin{bewertung}
Wiederhole den Schluss-Baustein \emph{in jedem} Teilpunkt vollständig -- der
Korrektor will pro Parameter das ganze Argument sehen, nicht nur beim ersten.
Entscheidend ist, ob du bei jedem Parameter richtig erkennst, \emph{ob} das
Sparsification-Lemma gebraucht wird.
\end{bewertung}

\begin{stolper}
Der Kern: \emph{$n$ oder $m$?} Hängt der Parameter an der Variablenzahl $n$,
argumentierst du \emph{direkt} mit der ETH. Hängt er an der Klauselzahl $m$
(oder an $n+m$, was $O(m)$ ist), \emph{musst} du das Sparsification-Lemma
nennen. Es einfach immer oder nie zu zitieren, kostet Punkte.
\end{stolper}

% ##################################################################
\section{Approximationsalgorithmus anwenden}
% ##################################################################

\begin{ziel}
Ein Themenwechsel: weg von den Härte-Beweisen, hin zur Approximation. Dieser Typ
ist eine reine \emph{Rechenaufgabe} -- du lässt einen bekannten Algorithmus
Schritt für Schritt auf eine konkrete Instanz laufen. Wenig Kreativität, viel
Sorgfalt.
\end{ziel}

\subsection{Woran du diesen Typ erkennst}

\glqq Wenden Sie den Algorithmus \dots auf die folgende Instanz an. Geben Sie
alle Zwischenschritte an.\grqq{} Kandidaten: List Scheduling / LPT, $\Delta$TSP$_1$,
Christofides, Knapsack-Greedy / Modified Greedy.

\subsection{Das Rezept}

\begin{rezept}{Was du flüssig können musst}
\begin{itemize}
\item \textbf{LPT / List Scheduling:} Jobs (bei LPT erst absteigend sortieren) der
Reihe nach auf die Maschine mit \emph{kleinster} Last; Schedule als
Gantt-Balken zeichnen; Güte nennen.
\item \textbf{$\Delta$TSP$_1$:} minimaler Spannbaum $\to$ Kanten verdoppeln $\to$
Eulerkreis $\to$ abkürzen.
\item \textbf{Christofides:} MST $\to$ ungerade Knoten $\to$ min.\ Matching
darauf $\to$ Eulerkreis $\to$ abkürzen. \emph{Alle Zwischengraphen angeben.}
\item \textbf{Knapsack-Greedy / MGA:} nach Profitdichte $p_i/w_i$ sortieren,
einpacken was passt; MGA zusätzlich mit dem besten Einzel-Item vergleichen.
\end{itemize}
\end{rezept}

\subsection{Musteraufgabe}

\begin{aufgabe}{Knapsack Greedy und Modified Greedy (Klausur SS23, Aufgabe 1)}
Kapazität $B = 16$. Gegenstände als $(p_i, w_i)$:
\[
(1,4),\ (1,1),\ (1,3),\ (11,13),\ (3,3),\ (5,6),\ (1,5).
\]
Führen Sie Greedy (GA) und Modified Greedy (MGA) aus und vergleichen Sie mit dem
Optimum.
\end{aufgabe}

\begin{loesung}
\textbf{Schritt 1 -- Profitdichten $p_i/w_i$ berechnen und sortieren.}
\begin{center}\small
\begin{tabular}{lccccccc}
\toprule
$(p,w)$ & $(1,4)$ & $(1,1)$ & $(1,3)$ & $(11,13)$ & $(3,3)$ & $(5,6)$ & $(1,5)$\\
Dichte & $0{,}25$ & $1$ & $0{,}33$ & $0{,}85$ & $1$ & $0{,}83$ & $0{,}2$\\
\bottomrule
\end{tabular}
\end{center}
Absteigend sortiert: $(1,1),\ (3,3),\ (11,13),\ (5,6),\ (1,3),\ (1,4),\ (1,5)$.

\medskip
\textbf{Schritt 2 -- Greedy einpacken} (Kapazität $B=16$, laufende Last):
\begin{itemize}
\item $(1,1)$: passt, Last $1$.
\item $(3,3)$: passt, Last $4$.
\item $(11,13)$: $4+13 = 17 > 16$ -- \emph{passt nicht}.
\item $(5,6)$: $4+6 = 10$, passt, Last $10$.
\item $(1,3)$: $10+3 = 13$, passt, Last $13$.
\item $(1,4)$: $13+4 = 17 > 16$ -- passt nicht. $(1,5)$: $13+5 = 18$ -- passt nicht.
\end{itemize}
Greedy-Profit: $\mathrm{GA} = 1 + 3 + 5 + 1 = \mathbf{10}$.

\medskip
\textbf{Schritt 3 -- Modified Greedy.} Vergleiche mit dem besten Einzel-Item.
Das ist $(11,13)$ mit Profit $11 > 10$. Also $\mathrm{MGA} = \mathbf{11}$.

\medskip
\textbf{Schritt 4 -- Optimum und Vergleich.} Optimal ist
$\{(11,13), (3,3)\}$: Gewicht $13 + 3 = 16 \le B$, Profit $\OPT = \mathbf{14}$.
Greedy verfehlt das schwere, profitable Item wegen seiner mittelmäßigen Dichte;
MGA repariert das teilweise (garantierte Güte 2). \hfill$\square$
\end{loesung}

\subsection{Zweite Variante: Christofides mit allen Zwischenschritten}

\begin{aufgabe}{Christofides (Klausur SS23-N, Aufgabe 1)}
Knoten $a,b,c,d$ mit $d(a,b)=1$, $d(b,c)=2$, $d(a,d)=2$, $d(a,c)=3$, $d(c,d)=3$,
$d(b,d)=3$. Wenden Sie Christofides an.
\end{aufgabe}

\begin{loesung}
\textbf{(1) MST} (Kruskal): $\{a,b\}\,(1)$, $\{b,c\}\,(2)$, $\{a,d\}\,(2)$;
Gewicht $5$.\\
\textbf{(2) Ungerade Grade im MST:} $a$ hat Grad 2, $b$ Grad 2, $c$ Grad 1,
$d$ Grad 1 $\Rightarrow X = \{c, d\}$.\\
\textbf{(3) Minimales perfektes Matching auf $X$:} nur die Kante $\{c,d\}$,
Kosten $3$.\\
\textbf{(4) Multigraph $T + K$:} Kanten $a\text{-}b, b\text{-}c, a\text{-}d,
c\text{-}d$ -- alle Grade jetzt gerade. \textbf{Eulerkreis} ab $a$:
$[a,b,c,d,a]$, Kosten $1+2+3+2 = 8$.\\
\textbf{(5) Abkürzen:} kein Knoten kommt doppelt vor -- dieser Schritt ändert
hier \emph{nichts} (trotzdem erwähnen!). Tour $[a,b,c,d,a]$, Länge $8$.\\
Hier ist sogar $8 = \OPT$. Güte-Garantie: $1{,}5$; benötigt Symmetrie \emph{und}
Dreiecksungleichung. \hfill$\square$
\end{loesung}

\subsection{Bewertung und häufige Fehler}

\begin{bewertung}
Punkte gibt es für die \emph{Zwischenschritte}, nicht nur das Endergebnis. Bei
Christofides: alle Zwischengraphen angeben. Bei Scheduling: den Schedule als
Gantt-Diagramm zeichnen. Und stets die \emph{Güte} des Verfahrens dazuschreiben.
\end{bewertung}

\begin{stolper}
Der Klassiker: den \emph{Abkürzen}-Schritt weglassen, wenn er nichts ändert --
er gehört trotzdem hin. Und bei Greedy die Dichte-Sortierung nicht sauber
hinschreiben, sodass die Einpack-Reihenfolge nicht nachvollziehbar ist.
\end{stolper}

% ##################################################################
\section{Güte beweisen und Worst-Case-Instanz bauen}
% ##################################################################

\begin{ziel}
Der anspruchsvollste Approximationstyp, fast immer \emph{zweiteilig}: (a)
beweise, dass ein Algorithmus eine bestimmte Güte einhält, und (b) konstruiere
eine Instanz, die diese Schranke (fast) erreicht -- die also zeigt, dass die
Schranke \emph{scharf} ist.
\end{ziel}

\subsection{Das Rezept}

\begin{rezept}{Die zwei Teile}
\textbf{Teil (a) -- Güte beweisen.} Meist eines von drei Mustern:
\begin{itemize}
\item \emph{OPT von unten abschätzen} über eine Struktur (z.\,B.\ ein Matching:
jede Optimallösung braucht pro Matching-Kante einen eigenen Knoten).
\item \emph{Widerspruch + Zählen} (z.\,B.\ MAX-3-SAT: jede Klausel wird von einer
der beiden Belegungen erfüllt).
\item \emph{Scheduling-Schranken}: $\OPT \ge \frac1m \sum p_i$ und
$\OPT \ge p_{\max}$.
\end{itemize}
\textbf{Teil (b) -- Worst-Case-Instanz.}
\begin{enumerate}
\item Zwinge den Algorithmus zu einer lokal guten, global schlechten
Entscheidung (Greedy-Falle).
\item Parametrisiere die Instanz und berechne $A(I)$ und $\OPT(I)$ \emph{explizit}.
\item Zeige $A(I)/\OPT(I) \to$ Schranke -- mit \emph{Grenzwert}.
\end{enumerate}
\end{rezept}

\subsection{Musteraufgabe}

\begin{aufgabe}{MAX-3-SAT, Güte 2 (Hausaufgabe 13.1 = Klausur SS23)}
Algorithmus $A$: werte die Formel unter $\beta_0$ (alle Variablen \false) und
$\beta_1$ (alle \true) aus, gib die bessere zurück. (a) Zeige
$v(A(\varphi)) \ge \tfrac12\, v(\OPT(\varphi))$. (b) Gib eine Formel an, bei der
$A$ genau die Hälfte des Optimums erreicht.
\end{aufgabe}

\begin{loesung}
\textbf{(a) Güte-Beweis (Widerspruch + Zählen).} Sei $\varphi$ eine Formel mit
$m$ Klauseln. \emph{Schlüsselbeobachtung:} Jede Klausel enthält mindestens ein
Literal -- ist es positiv, wird die Klausel von $\beta_1$ (alle \true) erfüllt;
ist es negativ, von $\beta_0$ (alle \false). Jede Klausel wird also von
\emph{mindestens einer} der beiden Belegungen erfüllt. Summiert man:
\[
v(\beta_0) + v(\beta_1) \;\ge\; m.
\]
Also erfüllt die bessere der beiden mindestens $m/2$ Klauseln:
$v(A(\varphi)) = \max\{v(\beta_0), v(\beta_1)\} \ge \tfrac{m}{2}$. Da eine
optimale Belegung höchstens alle $m$ Klauseln erfüllt, ist
$v(\OPT(\varphi)) \le m$. Zusammen:
\[
v(A(\varphi)) \;\ge\; \tfrac{m}{2} \;\ge\; \tfrac{1}{2}\, v(\OPT(\varphi)).
\]
Somit hat $A$ Güte 2.

\medskip
\textbf{(b) Scharfe Instanz.} Wähle
\[
\varphi = (x_1 \vee x_2 \vee x_3) \;\wedge\; (\neg x_0 \vee \neg x_2 \vee \neg x_3).
\]
Optimum: die Belegung $x_0 = \false$, $x_1 = x_2 = x_3 = \true$ erfüllt
\emph{beide} Klauseln, also $\OPT = 2$. Der Algorithmus aber: $\beta_1$ (alle
\true) erfüllt nur Klausel 1 (Klausel 2 hat lauter negative Literale, alle
falsch); $\beta_0$ (alle \false) erfüllt nur Klausel 2. Also
$v(A(\varphi)) = \max\{1,1\} = 1 = \tfrac12 \OPT$. Die Schranke wird exakt
erreicht. \emph{Bauprinzip: eine Klausel nur positiv, eine nur negativ.}
\hfill$\square$
\end{loesung}

\subsection{Zweite Variante: Approximate Subset Sum (Klausur SS24-H)}

\begin{aufgabe}{Greedy für Approximate Subset Sum}
Maximiere $\sum_{j \in S} a_j \le T$. Algorithmus GA: sortiere absteigend, nimm
der Reihe nach, \emph{stoppe} beim ersten Element, das nicht mehr passt. (a)
Instanzen, die Güte 2 annähern; (b) zeige $\mathrm{GA}(I) \ge \OPT(I)/2$.
\end{aufgabe}

\begin{loesung}
\textbf{(a) Worst-Case-Familie.} Für gerades $T$: $a_1 = \tfrac{T}{2}+1$,
$a_2 = a_3 = \tfrac{T}{2}$. GA nimmt zuerst $a_1$ (das größte) und stoppt, denn
$a_2$ passt nicht mehr ($\tfrac T2 + 1 + \tfrac T2 > T$). Also
$\mathrm{GA} = \tfrac T2 + 1$. Optimal sind $a_2 + a_3 = T$, also $\OPT = T$.
Rate: $\tfrac{T}{T/2+1} \to 2$ für $T \to \infty$.

\medskip
\textbf{(b) Güte-Beweis.} Sei $S$ die von GA gewählte Menge und $a_\ell$ das
erste Element, das nicht mehr passte. Dann ist
$\mathrm{GA}(I) + a_\ell > T \ge \OPT(I)$. Wegen der absteigenden Sortierung
enthält $S$ ein Element $a_j \ge a_\ell$, also $\mathrm{GA}(I) \ge a_\ell$.
Einsetzen:
\[
2\,\mathrm{GA}(I) \;\ge\; \mathrm{GA}(I) + a_\ell \;>\; T \;\ge\; \OPT(I),
\]
somit $\mathrm{GA}(I) \ge \OPT(I)/2$. \hfill$\square$
\end{loesung}

\subsection{Bewertung und häufige Fehler}

\begin{bewertung}
Beide Teile geben Punkte -- der Güte-Beweis (a) und die Konstruktion (b). Bei
(b) reicht keine einzelne Instanz: Gib eine \emph{parametrisierte Familie} an
und zeige den \emph{Grenzwert} $A/\OPT \to$ Schranke. $A(I)$ und $\OPT(I)$ müssen
\emph{explizit} berechnet sein.
\end{bewertung}

\begin{stolper}
In (a) die beiden $\OPT$-Schranken vergessen (bei Scheduling: Durchschnittslast
\emph{und} größter Job). In (b) nur eine feste Instanz angeben statt einer
Familie mit Grenzwert -- dann ist die Schärfe nicht gezeigt.
\end{stolper}

% ##################################################################
\section{Turingmaschine entwerfen}
% ##################################################################

\begin{ziel}
Der letzte Typ steht für sich -- er braucht keine der anderen Techniken. Du
konstruierst eine Turingmaschine für eine formale Sprache, begründest ihre
Korrektheit und schätzt die Laufzeit ab. Manchmal kommt ein Vergleich mit dem
RAM-Modell dazu.
\end{ziel}

\subsection{Das Rezept}

\begin{rezept}{TM in drei Teilen}
\textbf{1. Die Maschine in Worten.} Beschreibe das Verhalten als nummerierte
Schritte (\glqq lies das erste Symbol, laufe nach rechts bis \dots\grqq). Keine
formale Zustandstabelle nötig -- eine klare Wortbeschreibung genügt.\\[0.3em]
\textbf{2. Korrektheit.} Warum akzeptiert die TM genau die Wörter der Sprache?
Ein bis zwei Sätze über die Schleifeninvariante (\glqq nach jedem Durchlauf sind
die äußeren Symbole abgearbeitet\grqq).\\[0.3em]
\textbf{3. Laufzeit.} Kosten pro Durchlauf $\times$ Anzahl Durchläufe. Denk an
die \emph{Randfälle} (leeres Wort, ein Symbol).
\end{rezept}

\subsection{Musteraufgabe}

\begin{aufgabe}{Palindrom-Erkenner (Hausaufgabe 10.2)}
Konstruiere eine Turingmaschine für die Sprache
$L = \{\, w \mid w \text{ ist ein Palindrom} \,\}$ (liest sich vorwärts wie
rückwärts). Gib Korrektheit und Laufzeit an.
\end{aufgabe}

\begin{loesung}
\textbf{Die Maschine.}
\begin{enumerate}
\item Ist das Band leer, \emph{akzeptiere} (das leere Wort ist ein Palindrom).
\item Steht nur noch ein Buchstabe, \emph{akzeptiere}.
\item Lies den \emph{ersten} Buchstaben, merke ihn im Zustand, laufe zum
\emph{letzten} Buchstaben. Sind die beiden \emph{verschieden}, \emph{verwirf}.
Sind sie gleich, ersetze beide durch ein Leersymbol $x$ (erst den letzten, dann
laufe zurück zum ersten und lösche ihn).
\item Gehe zu Schritt 1.
\end{enumerate}

\textbf{Korrektheit.} Die Maschine vergleicht wiederholt das äußerste Paar von
Buchstaben und streicht es weg. Sie akzeptiert genau dann, wenn bei jedem
Vergleich beide Enden gleich waren -- also wenn $w$ symmetrisch ist. Sie endet
in der Mitte mit einem oder keinem Buchstaben (beides Palindrome). Bei
Ungleichheit verwirft sie sofort.

\textbf{Laufzeit.} Ein Durchlauf (Schritte 1--3) kostet $O(n)$: der Kopf läuft
einmal von links nach rechts und zurück. Pro Durchlauf werden zwei Buchstaben
gestrichen, es gibt also höchstens $\lfloor n/2 \rfloor$ Durchläufe. Insgesamt
$O(n) \cdot O(n) = O(n^2)$. \hfill$\square$
\end{loesung}

\subsection{Zweite Variante: $L = \{0^{2^n}\}$ (Präsenz 10.3)}

Etwas anspruchsvoller, mit RAM-Vergleich.

\begin{loesung}
\textbf{Die Maschine} (akzeptiert Nullfolgen, deren Länge eine Zweierpotenz
ist):
\begin{enumerate}
\item Steht genau eine $0$ auf dem Band, \emph{akzeptiere}.
\item Laufe über das Band und streiche \emph{jede zweite} $0$ (ersetze sie
durch $x$).
\item War die Anzahl der $0$en \emph{ungerade} (die letzte gelesene war eine
$0$, die nicht gepaart wurde), \emph{verwirf}.
\item Gehe zu Schritt 1.
\end{enumerate}

\textbf{Korrektheit.} Eine Zahl ist genau dann eine Zweierpotenz, wenn
wiederholtes Halbieren bei $1$ endet, ohne je auf eine ungerade Zahl $>1$ zu
treffen. Genau das prüft die Maschine: jedes Streichen jeder zweiten $0$
halbiert die Anzahl; eine ungerade Anzahl $> 1$ führt zum Verwerfen.

\textbf{Laufzeit.} Jeder Durchlauf kostet $O(n)$, und die Anzahl halbiert sich
jedes Mal -- also $O(\log n)$ Durchläufe. Insgesamt $O(n \log n)$.

\textbf{RAM-Vergleich.} Ein RAM-Modell könnte die $0$en einfach zählen
($O(n)$) und dann in $O(\log n)$ prüfen, ob die Zahl eine Zweierpotenz ist --
schneller, weil es beliebige Speicherzellen direkt adressiert, während die TM
den Kopf über das Band bewegen muss. \hfill$\square$
\end{loesung}

\subsection{Bewertung und häufige Fehler}

\begin{bewertung}
Punkteschema (Hausaufgabe 10.2): \emph{TM-Beschreibung} 2\,P.,
\emph{Korrektheit} 1\,P., \emph{Laufzeit} 2\,P. Die Laufzeit ist also die Hälfte
der Punkte -- rechne sie sauber vor (Kosten pro Durchlauf $\times$ Anzahl
Durchläufe).
\end{bewertung}

\begin{stolper}
Die Randfälle vergessen: leeres Wort, ein einzelnes Symbol. Und die Laufzeit nur
behaupten statt herzuleiten -- gerade hier steckt die halbe Punktzahl.
\end{stolper}

\end{document}
