init
This commit is contained in:
team3
858
lernmaterial/aufgabentypen.tex
Normal file
858
lernmaterial/aufgabentypen.tex
Normal file
@@ -0,0 +1,858 @@
|
||||
\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}
|
||||
Reference in New Issue
Block a user