init
This commit is contained in:
team3
639
nachgenerierte tex dateien/alle_hausaufgaben.tex
Normal file
639
nachgenerierte tex dateien/alle_hausaufgaben.tex
Normal file
@@ -0,0 +1,639 @@
|
||||
\documentclass[11pt,a4paper]{article}
|
||||
|
||||
\usepackage[utf8]{inputenc}
|
||||
\usepackage[T1]{fontenc}
|
||||
\usepackage[main=ngerman, provide=*]{babel}
|
||||
\usepackage{amsmath,amssymb,amsthm}
|
||||
\usepackage{mathtools}
|
||||
\usepackage{geometry}
|
||||
\usepackage{enumitem}
|
||||
\usepackage{xcolor}
|
||||
\usepackage{tcolorbox}
|
||||
\tcbuselibrary{breakable}
|
||||
\usepackage{scalerel}
|
||||
|
||||
\geometry{a4paper, left=2.5cm, right=2.5cm, top=2.5cm, bottom=2.5cm}
|
||||
|
||||
% ---------------------------------------------------------------
|
||||
% Umgebungen
|
||||
% ---------------------------------------------------------------
|
||||
\newtheorem{definition}{Definition}
|
||||
\newtheorem*{loesung}{Lösung}
|
||||
|
||||
% Grafik-Ersatz: klare Beschreibung statt Abbildung
|
||||
\newtcolorbox{grafik}[1]{
|
||||
colback=gray!5,
|
||||
colframe=gray!50,
|
||||
fonttitle=\bfseries,
|
||||
title={Abbildungsbeschreibung: #1},
|
||||
breakable
|
||||
}
|
||||
|
||||
% Kopf jedes offiziellen Aufgabenblatts
|
||||
\newcommand{\blattheader}[2]{%
|
||||
\begin{flushleft}
|
||||
\begin{minipage}{0.15\textwidth}
|
||||
\begin{tcolorbox}[colback=gray!8,colframe=gray!40,boxsep=2pt,left=2pt,right=2pt,top=2pt,bottom=2pt,halign=center,valign=center,height=2.2cm]
|
||||
\scriptsize\itshape Logo\\ CAU Kiel\\ (rundes\\ Siegel)
|
||||
\end{tcolorbox}
|
||||
\end{minipage}\hfill
|
||||
\begin{minipage}{0.82\textwidth}
|
||||
{\bfseries CHRISTIAN-ALBRECHTS-UNIVERSITÄT ZU KIEL}\\
|
||||
Institut für Informatik, Arbeitsgruppe Algorithmen und Komplexität\\
|
||||
Prof.\ Dr.\ K.\ Jansen, B.\ Schumacher, C.\ Wambsganz
|
||||
\end{minipage}
|
||||
\end{flushleft}
|
||||
\begin{flushright}#1\end{flushright}
|
||||
\begin{center}
|
||||
{\Large\bfseries Hausaufgaben zur Vorlesung »Analyse von Algorithmen und Komplexität«}\\[0.4em]
|
||||
{\large Blatt #2}
|
||||
\end{center}
|
||||
\vspace{0.5em}
|
||||
}
|
||||
|
||||
% Kopf jeder Abgabe von Marek
|
||||
\newcommand{\abgabeheader}[2]{%
|
||||
\begin{center}
|
||||
{\Large\bfseries Hausaufgabe #1}\\[0.4em]
|
||||
Marek Lenczewski\\
|
||||
Matrikelnummer: 1025252\\
|
||||
#2
|
||||
\end{center}
|
||||
\vspace{0.5em}
|
||||
}
|
||||
|
||||
\setlength{\parindent}{0pt}
|
||||
\setlength{\parskip}{0.5em}
|
||||
|
||||
\begin{document}
|
||||
|
||||
% ===============================================================
|
||||
% BLATT 9 – Aufgabenblatt (Musterlösung)
|
||||
% ===============================================================
|
||||
\blattheader{09.06.2025}{9}
|
||||
|
||||
\begin{definition}[Vertex Cover (VC)]
|
||||
Für einen (ungerichteten) Graphen $G = (V,E)$ ist ein Vertex Cover eine Menge von Knoten $C \subseteq V$, sodass $u \in C$ oder $v \in C$ für alle $\{u,v\} \in E$ gilt, also ist für alle Kanten mindestens ein Endpunkt in $C$.
|
||||
\end{definition}
|
||||
|
||||
Für das \textsc{VertexCover} Problem ist neben einem Graphen $G$ eine Zahl $k \in \mathbb{N}_{\geq 0}$ gegeben und es wird gefragt, ob ein Vertex Cover mit Größe (Anzahl der Knoten) höchstens $k$ in $G$ existiert.
|
||||
|
||||
\begin{definition}[Feedback Vertex Set (FVS)]
|
||||
Für einen gerichteten Graphen $G = (V,E)$ ist ein Feedback Vertex Set eine Menge von Knoten $X \subseteq V$, sodass $G \setminus X$ kreisfrei ist.
|
||||
\end{definition}
|
||||
|
||||
Für das \textsc{FeedbackVertexSet} Problem ist neben einem Graphen $G$ eine Zahl $k \in \mathbb{N}_{\geq 0}$ gegeben und es wird gefragt, ob ein Feedback Vertex Set mit Größe (Anzahl der Knoten) höchstens $k$ in $G$ existiert.
|
||||
|
||||
\begin{grafik}{Abbildung 1 -- Beispiel Graph}
|
||||
Gerichteter Graph mit acht Knoten $\{1,2,3,4,5,6,7,8\}$.\\[0.3em]
|
||||
\textbf{Anordnung:} Obere Reihe von links nach rechts: $1$, $6$, $2$. Im Zentrum liegen $5$ (links der Mitte) und $7$ (rechts der Mitte). Unten links steht $8$, unten Mitte $4$, rechts $3$.\\[0.3em]
|
||||
\textbf{Gerichtete Kanten (wie in der Abbildung gezeichnet):}
|
||||
\[
|
||||
1 \to 6,\quad 6 \to 2,\quad 2 \to 3,\quad 1 \to 5,\quad 6 \to 5,\quad 7 \to 5,
|
||||
\]
|
||||
\[
|
||||
5 \to 8,\quad 8 \to 4,\quad 4 \to 5,\quad 3 \to 4,\quad 3 \to 7,\quad 4 \to 7.
|
||||
\]
|
||||
Für das Vertex Cover ist die Orientierung der Kanten nicht relevant; für das Feedback Vertex Set schon.
|
||||
\end{grafik}
|
||||
|
||||
\subsection*{Hausaufgabe 9.1 (Nichtdeterministischer Algorithmus für VC) \hfill (5 Punkte)}
|
||||
\begin{enumerate}
|
||||
\item Finden Sie ein minimales Vertex Cover in Abbildung 1. Für ein Vertex Cover ist die Orientierung der Kanten nicht relevant.
|
||||
\item Zeigen Sie $\textsc{VertexCover} \in \mathbf{NP}$, indem Sie einen nichtdeterministischen Algorithmus angeben, der \textsc{VertexCover} in Polynomialzeit löst. Begründen Sie die Korrektheit und die Laufzeit von Ihrem Algorithmus.
|
||||
\end{enumerate}
|
||||
|
||||
\begin{loesung}\
|
||||
\begin{enumerate}
|
||||
\item Ein minimales Vertex Cover ist zum Beispiel $\{3,5,6,7,8\}$.
|
||||
\item Unser nichtdeterministischer Algorithmus geht wie folgt vor: Für jeden Knoten wird nichtdeterministisch entschieden, ob dieser im Vertex Cover sein soll. Nachdem dies für alle Knoten entschieden wurde, wird überprüft, ob nicht mehr als $k$ Knoten gewählt wurden und ob für jede Kante mindestens ein Endpunkt im Vertex Cover liegt.
|
||||
|
||||
Existiert ein Vertex Cover im Graphen, existiert auch eine Reihe von nichtdeterministischen Entscheidungen, die diese Teilmenge von Knoten auswählt. Diese Teilmenge wird dann auch von dem Algorithmus akzeptiert. Damit ist der Algorithmus korrekt.
|
||||
|
||||
Beide diese Schritte können naiv in Polynomialzeit erledigt werden, also löst dieser Algorithmus das Vertex Cover Problem in Polynomialzeit.
|
||||
\end{enumerate}
|
||||
\end{loesung}
|
||||
|
||||
\textbf{Bewertung} 1 Punkt für das Beispiel und 4 Punkte für den Algorithmus, dabei 2 Punkte für die Beschreibung und jeweils 1 Punkt für Korrektheit und Laufzeit.
|
||||
|
||||
\subsection*{Hausaufgabe 9.2 (Polynomieller Verifizierer für FVS) \hfill (5 Punkte)}
|
||||
\begin{enumerate}
|
||||
\item Finden Sie ein minimales Feedback Vertex Set in Abbildung 1.
|
||||
\item Zeigen Sie $\textsc{FeedbackVertexSet} \in \mathbf{NP}$, indem Sie einen polynomiellen Verifizierer für \textsc{FeedbackVertexSet} angeben. Begründen Sie die Korrektheit und die Laufzeit von Ihrem Verifizierer.
|
||||
\end{enumerate}
|
||||
|
||||
\begin{loesung}\
|
||||
\begin{enumerate}
|
||||
\item Ein minimales FVS ist zum Beispiel $\{5,6\}$.
|
||||
\item Das Zertifikat hat die Form einer Teilmenge $X \subseteq V$, die beschreibt, welche Knoten das Feedback Vertex Set bilden sollen. Zum Beispiel über ein Bit pro Knoten. Nun wird überprüft, ob $|X| \leq k$ gilt und ob $G \setminus X$ azyklisch ist.
|
||||
|
||||
Hat der Graph ein Feedback Vertex Set von Größe maximal $k$, gibt es ein Zertifikat, welches dieses beschreibt. Dieses Zertifikat wird dann von unserem Verifizierer akzeptiert, damit ist der Verifizierer korrekt.
|
||||
|
||||
Die Größe von $X$ zu überprüfen ist naiv in Polynomialzeit möglich. Für den zweiten Test bietet sich der Algorithmus zur topologischen Sortierung aus der Vorlesung an, welcher in Polynomialzeit eine topologische Sortierung findet, wenn der gegebene Graph azyklisch ist. Insgesamt ist dieser Verifizierer korrekt und auch ein polynomieller Verifizierer.
|
||||
\end{enumerate}
|
||||
\end{loesung}
|
||||
|
||||
\textbf{Bewertung} 1 Punkt für das Beispiel und 4 Punkte für den Verifizierer, dabei 2 Punkte für die Beschreibung und jeweils 1 Punkt für Korrektheit und Laufzeit.
|
||||
|
||||
\begin{flushleft}\small
|
||||
\textbf{Abgabe:} 16.06.2025, 10:00 in Moodle -- bitte beachten Sie die Informationen zum Abgabeformat im Moodlekurs.
|
||||
\end{flushleft}
|
||||
|
||||
\newpage
|
||||
% ===============================================================
|
||||
% ABGABE – Hausaufgabe 9 (Marek Lenczewski)
|
||||
% ===============================================================
|
||||
\abgabeheader{9}{22.\ Juni 2025}
|
||||
|
||||
\section*{Hausaufgabe 9.1}
|
||||
\subsection*{Teil 1}
|
||||
Ein minimales Vertex Cover ist $C = \{2,7,5,4,1\}$.\\
|
||||
Die minimale Knotenanzahl ist $5$.
|
||||
|
||||
\subsection*{Teil 2}
|
||||
Der Algorithmus arbeitet wie folgt:
|
||||
\begin{itemize}
|
||||
\item Zuerst wird für jeden Knoten $v \in V$ nichtdeterministisch entschieden, ob dieser in das Vertex Cover aufgenommen wird. Dabei wird drauf geachtet, dass die Anzahl $k$ nicht übersteigt.
|
||||
\item Danach wird geprüft, ob für jede Kante $\{u,v\} \in E$ entweder $v \in C$ oder $u \in C$ oder beides zutrifft.
|
||||
\item Falls dies für alle Kanten gilt, akzeptieren wir. Andernfalls lehnen wir ab.
|
||||
\end{itemize}
|
||||
|
||||
Existiert ein Vertex Cover der Größe höchstens $k$, dann gibt es auch eine, nichtdeterministisch ausgewählte, Knotenmenge, die dazu passt. Von dieser werden alle Kanten abgedeckt und der Algorithmus akzeptiert. Falls es kein Vertex Cover gibt, dann lehnt der Algorithmus ab. Die Auswahl der Knoten und die Prüfung der Kanten läuft in polynomieller Zeit, also ist dies ein polynomieller nichtdeterministischer Algorithmus, der \textsc{VertexCover} löst und damit ist $\textsc{VertexCover} \in \mathbf{NP}$.
|
||||
|
||||
\section*{Hausaufgabe 9.2}
|
||||
\subsection*{Teil 1}
|
||||
Ein minimales Feedback Vertex Set ist $X = \{1,5\}$.
|
||||
|
||||
\subsection*{Teil 2}
|
||||
Der Verifizierer arbeitet wie folgt:
|
||||
\begin{itemize}
|
||||
\item Es wird eine Teilmenge $X \subseteq V$ übergeben, die das Feedback Vertex Set darstellen soll.
|
||||
\item Dann wird geprüft, ob $|X| \leq k$ gilt und es wird abgelehnt, falls es nicht gilt.
|
||||
\item Danach wird ein Graph $G' = G \setminus X$ konstruiert, in dem alle Knoten aus $X$ und alle an $X$ angrenzenden Kanten entfernt wurden.
|
||||
\item Auf dem Graphen $G'$ wird eine Tiefensuche durchgeführt, dabei werden Knoten während der Bearbeitung grau markiert und beim Backtracking schwarz.
|
||||
\item Wird eine Kante zu einem grauen Knoten entdeckt, dann wird abgelehnt, da dies einen Kreis anzeigt.
|
||||
\item Falls die Tiefensuche den gesamten Graphen durchläuft ohne abzulehnen, dann wird akzeptiert.
|
||||
\end{itemize}
|
||||
|
||||
Existiert ein Feedback Vertex Set der Größe höchstens $k$, dann gibt es auch ein Zertifikat, das genau diese Knotenmenge beschreibt. Alle Teilmengen, die die Tiefensuche überstehen, werden von dem Verifizierer akzeptiert und sonst abgelehnt.
|
||||
|
||||
Die Prüfung der übergebenen Teilmenge und die Konstruktion des Graphen laufen in polynomieller Zeit. Ebenfalls die Tiefensuche läuft in polynomieller Zeit, somit ist auch der Verifizierer polynomiell und verifiziert die Lösung für das \textsc{FeedbackVertexSet} in polynomieller Zeit. Also gilt $\textsc{FeedbackVertexSet} \in \mathbf{NP}$.
|
||||
|
||||
\newpage
|
||||
% ===============================================================
|
||||
% BLATT 10 – Aufgabenblatt (Musterlösung)
|
||||
% ===============================================================
|
||||
\blattheader{16.06.2025}{10}
|
||||
|
||||
\begin{definition}[Feedback Vertex Set (FVS)]
|
||||
Für einen gerichteten Graphen $G = (V,E)$ ist ein Feedback Vertex Set eine Menge von Knoten $X \subseteq V$, sodass $G \setminus X$ kreisfrei ist.
|
||||
\end{definition}
|
||||
|
||||
Für das \textsc{FeedbackVertexSet} Problem ist neben einem Graphen $G$ eine Zahl $k \in \mathbb{N}_{\geq 0}$ gegeben und es wird gefragt, ob ein Feedback Vertex Set mit Größe (Anzahl der Knoten) höchstens $k$ in $G$ existiert.
|
||||
|
||||
\subsection*{Hausaufgabe 10.1 (\textsc{FeedbackVertexSet} ist \textbf{NP}-vollständig) \hfill (5 Punkte)}
|
||||
Zeigen Sie, dass \textsc{FeedbackVertexSet} \textbf{NP}-vollständig ist.
|
||||
|
||||
\textit{Hinweis:} Reduzieren Sie \textsc{VertexCover} auf \textsc{FeedbackVertexSet}. Wenn ein Vertex Cover aus einem Graphen entfernt wird, hat dieser keine Kanten mehr.
|
||||
|
||||
\begin{loesung}
|
||||
$\textsc{FeedbackVertexSet} \in \mathbf{NP}$ ist bekannt aus der letzten Hausaufgabe. Nun zeigen wir eine Reduktion von \textsc{VertexCover} auf \textsc{FeedbackVertexSet}. Betrachte die folgende \textbf{Reduktion:}
|
||||
|
||||
Für eine gegebene \textsc{VertexCover} Instanz $(G = (V,E), k)$ erzeuge den Graphen $G' = (V,E')$ mit $E' := \{(u,v),(v,u) \mid \{u,v\} \in E\}$. Gebe $(G',k)$ als \textsc{FeedbackVertexSet} Instanz aus.
|
||||
|
||||
\textbf{Korrektheit:}
|
||||
|
||||
$\Rightarrow$ (Falls $(G,k)$ eine Ja-Instanz von \textsc{VertexCover} ist, dann ist $(G',k)$ eine Ja-Instanz von \textsc{FeedbackVertexSet}.):
|
||||
|
||||
Sei $C \subseteq V$ ein Vertex Cover mit Größe kleiner oder gleich $k$. Dann enthält $G \setminus C$ keine Kanten. Damit hat $G' \setminus C$ ebenfalls keine Kanten und somit keine Kreise.
|
||||
|
||||
$\Leftarrow$ (Falls $(G',k)$ eine Ja-Instanz von \textsc{FeedbackVertexSet} ist, dann ist $(G,k)$ eine Ja-Instanz von \textsc{VertexCover}.):
|
||||
|
||||
Sei $X \subseteq V'$ ein Feedback Vertex Set mit Größe kleiner oder gleich $k$. Dann ist $X$ ein Vertex Cover in $G$, da ansonsten eine Kante $\{u,v\} \in E$ existiert, für die $u \notin X \wedge v \notin X$ gilt. Damit wäre aber $(u,v,u)$ ein Kreis in $G'$ und $X$ somit kein Feedback Vertex Set.
|
||||
|
||||
\textbf{Laufzeit:} Das Erzeugen der Menge $E'$ geht in Zeit $O(|E|)$. Insgesamt ist die Reduktion demnach in Laufzeit $O(|E|)$, also in polynomieller Laufzeit, durchführbar.
|
||||
|
||||
Also existiert eine polynomielle Reduktion von \textsc{VertexCover} auf \textsc{FeedbackVertexSet}. Da \textsc{VertexCover} nach den aktuellen Präsenzaufgaben \textbf{NP}-vollständig ist und $\textsc{FeedbackVertexSet} \in \mathbf{NP}$ gilt, ist somit \textsc{FeedbackVertexSet} \textbf{NP}-vollständig. \hfill$\square$
|
||||
\end{loesung}
|
||||
|
||||
\textbf{Bewertung} 2 Punkte für die Konstruktion, 1 Punkt für den 1. Fall, 1 Punkt für den 2. Fall, 0.5 Punkte für die Laufzeit, 0.5 Punkte für die Beweisführung im Ganzen.
|
||||
|
||||
\subsection*{Hausaufgabe 10.2 (Turingmaschinen) \hfill (5 Punkte)}
|
||||
Entwerfen Sie eine Turingmaschine für die Sprache $L = \{w \in \Sigma^* \mid w \text{ ist ein Palindrom}\}$ über einem gegebenen Alphabet $\Sigma$ und geben Sie die Laufzeit Ihrer Turingmaschine an. Begründen Sie dabei, warum Ihre Turingmaschine korrekt ist und die angegebene Laufzeit hat.
|
||||
|
||||
\begin{loesung}
|
||||
Die Turingmaschine sieht folgendermaßen aus:
|
||||
\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)] Lese den ersten Buchstaben und bewege danach den Kopf zum letzten Buchstaben. Falls die beiden Buchstaben verschieden sind, verwerfe. Ansonsten ersetze beide Buchstaben durch ein neues Symbol $x$. Ersetze dafür zuerst den letzten Buchstaben und bewege dann den Kopf zum ersten Buchstaben.
|
||||
\item[(4)] Gehe zu Schritt (1).
|
||||
\end{enumerate}
|
||||
|
||||
\textbf{Korrektheit:} Die Turingmaschine vergleicht immer den ersten und den letzten Buchstaben. Wenn die Buchstaben nicht gleich sind, ist das Wort kein Palindrom und es wird verworfen. Ansonsten werden die Buchstaben rausgestrichen (siehe Schritt (3)). Diese Prozedur wird solange wiederholt, bis man in der Mitte des Wortes angekommen ist und entweder nur noch ein Buchstabe oder kein Buchstabe vorhanden ist. In beiden Fällen ist das Wort ein Palindrom und es wird akzeptiert (siehe Schritte (1) und (2)).
|
||||
|
||||
\textbf{Laufzeit:} Die Schritte (1) bis (3) benötigen jeweils eine Laufzeit von $O(n)$, wobei $n$ hier die Länge der Eingabe bezeichnet. Da in jedem Durchlauf der Schritte (1) bis (3) zwei Buchstaben raus gestrichen werden oder das Wort akzeptiert oder verworfen wird, gibt es maximal $\lfloor n/2 \rfloor$ Durchläufe, bis nur noch ein oder kein Buchstabe auf dem Band stehen und somit in den Schritten (1) oder (2) akzeptiert wird. Damit ergibt sich insgesamt eine Laufzeit von $O(n^2)$.
|
||||
\end{loesung}
|
||||
|
||||
\textbf{Bewertung} 2 Punkte für die Turingmaschine, 1 Punkt für die Korrektheit und 2 Punkte für die Laufzeit: 1 Punkt Angabe, 1 Punkt Begründung.
|
||||
|
||||
\begin{flushleft}\small
|
||||
\textbf{Abgabe:} 23.06.2025, 10:00 in Moodle -- bitte beachten Sie die Informationen zum Abgabeformat im Moodlekurs.
|
||||
\end{flushleft}
|
||||
|
||||
\newpage
|
||||
% ===============================================================
|
||||
% ABGABE – Hausaufgabe 10 (Marek Lenczewski)
|
||||
% ===============================================================
|
||||
\abgabeheader{10}{22.\ Juni 2025}
|
||||
|
||||
\section*{Hausaufgabe 10.1}
|
||||
\subsection*{Teil 1: FeedbackVertexSet $\in$ NP}
|
||||
Zuerst brauchen wir einen polynomiellen Verifizierer, um zu zeigen, dass $\textsc{FeedbackVertexSet} \in \mathbf{NP}$.
|
||||
|
||||
Der Verifizierer bekommt einen Graphen $G$ und eine Teilmenge $X$, dieser arbeitet wie folgt:
|
||||
\begin{itemize}
|
||||
\item Prüfe, ob $|X| \leq k$, sonst ablehnen.
|
||||
\item Den Graphen $G' = G \setminus X$ konstruieren.
|
||||
\item Tiefensuche auf $G'$ durchführen, dabei werden Knoten vom aktuellen Pfad als grau markiert und nach vollständiger Bearbeitung als schwarz. Wird eine Kante zu einem grauen Knoten gefunden, zeigt dies einen Kreis an und wir lehnen ab.
|
||||
\item Akzeptieren, wenn die Tiefensuche nichts findet.
|
||||
\end{itemize}
|
||||
|
||||
Die Schritte 1--4 laufen in polynomieller Zeit, somit läuft der Verifizierer in polynomieller Zeit. Damit ist $\textsc{FeedbackVertexSet} \in \mathbf{NP}$.
|
||||
|
||||
\subsection*{Teil 2: FeedbackVertexSet ist NP-schwer}
|
||||
Jetzt brauchen wir eine Reduktion von \textsc{VertexCover} auf \textsc{FeedbackVertexSet}, um zu zeigen, dass \textsc{FeedbackVertexSet} NP-schwer ist.
|
||||
|
||||
\textbf{Konstruktion:} Sei dafür ein \textsc{VertexCover} gegeben mit einem Graphen $G$ und einer Zahl $k$. Aus $G$ wird ein $G'$, wobei jede ungerichtete Kante $\{u,v\} \in E$ durch zwei gerichtete Kanten $(u,v)$ und $(v,u)$ zu $E'$ ersetzt wird. Das $k$ wird einfach übernommen $k = k'$.
|
||||
|
||||
\textbf{Beweis VertexCover nach FeedbackVertexSet:}
|
||||
\begin{itemize}
|
||||
\item Sei $C$ ein \textsc{VertexCover} von $G$ mit $|C| \leq k$.
|
||||
\item Da $C$ ein \textsc{VertexCover} ist, wird jede Kante mit $C$ verbunden.
|
||||
\item Wenn $C$ entfernt wird, dann hat $G \setminus C$ keine Kanten mehr.
|
||||
\item Dann hat auch $G' \setminus C$ keine Kanten und ist somit kreisfrei.
|
||||
\item Damit ist $C$ ein \textsc{FeedbackVertexSet} für $G'$ mit $|C| \leq k'$.
|
||||
\end{itemize}
|
||||
|
||||
\textbf{Beweis FeedbackVertexSet nach VertexCover:}
|
||||
\begin{itemize}
|
||||
\item Sei $X$ ein \textsc{FeedbackVertexSet} von $G'$ mit $|X| \leq k'$.
|
||||
\item Dann ist $G' \setminus X$ kreisfrei.
|
||||
\item Angenommen $X$ wäre kein \textsc{VertexCover} von $G$, dann gäbe es eine Kante $\{u,v\} \in E$ mit $u,v \notin X$.
|
||||
\item Somit wären $u,v$ noch in $G' \setminus X$ vorhanden.
|
||||
\item Die Kanten $(u,v)$ und $(v,u)$ würden, durch die Konstruktion, einen Kreis erzeugen.
|
||||
\item Das ist ein Widerspruch, somit ist $G' \setminus X$ kreisfrei und $X$ ist ein \textsc{VertexCover}.
|
||||
\end{itemize}
|
||||
|
||||
Da $\textsc{FeedbackVertexSet} \in \mathbf{NP}$ und NP-schwer ist, folgt dass \textsc{FeedbackVertexSet} NP-vollständig ist. \hfill$\square$
|
||||
|
||||
\section*{Hausaufgabe 10.2}
|
||||
\begin{loesung}
|
||||
Die Turingmaschine arbeitet wie folgt:
|
||||
\begin{enumerate}
|
||||
\item Falls das Band leer ist oder nur aus Markierungen besteht, akzeptiere.
|
||||
\item Merke das erste unmarkierte Zeichen und ersetze es durch $X$.
|
||||
\item Laufe zum letzten unmarkierten Zeichen oder verwerfe.
|
||||
\item Falls dieses Zeichen nicht mit dem gemerkten übereinstimmt, verwerfe.
|
||||
\item Ersetze es durch $X$ und gehe zurück zum Anfang.
|
||||
\item Gehe zu 1.
|
||||
\end{enumerate}
|
||||
|
||||
\textbf{Korrektheit:} Ein Wort ist genau dann ein Palindrom, wenn es sich von vorne und hinten gleich liest. Dies prüft die Turingmaschine, indem sie schrittweise die äußeren Buchstaben verifiziert, bis nur noch einer oder keiner vorhanden ist, dann akzeptiert wird, und wenn eine Unstimmigkeit auftritt, dann lehnt sie ab.
|
||||
|
||||
\textbf{Laufzeit:} Die Turingmaschine hat eine Laufzeit von $O(n^2)$. In jedem Durchlauf macht sie $O(n)$ Schritte und das mit $O(n)$ Durchläufen. \hfill$\square$
|
||||
\end{loesung}
|
||||
|
||||
\newpage
|
||||
% ===============================================================
|
||||
% BLATT 11 – Aufgabenblatt (Musterlösung)
|
||||
% ===============================================================
|
||||
\blattheader{23.06.2025}{11}
|
||||
|
||||
\begin{definition}[Dreiecksüberdeckung eines Graphen ($\Delta$ COVER)]
|
||||
Gegeben ist ein endlicher ungerichteter Graph $G = (V,E)$ und eine Zahl $k \in \mathbb{N}$. Dieser Graph hat eine Dreiecksüberdeckung, wenn eine Menge von Knoten $C_\Delta \subseteq V$ mit $|C_\Delta| \leq k$ existiert, so dass zu jedem Teilgraphen (Dreieck) $D = (V_D,E_D) \subseteq (V,E)$ mit $|V_D| = 3$ und $E_D = \{\{v_1,v_2\} \in V_D \times V_D \mid v_1 \neq v_2\}$ von $G$ gilt, $v \in C_\Delta$ für mindestens ein $v \in V_D$.
|
||||
\end{definition}
|
||||
|
||||
\subsection*{Hausaufgabe 11.1 \hfill (10 Punkte)}
|
||||
\begin{enumerate}
|
||||
\item[(a)] (1 Punkt) Markieren Sie im folgenden Graphen (Abbildung 1 (a)) ein \textsc{VertexCover} der Größe 5.
|
||||
\item[(b)] (1 Punkt) Markieren Sie im folgenden Graphen (Abbildung 1 (b)) eine Dreiecksüberdeckung der Größe 5.
|
||||
\item[(c)] (8 Punkte) Zeigen Sie, dass $\Delta$ COVER \textbf{NP}-vollständig ist.
|
||||
\end{enumerate}
|
||||
|
||||
\begin{grafik}{Abbildung 1 -- Beispielgraph (Aufgabenstellung)}
|
||||
Zwei ungerichtete Graphen nebeneinander.\\[0.3em]
|
||||
\textbf{Graph (a)} (links, für das VertexCover): Ein kleinerer Graph in Form einer geschlossenen Schleife mit einem angehängten Dreieck am unteren Ende. Grob: eine sechseckartige/rautenförmige Kette von Knoten bildet oben und in der Mitte eine Ringstruktur, an deren unterem Teil ein Dreieck hängt (drei paarweise verbundene Knoten).\\[0.3em]
|
||||
\textbf{Graph (b)} (rechts, für die Dreiecksüberdeckung): Ein größerer, dichterer Graph, der aus mehreren miteinander verbundenen Dreiecken besteht. Er enthält mehrere Dreiecksstrukturen, die über gemeinsame Knoten und Kanten verknüpft sind (u.\,a.\ Dreiecke oben links und oben rechts sowie eine Kette von Dreiecken im unteren Bereich). Alle Kanten sind ungerichtet.
|
||||
\end{grafik}
|
||||
|
||||
\begin{loesung}\end{loesung}
|
||||
|
||||
\begin{grafik}{Abbildung 2 -- Beispielgraph Lösung}
|
||||
Dieselben beiden Graphen wie in Abbildung 1, jedoch mit markierten Lösungsknoten:\\[0.3em]
|
||||
\textbf{(a)} Fünf Knoten sind markiert, die zusammen ein Vertex Cover der Größe 5 bilden (jede Kante des Graphen hat mindestens einen markierten Endpunkt).\\[0.3em]
|
||||
\textbf{(b)} Fünf Knoten sind markiert, die zusammen eine Dreiecksüberdeckung der Größe 5 bilden (jedes Dreieck des Graphen enthält mindestens einen markierten Knoten).
|
||||
\end{grafik}
|
||||
|
||||
(c) Wir zeigen zunächst, $\Delta$ COVER $\in \mathbf{NP}$ mittels eines polynomiellen Verifizierers.
|
||||
|
||||
Der polynomielle Verifizierer erhält als Zertifikat eine Menge von Knoten $C_\Delta \subseteq V$. Zunächst überprüft er, ob $|C_\Delta| \leq k$. Falls dies nicht der Fall ist, verwerfe die Instanz. Ansonsten überprüfe für alle Teilgraphen $D = (V_D,E_D) \subseteq (V,E)$ mit $|V_D| = 3$ und $E_D = \{\{v_1,v_2\} \in V_D \times V_D \mid v_1 \neq v_2\}$ von $G$, ob für mindestens ein $v \in V_D$ auch $v \in C_\Delta$ gilt. Falls dies gilt, akzeptiere. Ansonsten verwerfe.
|
||||
|
||||
\textbf{Korrektheit:} Der Verifizierer überprüft die geforderten Eigenschaften. Falls ein Graph eine Dreiecksüberdeckung besitzt, so existiert ein entsprechendes Zertifikat $C_\Delta$ und der Verifizierer akzeptiert die Instanz. Falls ein Graph keine Dreiecksüberdeckung besitzt, existiert kein valides entsprechendes Zertifikat $C_\Delta$ und der Verifizierer verwirft die Instanz.
|
||||
|
||||
\textbf{Laufzeit:} Es gibt maximal $|V|^3$ verschiedene Teilmengen, die ein Dreieck bilden könnten und daher überprüft werden müssen. Die Überprüfung geht in $O(|V|)$ Zeit. Da alle anderen Schritte des Verifizierers in $O(1)$ Zeit erledigt werden können, ergibt sich somit insgesamt eine Laufzeit von $O(|V|^4)$, was einer polynomiellen Laufzeit entspricht.
|
||||
|
||||
Also gilt $\Delta$ COVER $\in \mathbf{NP}$.
|
||||
|
||||
Nun reduzieren wir \textsc{VertexCover} auf $\Delta$ COVER. Betrachte folgende Reduktion:
|
||||
|
||||
Sei $I = (G = (V,E), k)$ eine Instanz von \textsc{VertexCover}. Bilde den Graphen $G' = (V',E')$ mit $V' = V \cup \{v_e \mid e \in E\}$ und $E' = E \cup \{\{v_e,e_1\},\{v_e,e_2\} \mid e = \{e_1,e_2\} \in E\}$. Gebe $I' = (G',k)$ als $\Delta$ COVER Instanz aus.
|
||||
|
||||
\textbf{Korrektheit:}
|
||||
|
||||
$\Rightarrow$ (Falls $(G,k)$ eine Ja-Instanz von \textsc{VertexCover} ist, dann ist $(G',k)$ eine Ja-Instanz von $\Delta$ COVER.):
|
||||
|
||||
Sei $C$ ein Vertex Cover mit Größe kleiner oder gleich $k$ von $G$. Dann ist $C$ ebenfalls eine Dreiecksüberdeckung mit Größe kleiner oder gleich $k$. Offensichtlich gilt $|C| \leq k$. Da $C$ ein Vertex Cover von $G$ ist, gilt für jede Kante $\{u,v\} \in E$, dass $u \in C$ oder $v \in C$. Für alle Teilgraphen $D = (V_D,E_D) \subseteq (V,E)$ mit $|V_D| = 3$ und $E_D = \{\{v_1,v_2\} \in V_D \times V_D \mid v_1 \neq v_2\}$ von $G$ gilt damit direkt, dass mindestens ein $v \in V_D$ auch in $C$ enthalten ist. Der Graph $G'$ besitzt neben allen solchen Teilgraphen in $G$ zusätzlich solche Teilgraphen (Dreiecke), die durch die Knotenmenge $\{v_e \mid e \in E\}$ und die entsprechenden Kanten $\{e,\{v_e,e_1\},\{v_e,e_2\} \mid e = \{e_1,e_2\} \in E\}$ entstehen. Für diese Dreiecke gilt aber auch, dass mindestens ein Knoten, nämlich $e_1$ oder $e_2$, in $C$ enthalten sein muss, da $C$ ein Vertex Cover ist.
|
||||
|
||||
$\Leftarrow$ (Falls $(G',k)$ eine Ja-Instanz von $\Delta$ COVER ist, dann ist $(G,k)$ eine Ja-Instanz von \textsc{VertexCover}.):
|
||||
|
||||
Sei $C_\Delta$ eine Dreiecksüberdeckung von $G'$ der Größe $|C_\Delta| \leq k$. Ohne Beschränkung der Allgemeinheit können wir davon ausgehen, dass $C_\Delta \subseteq V$ gilt: Falls für einen Knoten $v_e \in C_\Delta$ gilt, können wir $e_1$ zu $C_\Delta$ hinzufügen und $v_e$ aus $C_\Delta$ löschen. Dadurch bleibt die Überdeckungseigenschaft erhalten und die Menge wird höchstens kleiner. Nun gilt also $C_\Delta \subseteq V$. Die Menge $C_\Delta$ ist auch ein Vertex Cover mit Größe kleiner oder gleich $k$ von $G$. Offensichtlich gilt $|C_\Delta| \leq k$. Da für alle Teilgraphen $D' = (V'_D,E'_D) \subseteq (V',E')$ mit $|V'_D| = 3$ und $E'_D = \{\{v_1,v_2\} \in V'_D \times V'_D \mid v_1 \neq v_2\}$ von $G'$ gilt, dass mindestens ein Knoten $v \in V'_D$ ebenfalls in $C_\Delta$ enthalten sein muss, gilt dies auch für die Dreiecke $\{v_e,e_1,e_2\}$. Da außerdem $C_\Delta \subseteq V$ gilt, gilt $e_1 \in C_\Delta$ oder $e_2 \in C_\Delta$ für alle Kanten $e \in E$.
|
||||
|
||||
\textbf{Laufzeit:} Das Hinzufügen von einem neuen Knoten und zwei neuen Kanten pro Kante geht in $O(|E|)$. Damit geht die gesamte Reduktion in $O(|E|)$, also in polynomieller Zeit.
|
||||
|
||||
Also existiert eine polynomielle Reduktion von \textsc{VertexCover} auf $\Delta$ COVER. Da \textsc{VertexCover} \textbf{NP}-vollständig aus den Präsenzaufgaben bekannt ist und $\Delta$ COVER $\in \mathbf{NP}$ gilt, ist somit $\Delta$ COVER \textbf{NP}-vollständig.
|
||||
|
||||
\textbf{Bewertung} (a) und (b) jeweils 1 Punkt, (c) gibt 8 Punkte: 1 Punkt Angabe Verifizierer/NDTM, 0,5 Punkte Korrektheit Verifizierer/NDTM, 0,5 Punkte Laufzeit Verifizierer/NDTM, 1 Punkt Angabe Reduktion, 3 Punkte Korrektheit (je Richtung 1,5 Punkte), 1 Punkt Laufzeit Reduktion, 1 Punkt Beweisführung.
|
||||
|
||||
\begin{flushleft}\small
|
||||
\textbf{Abgabe:} 30.06.2025, 10:00 in Moodle -- bitte beachten Sie die Informationen zum Abgabeformat im Moodlekurs.
|
||||
\end{flushleft}
|
||||
|
||||
\newpage
|
||||
% ===============================================================
|
||||
% ABGABE – Hausaufgabe 11 (Marek Lenczewski)
|
||||
% ===============================================================
|
||||
\abgabeheader{11}{28.\ Juni 2025}
|
||||
|
||||
\section*{Hausaufgabe 11.1}
|
||||
|
||||
\begin{grafik}{Handschriftliche Lösungsskizze (a), (b) und (c)}
|
||||
\textbf{Skizze (a) -- VertexCover der Größe 5:} Der Graph aus Aufgabe 1(a) mit Knoten $1$ bis $10$. Als Vertex Cover sind 5 Knoten markiert.\\[0.3em]
|
||||
\textbf{Skizze (b) -- Dreiecksüberdeckung der Größe 5:} Der Graph aus Aufgabe 1(b) mit Knoten $a$ bis $v$ (Buchstabenbeschriftung: $a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v$). Es sind 5 Knoten als Dreiecksüberdeckung markiert.\\[0.3em]
|
||||
\textbf{Skizze (c):} Verweis auf den nachfolgenden Textbeweis.
|
||||
\end{grafik}
|
||||
|
||||
\subsection*{Teil 1: $\Delta$-Cover $\in$ NP}
|
||||
Zuerst brauchen wir einen polynomiellen Verifizierer, um zu zeigen, dass $\Delta$-Cover $\in \mathbf{NP}$.
|
||||
|
||||
Der Verifizierer bekommt einen Graphen $G = (V,E)$, Zahl $k$ und ein Zertifikat $C_\Delta \subseteq V$ und arbeitet wie folgt:
|
||||
\begin{enumerate}
|
||||
\item Prüfe, ob $|C_\Delta| \leq k$.
|
||||
\item Prüfe alle Knotentripel $\{a,b,c\} \subseteq V$, ob sie ein Dreieck bilden (also ob $\{a,b\},\{b,c\}$ und $\{a,c\} \in E$ zutrifft) und ob $a$, $b$ oder $c \in C_\Delta$.
|
||||
\item Ablehnen, falls ein Dreieck den Test nicht besteht, sonst akzeptieren.
|
||||
\end{enumerate}
|
||||
|
||||
Die Schritte 1 und 3 laufen in $O(1)$ und Schritt zwei läuft in $O(|V|^3)$, das ergibt eine polynomielle Laufzeit. Damit ist $\Delta$-Cover $\in \mathbf{NP}$.
|
||||
|
||||
\subsection*{Teil 2: $\Delta$-Cover ist NP-schwer}
|
||||
Jetzt brauchen wir eine Reduktion von \textsc{VertexCover} auf $\Delta$-Cover, um zu zeigen, dass $\Delta$-Cover NP-schwer ist.
|
||||
|
||||
\textbf{Konstruktion:} Sei dafür ein \textsc{VertexCover} gegeben mit einem Graphen $G = (V,E)$ und einer Zahl $k$. Aus $G$ wird $G' = (V',E')$, wobei für jede Kante $e = \{u,v\} \in E$ ein neuer Knoten $w_e \in V'$ hinzugefügt wird und mit beiden Knoten $u,v$ verbunden wird, sodass die Kanten $\{v,w_e\}$ und $\{u,w_e\}$ zu $E'$ dazu kommen. Das $k = k'$ wird übernommen. So werden aus allen Kanten Dreiecke.
|
||||
|
||||
\textbf{Beweis VertexCover nach $\Delta$-Cover:}
|
||||
\begin{itemize}
|
||||
\item Sei $C$ ein \textsc{VertexCover} für $G$ mit $|C| \leq k$.
|
||||
\item Zu zeigen sei, dass $C$ auch ein $\Delta$-Cover für $G'$ mit $|C| \leq k$ ist.
|
||||
\item Da $C$ ein \textsc{VertexCover} ist, gilt $u \in C$ oder $v \in C$.
|
||||
\item Jedes Dreieck in $G'$ hat die Form $\{u,v,w_e\}$ für eine Kante $e = \{u,v\} \in E$.
|
||||
\item Somit hat jedes Dreieck mindestens einen Knoten in $C$.
|
||||
\item Also ist $C$ ein $\Delta$-Cover für $G'$.
|
||||
\end{itemize}
|
||||
|
||||
\textbf{Beweis $\Delta$-Cover nach VertexCover:}
|
||||
\begin{itemize}
|
||||
\item Sei $C_\Delta$ ein $\Delta$-Cover für $G'$ mit $|C_\Delta| \leq k'$.
|
||||
\item Jede Kante $e = \{u,v\} \in E$ bildet durch $\{u,v,w_e\}$ ein Dreieck in $G'$.
|
||||
\item Also gilt $u$, $v$ oder $w_e \in C_\Delta$ für alle Kanten in $G'$.
|
||||
\item Falls $w_e \in C_\Delta$, dann kann man $w_e$ durch $u$ oder $v$ tauschen ohne die Eigenschaft von $\Delta$-Cover zu verletzen, sodass $u$ oder $v \in C_\Delta$ für alle Kanten in $G'$ gilt.
|
||||
\item Da sich die Knoten aus $C_\Delta$ nur vertauschen gilt weiter $|C| = |C_\Delta| \leq k$.
|
||||
\item Weiter sind in $C_\Delta$ nur noch die Knoten aus $V$, somit gilt $u \in C$ oder $v \in C$ für alle Kanten $E$.
|
||||
\item Also ist $C$ ein \textsc{VertexCover} für $G$.
|
||||
\end{itemize}
|
||||
|
||||
Da $\Delta$-Cover $\in \mathbf{NP}$ und NP-schwer ist, folgt dass $\Delta$-Cover NP-vollständig ist. \hfill$\square$
|
||||
|
||||
\newpage
|
||||
% ===============================================================
|
||||
% BLATT 12 – Aufgabenblatt (Musterlösung)
|
||||
% ===============================================================
|
||||
\blattheader{30.06.2025}{12}
|
||||
|
||||
\subsection*{Hausaufgabe 12.1 (Lower Bound: \textsc{VertexCover}) \hfill (5 Punkte)}
|
||||
Betrachten Sie die Reduktion aus der Musterlösung zu Präsenzserie 10 von \textsc{Clique} auf \textsc{VertexCover}.
|
||||
\begin{enumerate}
|
||||
\item Geben Sie die Anzahl der Knoten, die Anzahl der Kanten und den Wert $k$ für die resultierende \textsc{VertexCover} Instanz in Abhängigkeit von der originalen \textsc{Clique} Instanz an.
|
||||
\item Zeigen Sie Lower Bounds für \textsc{VertexCover} bezüglich Anzahl der Knoten, Anzahl der Kanten und $k$ basierend auf der ETH und der Reduktion aus der Musterlösung zu Präsenzserie 10.
|
||||
\end{enumerate}
|
||||
|
||||
\begin{loesung}\
|
||||
\begin{enumerate}
|
||||
\item Sei $I = (G = (V,E), k)$ eine Instanz von \textsc{Clique} und $I' = (G' = (V',E'), k')$ die aus der Reduktion resultierende Instanz von \textsc{VertexCover}. Es gilt $|V'| = |V|$, $|E'| = \frac{1}{2}|V|(|V|-1) - |E| \leq |V|^2$ und $k' = |V| - k \leq |V|$.
|
||||
\item \begin{itemize}
|
||||
\item Angenommen es gäbe einen Algorithmus, der \textsc{VertexCover} in $2^{o(|V'|)} \cdot |I|^{O(1)}$ löst. Durch die Kombination der Reduktion von \textsc{Clique} auf \textsc{VertexCover} und diesem Algorithmus, existiert dann auch ein $2^{o(|V|)} \cdot |I|^{O(1)}$ Algorithmus für \textsc{Clique}, da $|V'| = |V|$ nach Aufgabenteil 1. Aus der Musterlösung der Präsenzserie 12 folgt somit, dass die ETH falsch ist.
|
||||
|
||||
Damit kann es so einen Algorithmus für \textsc{VertexCover} nur geben, wenn die ETH falsch ist.
|
||||
|
||||
\item Angenommen es gäbe einen Algorithmus, der \textsc{VertexCover} in $2^{o(\sqrt{|E'|})} \cdot |I|^{O(1)}$ löst. Durch die Kombination der Reduktion von \textsc{Clique} auf \textsc{VertexCover} und diesem Algorithmus, existiert dann auch ein $2^{o(|V|)} \cdot |I|^{O(1)}$ Algorithmus für \textsc{Clique}, da $|E'| \leq |V|^2$ nach Aufgabenteil 1. Aus der Musterlösung der Präsenzserie 12 folgt somit, dass die ETH falsch ist.
|
||||
|
||||
Damit kann es so einen Algorithmus für \textsc{VertexCover} nur geben, wenn die ETH falsch ist.
|
||||
|
||||
\item Angenommen es gäbe einen Algorithmus, der \textsc{VertexCover} in $2^{o(k')} \cdot |I|^{O(1)}$ löst. Durch die Kombination der Reduktion von \textsc{Clique} auf \textsc{VertexCover} und diesem Algorithmus, existiert dann auch ein $2^{o(|V|)} \cdot |I|^{O(1)}$ Algorithmus für \textsc{Clique}, da $k' \leq |V|$ nach Aufgabenteil 1. Aus der Musterlösung der Präsenzserie 12 folgt somit, dass die ETH falsch ist.
|
||||
|
||||
Damit kann es so einen Algorithmus für \textsc{VertexCover} nur geben, wenn die ETH falsch ist. \hfill$\square$
|
||||
\end{itemize}
|
||||
\end{enumerate}
|
||||
\end{loesung}
|
||||
|
||||
\textbf{Bewertung} 1 Punkt für den ersten Teil und $1.5 + 1.5 + 1$ für den zweiten.
|
||||
|
||||
\begin{definition}[\textsc{HittingSet}]
|
||||
Bei diesem Problem ist ein Universum $U$, Teilmengen des Universums $F_1,\ldots,F_r \subseteq U$ und eine Zahl $k \in \mathbb{N}_{\geq 0}$ gegeben. Gibt es eine Menge $S \subseteq U$ mit $|U| \leq k$ und $S \cap F_i \neq \emptyset$ für alle $i \in [r]$?
|
||||
\end{definition}
|
||||
|
||||
Anschaulicher wird bei diesem Problem nach maximal $k$ Elementen aus dem Universum gefragt, sodass diese Elemente alle gegebenen Mengen $F_i$ „treffen``.
|
||||
|
||||
\subsection*{Hausaufgabe 12.2 (Lower Bound: \textsc{HittingSet}) \hfill (5 Punkte)}
|
||||
Betrachten Sie folgende Reduktion von 3-SAT auf \textsc{HittingSet}.
|
||||
|
||||
Für eine gegebene 3-SAT Instanz $I$ mit $n$ Variablen $x_1,\ldots,x_n$ und $m$ Klauseln $C_1,\ldots,C_m$: Als Universum wählen wir $U = \{x_1,\bar{x}_1,\ldots,x_n,\bar{x}_n\}$. Für jede Variable $x_i$ fügen wir die Menge $F_i := \{x_i,\bar{x}_i\}$ hinzu. Für jede Klausel $C_j$ fügen wir die Menge $F_{n+j} := C_j$ hinzu. Wir setzen $k := n$ und erhalten damit eine \textsc{HittingSet} Instanz $I$.
|
||||
\begin{enumerate}
|
||||
\item Geben Sie die Größe des Universums, die Anzahl der Mengen und die Zahl $k$ aus der resultierenden \textsc{HittingSet} Instanz in Abhängigkeit von der Anzahl der Variablen $n$ und der Anzahl der Klauseln $m$ aus der originalen 3-SAT Instanz an.
|
||||
\item Beweisen Sie Lower Bounds für \textsc{HittingSet} bezüglich Universumsgröße, Anzahl der Mengen und der Zahl $k$ basierend auf der obigen Reduktion und der ETH.
|
||||
\end{enumerate}
|
||||
|
||||
\begin{loesung}\
|
||||
\begin{enumerate}
|
||||
\item Für die Universumsgröße gilt $|U| = 2n$, für die Anzahl der Mengen gilt $r = n+m$ und es gilt $k = n$.
|
||||
\item \begin{itemize}
|
||||
\item Angenommen es gäbe einen Algorithmus, der \textsc{HittingSet} in $2^{o(|U|)} \cdot |I|^{O(1)}$ löst. Durch die Kombination der Reduktion von 3-SAT auf \textsc{HittingSet} und diesem Algorithmus, existiert dann auch ein $2^{o(n)} \cdot |I|^{O(1)}$ Algorithmus für 3-SAT, da $|U| = 2n$ nach Aufgabenteil 1. Damit ist die ETH falsch.
|
||||
|
||||
Damit kann es so einen Algorithmus für \textsc{HittingSet} nur geben, wenn die ETH falsch ist.
|
||||
|
||||
\item Angenommen es gäbe einen Algorithmus, der \textsc{HittingSet} in $2^{o(r)} \cdot |I|^{O(1)}$ löst. Durch die Kombination der Reduktion von 3-SAT auf \textsc{HittingSet} und diesem Algorithmus, existiert dann auch ein $2^{o(m)} \cdot |I|^{O(1)}$ Algorithmus für 3-SAT, da $r = n+m$ nach Aufgabenteil 1 und $n \leq 3m$ für 3-SAT gilt. Aus dem Sparsification Lemma folgt damit, dass die ETH falsch ist.
|
||||
|
||||
Damit kann es so einen Algorithmus für \textsc{HittingSet} nur geben, wenn die ETH falsch ist.
|
||||
|
||||
\item Angenommen es gäbe einen Algorithmus, der \textsc{HittingSet} in $2^{o(k)} \cdot |I|^{O(1)}$ löst. Durch die Kombination der Reduktion von 3-SAT auf \textsc{HittingSet} und diesem Algorithmus, existiert dann auch ein $2^{o(n)} \cdot |I|^{O(1)}$ Algorithmus für 3-SAT, da $k = n$ nach Aufgabenteil 1. Damit ist die ETH falsch.
|
||||
|
||||
Damit kann es so einen Algorithmus für \textsc{HittingSet} nur geben, wenn die ETH falsch ist.
|
||||
\end{itemize}
|
||||
\end{enumerate}
|
||||
\end{loesung}
|
||||
|
||||
\textbf{Bewertung} 1 Punkt für den ersten Teil und $1.5 + 1.5 + 1$ für den zweiten.
|
||||
|
||||
\begin{flushleft}\small
|
||||
\textbf{Abgabe:} 07.07.2025, 10:00 in Moodle -- bitte beachten Sie die Informationen zum Abgabeformat im Moodlekurs.
|
||||
\end{flushleft}
|
||||
|
||||
\newpage
|
||||
% ===============================================================
|
||||
% ABGABE – Hausaufgabe 12 (Marek Lenczewski)
|
||||
% ===============================================================
|
||||
\abgabeheader{12}{6.\ Juli 2025}
|
||||
|
||||
\section*{Hausaufgabe 12.1.1}
|
||||
Die Knotenzahl bleibt gleich: $|V'| = |V| = n$.\\
|
||||
Die Kantenzahl entspricht den nicht vorhandenen Kanten: $|E'| = |E|$.\\
|
||||
$k'$ entspricht allen Knoten, die vorher nicht in der Clique waren: $k' = n - k$.
|
||||
|
||||
\section*{Hausaufgabe 12.1.2}
|
||||
Wir wissen, dass 3-SAT laut ETH mindestens $2^{\Omega(n)}$ braucht, wobei $n$ für die Anzahl der Variablen steht.
|
||||
|
||||
In der Vorlesung wurde eine Reduktion von 3-SAT auf Clique gezeigt. In der Präsenzaufgabe 10.2 wurde eine Reduktion von Clique auf VertexCover gezeigt. Also gibt es eine Reduktion von 3-SAT zu VertexCover. Somit kann VertexCover nicht schneller lösbar sein als 3-SAT, weil sonst 3-SAT schneller werden würde, was nach ETH nicht geht.
|
||||
|
||||
So ergeben sich die folgenden Lower Bounds:
|
||||
\begin{itemize}
|
||||
\item Bezüglich Anzahl der Knoten: $2^{\Omega(n)}$, wobei $n = |V'|$. Die Knotenzahl verändert sich nicht bei den Reduktionen.
|
||||
\item Bezüglich Anzahl der Kanten: $2^{\Omega(\sqrt{m})}$, wobei $m = |E'|$. Die Kanten können bei den Reduktionen zu einem quadratischen Wachstum der Kanten führen.
|
||||
\item Bezüglich $k'$: $2^{\Omega(k')}$. Bei der Reduktion gilt $k' = n - k$, wobei $k'$ linear von $n$ abhängt.
|
||||
\end{itemize}
|
||||
|
||||
\section*{Hausaufgabe 12.2.1}
|
||||
\begin{itemize}
|
||||
\item Größe des Universums: $|U| = 2n$. Für jede der $n$ Variablen gibt es zwei Elemente ($x_i$ und $\bar{x}_i$).
|
||||
\item Anzahl der Mengen: $n+m$. $n$ sind die Variablenmengen und $m$ die Klauselmengen ($F_i$ und $F_{n+j}$).
|
||||
\item Parameter: $k = n$. Wird in der Reduktion so übernommen.
|
||||
\end{itemize}
|
||||
|
||||
\section*{Hausaufgabe 12.2.2}
|
||||
Wir wissen, dass 3-SAT laut ETH mindestens $2^{\Omega(n)}$ braucht, wobei $n$ für die Anzahl der Variablen steht. Somit kann HittingSet nicht schneller sein.
|
||||
|
||||
Es ergeben sich die folgenden Lower Bounds für HittingSet:
|
||||
\begin{itemize}
|
||||
\item Bezüglich Größe des Universums: $2^{\Omega(|U|/2)}$, da für jede Variable zwei Elemente ins Universum aufgenommen werden.
|
||||
\item Bezüglich Anzahl der Mengen: $2^{\Omega(n)}$, wobei die Anzahl der Variablen- und Klauselmengen $(m+n)$ mindestens $n$ ist.
|
||||
\item Bezüglich Zahl $k$: $2^{\Omega(k)}$, da in der Reduktion $k = n$ gilt.
|
||||
\end{itemize}
|
||||
|
||||
\newpage
|
||||
% ===============================================================
|
||||
% BLATT 13 – Aufgabenblatt (Musterlösung)
|
||||
% ===============================================================
|
||||
\blattheader{07.07.2025}{13}
|
||||
|
||||
\begin{definition}[MAX-3-SAT]
|
||||
Bei dem Problem MAX-3-SAT ist eine Formel $\phi$ in konjunktiver Normalform gegeben, wobei jede Klausel 3 Literale enthält. Gesucht ist eine Belegung $\beta$ der Variablen, die die Anzahl $v(\beta)$ der erfüllten Klauseln maximiert.
|
||||
\end{definition}
|
||||
|
||||
\subsection*{Hausaufgabe 13.1 (MAX-3-SAT) \hfill (10 Punkte)}
|
||||
Betrachten Sie folgenden Algorithmus $A$:
|
||||
\begin{itemize}
|
||||
\item Sei $\beta_0$ die Belegung, die alle Variablen auf \texttt{false} setzt.
|
||||
\item Sei $\beta_1$ die Belegung, die alle Variablen auf \texttt{true} setzt.
|
||||
\item Falls $v(\beta_0) \geq v(\beta_1)$, gib $\beta_0$ zurück.
|
||||
\item Sonst gib $\beta_1$ zurück.
|
||||
\end{itemize}
|
||||
\begin{enumerate}
|
||||
\item[(a)] (6 Punkte) Zeigen Sie, dass obiger Algorithmus Güte 2 hat, d.h.\ $v(A(\phi)) \geq \frac{1}{2}v(OPT(\phi))$ gilt für alle Eingaben $\phi$.
|
||||
\item[(b)] (4 Punkte) Geben Sie eine Formel an, bei der der Algorithmus eine Belegung ausgibt, die genau die Hälfte der maximal erfüllbaren Klauseln erfüllt. Begründen Sie kurz, warum Ihre Formel geeignet ist.
|
||||
|
||||
\textit{Hinweis:} Sie brauchen nur höchstens zwei Klauseln und vier Variablen.
|
||||
\end{enumerate}
|
||||
|
||||
\begin{loesung}\
|
||||
\begin{enumerate}
|
||||
\item[(a)] Für jede Klausel $C$ gilt, dass sie von mindestens einer der Belegungen $\beta_0$ und $\beta_1$ erfüllt wird. Wir zeigen nun per Widerspruch, dass der obige Algorithmus eine Güte von 2 hat:
|
||||
|
||||
Angenommen, es gilt $v(A(\phi)) < \frac{1}{2}v(OPT(\phi))$ für eine Formel $\phi$. Sei $m$ die Anzahl an Klauseln in $\phi$. Dann gilt $v(OPT(\phi)) \leq m$. Da $v(A(\phi)) < \frac{1}{2}v(OPT(\phi)) \leq \frac{1}{2}m$, gilt $v(\beta_0) < \frac{1}{2}m$ und $v(\beta_1) < \frac{1}{2}m$. Da jede Klausel $C$ allerdings von mindestens einer der Belegungen $\beta_0$ und $\beta_1$ erfüllt wird, gilt $v(\beta_0) \geq \frac{1}{2}m$ oder $v(\beta_1) \geq \frac{1}{2}m$. Dies ist ein Widerspruch.
|
||||
|
||||
Also gilt $v(A(\phi)) \geq \frac{1}{2}v(OPT(\phi))$ für alle Eingaben $\phi$ und obiger Algorithmus hat Güte 2.
|
||||
|
||||
\item[(b)] Betrachte folgende Formel: $\phi = (x_1 \vee x_2 \vee x_3) \wedge (\neg x_0 \vee \neg x_2 \vee \neg x_3)$. Mit $\beta = \{x_0 \to \texttt{false}, x_1 \to \texttt{true}, x_2 \to \texttt{true}, x_3 \to \texttt{true}\}$ gilt $v(\beta) = 2$. Da $\phi$ nur zwei Klauseln hat, gilt somit $v(OPT(\phi)) = 2$. Es gilt allerdings $v(\beta_0) = 1$, da hier nur die zweite Klausel erfüllt ist, und $v(\beta_1) = 1$, da hier nur die erste Klausel erfüllt ist. Somit gilt $v(A(\phi)) = 1 = \frac{1}{2} \cdot 2 = \frac{1}{2}v(OPT(\phi))$.
|
||||
\end{enumerate}
|
||||
\end{loesung}
|
||||
|
||||
\textbf{Bewertung} (a) 2 Punkte korrekte Beweisführung im Allgemeinen, 2 Punkte Abschätzung Algorithmus, 2 Punkte Abschätzung Optimum; (b) 2 Punkte für Angabe einer korrekten Formel, 1 Punkt Ausgabe Algorithmus, 1 Punkt Optimum.
|
||||
|
||||
\begin{flushleft}\small
|
||||
\textbf{Abgabe:} 14.07.2025, 10:00 in Moodle -- bitte beachten Sie die Informationen zum Abgabeformat im Moodlekurs.
|
||||
\end{flushleft}
|
||||
|
||||
\newpage
|
||||
% ===============================================================
|
||||
% ABGABE – Hausaufgabe 13 (Marek Lenczewski)
|
||||
% ===============================================================
|
||||
\abgabeheader{13}{13.\ Juli 2025}
|
||||
|
||||
\section*{Hausaufgabe 13.1.a}
|
||||
Zu zeigen ist, dass der Algorithmus die Güte 2 hat, also die Lösung vom Algorithmus mindestens halb so gut ist wie die optimale Lösung. Also $\nu(A(\phi)) \geq \frac{1}{2}\nu(OPT(\phi))$ für alle Eingaben $\phi$.
|
||||
|
||||
Sei $\phi$ eine beliebige 3-SAT-Formel mit $m$ Klauseln $C_1,C_2,\ldots,C_m$, wobei jede Klausel genau 3 Literale enthält.
|
||||
|
||||
Jede Klausel $C_i$ ist wahr, wenn $\beta_0$ wahr ist oder wenn $\beta_1$ wahr ist oder beides. Da die Variablen in $C_i$ nur positiv oder negativ sein können, muss dabei mindestens $\beta_0$ oder $\beta_1$ wahr werden.
|
||||
|
||||
Der Algorithmus wählt die Belegung $\beta_0$ oder $\beta_1$ aus, die die meisten Klauseln $C_i$ erfüllt.
|
||||
|
||||
Somit ist die Anzahl der ausgewählten Klauseln $C_i$ mindestens $\frac{m}{2}$, da bei jeder Klausel mindestens eine Belegung wahr werden muss und somit hat mindestens eine Belegung mindestens $\frac{m}{2}$ wahre Klauseln.
|
||||
|
||||
Sei $\nu_0 = $ Anzahl der von $\beta_0$ erfüllten Klauseln und $\nu_1 = $ Anzahl der von $\beta_1$ erfüllten Klauseln.
|
||||
|
||||
So ergibt sich $\nu(A(\phi)) = \max\{\nu_0,\nu_1\} \geq \frac{\nu_0 + \nu_1}{2} \geq \frac{m}{2}$.
|
||||
|
||||
Da die optimale Lösung höchstens alle $m$ Klauseln erfüllen kann, gilt $\nu(OPT(\phi)) \leq m$.
|
||||
|
||||
Daraus folgt: $\nu(A(\phi)) \geq \frac{m}{2} \geq \frac{\nu(OPT(\phi))}{2}$.
|
||||
|
||||
Somit hat der Algorithmus eine Güte von 2.
|
||||
|
||||
\section*{Hausaufgabe 13.1.b}
|
||||
Der Algorithmus erfüllt genau die Hälfte der maximal erfüllbaren Klauseln, wenn jede Klausel nur aus positiven oder negativen Variablen besteht und sich diese genau gleich aufteilen.
|
||||
|
||||
\textbf{Formel:} $\phi = (x_1 \vee x_2 \vee x_3) \wedge (\neg x_1 \vee \neg x_2 \vee \neg x_3)$
|
||||
|
||||
Unter $\beta_0$ (alle \texttt{false}):
|
||||
\begin{itemize}
|
||||
\item $C_1 = (x_1 \vee x_2 \vee x_3) = (\texttt{false} \vee \texttt{false} \vee \texttt{false}) = \texttt{false}$
|
||||
\item $C_2 = (\neg x_1 \vee \neg x_2 \vee \neg x_3) = (\texttt{true} \vee \texttt{true} \vee \texttt{true}) = \texttt{true}$
|
||||
\item $\nu(\beta_0) = 1$
|
||||
\end{itemize}
|
||||
|
||||
Unter $\beta_1$ (alle \texttt{true}):
|
||||
\begin{itemize}
|
||||
\item $C_1 = (x_1 \vee x_2 \vee x_3) = (\texttt{true} \vee \texttt{true} \vee \texttt{true}) = \texttt{true}$
|
||||
\item $C_2 = (\neg x_1 \vee \neg x_2 \vee \neg x_3) = (\texttt{false} \vee \texttt{false} \vee \texttt{false}) = \texttt{false}$
|
||||
\item $\nu(\beta_1) = 1$
|
||||
\end{itemize}
|
||||
|
||||
Der Algorithmus wählt $\nu(A(\phi)) = \max\{\nu(\beta_0),\nu(\beta_1)\} = \max\{1,1\} = 1$.
|
||||
|
||||
Eine optimale Lösung wäre zum Beispiel $x_1 = \texttt{true}, x_2 = \texttt{false}, x_3 = \texttt{false}$.
|
||||
\begin{itemize}
|
||||
\item $C_1 = (\texttt{true} \vee \texttt{false} \vee \texttt{false}) = \texttt{true}$
|
||||
\item $C_2 = (\texttt{false} \vee \texttt{true} \vee \texttt{true}) = \texttt{true}$
|
||||
\end{itemize}
|
||||
|
||||
Daraus ergibt sich $\nu(OPT(\phi)) = 2$, also $\nu(A(\phi)) = \frac{\nu(OPT(\phi))}{2}$. Somit hat es die Güte 2.
|
||||
|
||||
\end{document}
|
||||
Reference in New Issue
Block a user