Hilfsmakros
This commit is contained in:
Marco Ammon
parent
787ccff53f
commit
1abcc1f9e2
Binary file not shown.
@ -26,18 +26,67 @@
|
||||
%\usepackage{datetime}
|
||||
%\usepackage{xcolor}
|
||||
|
||||
\DeclareMathOperator{\opt}{OPT}
|
||||
% Formatierung
|
||||
\newcommand*{\algo}[1]{\textsc{#1}}
|
||||
\newcommand*{\problem}[1]{\textsc{#1}}
|
||||
|
||||
% TODO: Set
|
||||
|
||||
\DeclarePairedDelimiter\abs{\lvert}{\rvert}
|
||||
\DeclarePairedDelimiter\encoded{\langle}{\rangle}
|
||||
|
||||
\newcommand{\cupdot}{\mathbin{\mathaccent\cdot\cup}}
|
||||
|
||||
% Notation
|
||||
\newcommand{\bigO}{\mathcal{O}}
|
||||
\newcommand{\naturals}{\mathbb{N}}
|
||||
\DeclareMathOperator{\maxnr}{maxnr}
|
||||
\DeclareMathOperator{\poly}{poly}
|
||||
% Modifier
|
||||
\newcommand{\rel}{\mathrm{rel}}
|
||||
\newcommand{\red}{\mathrm{red}}
|
||||
|
||||
% Optimierungsproblem
|
||||
\newcommand{\domain}{\mathcal{D}}
|
||||
\newcommand{\solution}{\mathcal{S}}
|
||||
\newcommand{\ziel}{\mathrm{ziel}}
|
||||
\DeclareMathOperator{\opt}{OPT}
|
||||
|
||||
% Graphen
|
||||
\newcommand{\greedycol}{\algo{GreedyCol}}
|
||||
\newcommand{\greedycoltwo}{\algo{GreedyCol2}}
|
||||
\newcommand{\vertices}{\mathrm{V}}
|
||||
\newcommand{\edges}{\mathrm{E}}
|
||||
|
||||
% Rucksackproblem
|
||||
\newcommand{\rucksack}{\problem{Rucksack}}
|
||||
\newcommand{\vol}{\mathrm{vol}}
|
||||
\newcommand{\dynrucksack}{\algo{DynRucksack}}
|
||||
\newcommand{\fpasrucksack}{\algo{FPASRucksack}}
|
||||
|
||||
% Max-SAT
|
||||
\newcommand{\maxsat}{\problem{Max-SAT}}
|
||||
\DeclareMathOperator{\wahr}{wahr}
|
||||
\newcommand{\true}{\textsc{True}}
|
||||
\newcommand{\false}{\textsc{False}}
|
||||
|
||||
% Independet Set
|
||||
\newcommand{\is}{\problem{IS}}
|
||||
\newcommand{\greedyis}{\algo{GreedyIS}}
|
||||
|
||||
% TSP
|
||||
\newcommand{\tsp}{\problem{TSP}}
|
||||
\newcommand{\deltatsp}{\Delta\tsp}
|
||||
\newcommand{\ch}{\mathrm{CH}}
|
||||
|
||||
% Hamilton
|
||||
\newcommand{\hamilton}{\problem{Hamilton}}
|
||||
|
||||
% Beweisumgebungen
|
||||
\newtheorem*{satz}{Satz}
|
||||
\newtheorem*{lemma}{Lemma}
|
||||
\newtheorem*{zeuge}{Zeuge}
|
||||
|
||||
\newcommand*{\algo}[1]{\textsc{#1}}
|
||||
\newcommand*{\problem}[1]{\textsc{#1}}
|
||||
|
||||
\setlist[enumerate,1]{label={\arabic*.}}
|
||||
\setlist[enumerate,2]{label={\alph*)}}
|
||||
|
||||
@ -57,75 +106,75 @@
|
||||
\section{Allgemeine Definitionen}
|
||||
\subsection{Kombinatorisches Optimierungsproblem $\Pi$}
|
||||
\begin{align*}
|
||||
\mathcal{D} &= \text{Menge der Eingaben $I$}\\
|
||||
\mathcal{S}(I \in \mathcal{D}) &= \text{Menge der zur Eingabe $I$ zulässigen Lösungen}\\
|
||||
f: \mathcal{S}(I) \mapsto \mathbb{N}^{\neq 0} &= \text{Bewertungs-/Kosten-/Maßfunction}\\
|
||||
\mathrm{ziel} \in \{\min, \max\}
|
||||
\domain &= \text{Menge der Eingaben $I$}\\
|
||||
\solution(I \in \domain) &= \text{Menge der zur Eingabe $I$ zulässigen Lösungen}\\
|
||||
f: \solution(I) \mapsto \naturals^{\neq 0} &= \text{Bewertungs-/Kosten-/Maßfunktion}\\
|
||||
\ziel \in \{\min, \max\}
|
||||
\end{align*}
|
||||
\begin{enumerate}
|
||||
\begin{itemize}
|
||||
\item Beschränkung auf natürliche Zahlen, weil Vergleich reeller Zahlen bislang nicht beweisbar schnell funktioniert.
|
||||
\item Ausschluss der 0 für spätere Definitionen sinnvoll (lässt sich durch Modifikation von $f$ in der Regel trivial erreichen)
|
||||
\end{enumerate}
|
||||
\end{itemize}
|
||||
|
||||
Gesucht ist zu $I \in \mathcal{D}$ eine zulässige Lösung $\sigma_\mathrm{opt} \in \mathcal{S}(I)$, sodass
|
||||
Gesucht ist zu $I \in \domain$ eine zulässige Lösung $\sigma_\mathrm{opt} \in \solution(I)$, sodass
|
||||
\begin{equation*}
|
||||
\opt(I) = f(\sigma_\mathrm{opt}) = \mathrm{ziel}\{f(\sigma) \mid \sigma \in \mathcal{S}(I) \}
|
||||
\opt(I) = f(\sigma_\mathrm{opt}) = \ziel\{f(\sigma) \mid \sigma \in \solution(I) \}
|
||||
\end{equation*}
|
||||
|
||||
\subsubsection{Das Rucksackproblem \problem{Rucksack}}
|
||||
\subsubsection{Das Rucksackproblem \rucksack}
|
||||
\begin{align*}
|
||||
\mathcal{D} &= \{\langle W, \mathrm{vol}, p, B\rangle \mid \{1, \dots, n\}, \mathrm{vol}: W \mapsto \mathbb{N}, p: W\mapsto \mathbb{N}, B \in \mathbb{N}, \forall w \in W: vol(w) \le B\}\\
|
||||
\mathcal{S}(\langle W, \mathrm{vol}, p, B\rangle) &= \{ A \subseteq W \mid \sum_{w\in A}\mathrm{vol}(w) \le B\}\\
|
||||
\domain &= \{\encoded{ W, \vol, p, B} \mid \{1, \dots, n\}, \vol: W \mapsto \naturals, p: W\mapsto \naturals, B \in \naturals, \forall w \in W: vol(w) \le B\}\\
|
||||
\solution(\encoded{ W, \vol, p, B}) &= \{ A \subseteq W \mid \sum_{w\in A}\vol(w) \le B\}\\
|
||||
f(A) &= \sum_{w\in A} p_w\\
|
||||
\mathrm{ziel} &= \max
|
||||
\ziel &= \max
|
||||
\end{align*}
|
||||
Die Restriktion der verfügbaren Waren auf solche, die in den leeren Rucksack passen, hilft gegen das künstliche Aufblähen der Eingabe.
|
||||
|
||||
\subsubsection{Das Knotenfärbungsproblem \problem{Col}}
|
||||
\begin{align*}
|
||||
\mathcal{D} &= \{\langle G\rangle \mid G = (V, E)\,\text{ein ungerichteter Graph mit mindestens einer Kante}\}\\
|
||||
\mathcal{S}(\langle G \rangle) &= \{ c_\mathrm{V} \mid c_\mathrm{V}\, \text{ist eine Knotenfärbung von}\, G\}\\
|
||||
f(c_\mathrm{V}) &= \abs{c_\mathrm{V}(V)}\\
|
||||
\mathrm{ziel} &= \min
|
||||
\domain &= \{\encoded{ G} \mid G = (V, E)\,\text{ein ungerichteter Graph mit mindestens einer Kante}\}\\
|
||||
\solution(\encoded{ G }) &= \{ c_\vertices \mid c_\vertices\, \text{ist eine Knotenfärbung von}\, G\}\\
|
||||
f(c_\vertices) &= \abs{c_\vertices(V)}\\
|
||||
\ziel &= \min
|
||||
\end{align*}
|
||||
|
||||
Die Größe der kleinsten möglichen Knotenfärbung ist die chromatische Zahl $\chi(G)$.
|
||||
|
||||
\subsubsection{Das Kantenfärbungsproblem \problem{EdgeCol}}
|
||||
\begin{align*}
|
||||
\mathcal{D} &= \{\langle G\rangle \mid G = (V, E)\,\text{ein ungerichteter Graph mit mindestens einer Kante}\}\\
|
||||
\mathcal{S}(\langle G \rangle) &= \{ c_\mathrm{E} \mid c_\mathrm{E}\, \text{ist eine Kantenfärbung von}\, G\}\\
|
||||
f(c_\mathrm{E}) &= \abs{c_\mathrm{E}(E)}\\
|
||||
\mathrm{ziel} &= \min
|
||||
\domain &= \{\encoded{ G} \mid G = (V, E)\,\text{ein ungerichteter Graph mit mindestens einer Kante}\}\\
|
||||
\solution(\encoded{ G }) &= \{ c_\edges \mid c_\edges\, \text{ist eine Kantenfärbung von}\, G\}\\
|
||||
f(c_\edges) &= \abs{c_\edges(E)}\\
|
||||
\ziel &= \min
|
||||
\end{align*}
|
||||
Die Größe der kleinsten möglichen Kantenfärbung ist der chromatische Index $\chi'(G)$.
|
||||
|
||||
\subsubsection{Das Traveling-Salesperson-Problem \problem{TSP}}
|
||||
\subsubsection{Das Traveling-Salesperson-Problem \tsp}
|
||||
\begin{align*}
|
||||
\mathcal{D} &= \{\langle K_n, c\rangle \mid K_n\, \text{vollständiger Graph auf $n$ Knoten}, c: E \mapsto \mathbb{N},\}\\
|
||||
\mathcal{S}(\langle K_n, c \rangle) &= \{ C \mid C = (v_{i_1}, v_{i_2}, \dots, v_{i_n}, v_{i_i})\,\text{ist ein Hamiltonkreis}\}\\
|
||||
f(c_\mathrm{E}) &= c(v_{i_n}, v_{i_1}) + \sum_{j=1}^{n-1} c(v_{i_j}, v_{i_{j+1}})\\
|
||||
\mathrm{ziel} &= \min
|
||||
\domain &= \{\encoded{ K_n, c} \mid K_n\, \text{vollständiger Graph auf $n$ Knoten}, c: E \mapsto \naturals,\}\\
|
||||
\solution(\encoded{ K_n, c }) &= \{ C \mid C = (v_{i_1}, v_{i_2}, \dots, v_{i_n}, v_{i_i})\,\text{ist ein Hamiltonkreis}\}\\
|
||||
f(c_\edges) &= c(v_{i_n}, v_{i_1}) + \sum_{j=1}^{n-1} c(v_{i_j}, v_{i_{j+1}})\\
|
||||
\ziel &= \min
|
||||
\end{align*}
|
||||
|
||||
\subsubsection{Das metrische Traveling-Salesperson-Problem $\Delta\problem{TSP}$}
|
||||
\subsubsection{Das metrische Traveling-Salesperson-Problem $\deltatsp$}
|
||||
\begin{align*}
|
||||
\mathcal{D} &= \{\langle K_n, c\rangle \mid K_n\, \text{vollständiger Graph auf $n$ Knoten}, c: E \mapsto \mathbb{N},\\
|
||||
\domain &= \{\encoded{ K_n, c} \mid K_n\, \text{vollständiger Graph auf $n$ Knoten}, c: E \mapsto \naturals,\\
|
||||
&\underbrace{\forall u, v, w \in V: c(u,v) \le c(u,w) + c(w, v)}_\text{Dreiecksungleichung}\}\\
|
||||
\mathcal{S}(\langle K_n, c \rangle) &= \{ C \mid C = (v_{i_1}, v_{i_2}, \dots, v_{i_n}, v_{i_i})\,\text{ist ein Hamiltonkreis}\}\\
|
||||
f(c_\mathrm{E}) &= c(v_{i_n}, v_{i_1}) + \sum_{j=1}^{n-1} c(v_{i_j}, v_{i_{j+1}})\\
|
||||
\mathrm{ziel} &= \min
|
||||
\solution(\encoded{ K_n, c }) &= \{ C \mid C = (v_{i_1}, v_{i_2}, \dots, v_{i_n}, v_{i_i})\,\text{ist ein Hamiltonkreis}\}\\
|
||||
f(c_\edges) &= c(v_{i_n}, v_{i_1}) + \sum_{j=1}^{n-1} c(v_{i_j}, v_{i_{j+1}})\\
|
||||
\ziel &= \min
|
||||
\end{align*}
|
||||
|
||||
\subsubsection{Das Problem der Unabhängigen Knotenmengen \problem{IS}}
|
||||
\subsubsection{Das Problem der Unabhängigen Knotenmengen \is}
|
||||
\begin{align*}
|
||||
\mathcal{D} &= \{\langle G\rangle \mid G = (V, E)\,\text{ein Graph}\}\\
|
||||
\mathcal{S}(\langle G \rangle) &= \{ U \mid U \subseteq V, \forall u, v \in U: (u, v) \notin E\}\\
|
||||
\domain &= \{\encoded{ G} \mid G = (V, E)\,\text{ein Graph}\}\\
|
||||
\solution(\encoded{ G }) &= \{ U \mid U \subseteq V, \forall u, v \in U: (u, v) \notin E\}\\
|
||||
f(U) &= \abs{U}\\
|
||||
\mathrm{ziel} &= \max
|
||||
\ziel &= \max
|
||||
\end{align*}
|
||||
|
||||
\subsubsection{Das Erfüllbarkeitsproblem \problem{Max-SAT}}
|
||||
\subsubsection{Das Erfüllbarkeitsproblem \maxsat}
|
||||
Sei $V = \{x_1, \dots, x_n\}$ die Menge der Variablen.
|
||||
Als Literal $l$ bezeichnet man eine Variable $x_i \in V$ oder ihre Negation $\overline{x_i}$.
|
||||
Eine Oder-Klausel (kurz Klausel) $C = l_1 \lor \dots \lor l_k$ ist eine Oder-Verknüpfung von Literalen.
|
||||
@ -133,29 +182,29 @@ Eine Oder-Klausel (kurz Klausel) $C = l_1 \lor \dots \lor l_k$ ist eine Oder-Ver
|
||||
Eine Boolesche $(n, m)$-Formel $\Phi = C_1 \land \dots \land C_m$ in konjunktiver Normalform ist eine Und-Verknüpfung von Oder-Klauseln aus $n$ Variablen aus $V$.
|
||||
|
||||
\begin{align*}
|
||||
\mathcal{D} &= \{\langle \Phi\rangle \mid \Phi\,\text{eine boolesche $(n,m)$-Formel in KNF}\}\\
|
||||
\mathcal{S}(\langle \Phi \rangle) &= \{ b \mid b: V \mapsto \{\textsc{False}, \textsc{True}\}\}\\
|
||||
\mathrm{wahr}(\Phi) &= \abs{\{j \mid C_j \in \Phi, b(C_j) = \textsc{True}\}}\\
|
||||
\mathrm{ziel} &= \max
|
||||
\domain &= \{\encoded{ \Phi} \mid \Phi\,\text{eine boolesche $(n,m)$-Formel in KNF}\}\\
|
||||
\solution(\encoded{ \Phi }) &= \{ b \mid b: V \mapsto \{\false{}, \true{}\}\}\\
|
||||
\\wahr(\Phi) &= \abs{\{j \mid C_j \in \Phi, b(C_j) = \true{}\}}\\
|
||||
\ziel &= \max
|
||||
\end{align*}
|
||||
|
||||
\subsection{$t(n)$-Zeit-Approximationsalgorithmus}
|
||||
Berechnet ein Algorithmus $A$ in Zeit $t(\abs{I})$ eine Ausgabe $\sigma_I^A \in \mathcal{S}(I)$ für Eingabe $I \in \mathcal{D}$, wird er als $t(n)$-Zeit-Approximationsalgorithmus bezeichnet. Es gilt die Schreibweise $A(I) = f(\sigma_I^A)$.
|
||||
Berechnet ein Algorithmus $A$ in Zeit $t(\abs{I})$ eine Ausgabe $\sigma_I^A \in \solution(I)$ für Eingabe $I \in \domain$, wird er als $t(n)$-Zeit-Approximationsalgorithmus bezeichnet. Es gilt die Schreibweise $A(I) = f(\sigma_I^A)$.
|
||||
|
||||
\subsection{Pseudo-polynomieller Algorithmus}
|
||||
Sei $\Pi$ ein kombinatorisches Optimierungsproblem, sodass in allen Instanzen $I$ alle vorkommenden Zahlen natürliche Zahlen sind. Sei $\mathrm{maxnr}(I)$ die größte in $I$ vorkommende Zahl. Ein Algorithmus wird als pseudo-polynomiell bezeichnet, falls es ein Polynom $\mathrm{poly}(\cdot, \cdot)$ gibt, sodass für alle Instanzen $I$ seine Laufzeit $\mathrm{poly}(\abs{I}, \mathrm{maxnr}(I))$ ist.
|
||||
Sei $\Pi$ ein kombinatorisches Optimierungsproblem, sodass in allen Instanzen $I$ alle vorkommenden Zahlen natürliche Zahlen sind. Sei $\maxnr(I)$ die größte in $I$ vorkommende Zahl. Ein Algorithmus wird als pseudo-polynomiell bezeichnet, falls es ein Polynom $\poly(\cdot, \cdot)$ gibt, sodass für alle Instanzen $I$ seine Laufzeit $\poly(\abs{I}, \maxnr(I))$ ist.
|
||||
|
||||
Kann also das Problem so eingeschränkt werden, dass für alle Instanzen $I$ die größte vorkommende Zahl durch ein Polynom begrenz wird, also $\mathrm{maxnr}(I) \le q(\abs{I})$ mit Polynom $q$ gilt, so ist auch die Laufzeit des Algorithmus polynomiell.
|
||||
Kann also das Problem so eingeschränkt werden, dass für alle Instanzen $I$ die größte vorkommende Zahl durch ein Polynom begrenz wird, also $\maxnr(I) \le q(\abs{I})$ mit Polynom $q$ gilt, so ist auch die Laufzeit des Algorithmus polynomiell.
|
||||
|
||||
\subsection{Starke NP-Vollständigkeit}
|
||||
Ein NP-vollständiges Entscheidungsproblem $L$ wird als stark NP-vollständig bezeichnet, wenn es ein Polynom $q$ gibt, sodass $L_q = \{x \mid x \in L, \mathrm{maxnr}(x) \le q(\abs{x})\}$ NP-vollständig ist. Gibt es kein solches Polynom, gilt $L$ als schwach NP-vollständig.
|
||||
Ein NP-vollständiges Entscheidungsproblem $L$ wird als stark NP-vollständig bezeichnet, wenn es ein Polynom $q$ gibt, sodass $L_q = \{x \mid x \in L, \maxnr(x) \le q(\abs{x})\}$ NP-vollständig ist. Gibt es kein solches Polynom, gilt $L$ als schwach NP-vollständig.
|
||||
|
||||
Eine äquivalente Charakterisierung ist: Das NP-vollständige Entscheidungsproblem $L$ ist stark vollständig, falls es keinen pseudo-polynomiellen Algorithmus für $L$ gibt (unter der Annahme $P \neq NP$).
|
||||
|
||||
\begin{itemize}
|
||||
\item \problem{Hamilton} und \problem{Clique} sind stark NP-vollständig, da bei ihnen das Polynom $q(n) = n$ ausreicht.
|
||||
\item \problem{TSP} ist stark NP-vollständig, da sogar das $\Delta\problem{TSP}$ mit Gewichten 1 und 2 NP-vollständig ist.
|
||||
\item \problem{Rucksack} ist schwach NP-vollständig, weil es einen pseudopolynomiellen Algorithmus für die Optimierungsvariante gibt, der auch für das Entscheidungsproblem verwendet werden kann.
|
||||
\item \hamilton{} und \problem{Clique} sind stark NP-vollständig, da bei ihnen das Polynom $q(n) = n$ ausreicht.
|
||||
\item \tsp{} ist stark NP-vollständig, da sogar das $\deltatsp$ mit Gewichten 1 und 2 NP-vollständig ist.
|
||||
\item \rucksack{} ist schwach NP-vollständig, weil es einen pseudo-polynomiellen Algorithmus für die Optimierungsvariante gibt, der auch für das Entscheidungsproblem verwendet werden kann.
|
||||
\end{itemize}
|
||||
|
||||
\section{Absolute Gütegarantie}
|
||||
@ -167,17 +216,17 @@ Eine äquivalente Charakterisierung ist: Das NP-vollständige Entscheidungsprobl
|
||||
\end{equation*}
|
||||
\item Die absolute Worst-Case-Güte von $A$ abhängig von der Eingabelänge $n = \abs{I}$ ist die Funktion
|
||||
\begin{equation*}
|
||||
\kappa_A^{\mathrm{wc}}(n) = \max\{\kappa_A(I) \mid I \in \mathcal{D}, \abs{I} <= n\}
|
||||
\kappa_A^{\mathrm{wc}}(n) = \max\{\kappa_A(I) \mid I \in \domain, \abs{I} <= n\}
|
||||
\end{equation*}
|
||||
\item $A$ garantiert eine absolute Güte von $\kappa_A: \mathbb{N} \mapsto \mathbb{N}$, falls für alle $n \in \mathbb{N}$ gilt:
|
||||
\item $A$ garantiert eine absolute Güte von $\kappa_A: \naturals \mapsto \naturals$, falls für alle $n \in \naturals$ gilt:
|
||||
\begin{equation*}
|
||||
\kappa_A^{\mathrm{wc}}(n) \le \kappa_A(n)
|
||||
\end{equation*}
|
||||
\item $A$ hat eine absolute Abweichung von $\kappa'_A: \mathbb{N} \mapsto \mathbb{N}$, falls für unendlich viele $n$ gilt
|
||||
\item $A$ hat eine absolute Abweichung von $\kappa'_A: \naturals \mapsto \naturals$, falls für unendlich viele $n$ gilt
|
||||
\begin{equation*}
|
||||
\kappa'_A(n) \le \kappa_A^{wc}(n)
|
||||
\end{equation*}
|
||||
Eine unendlich große Menge $\mathcal{D}' \subseteq \mathcal{D}$ heißt $\kappa'_A(n)$-Zeugenmenge gegen $A$, wenn für alle $I \in \mathcal{D}'$ gilt:
|
||||
Eine unendlich große Menge $\domain' \subseteq \domain$ heißt $\kappa'_A(n)$-Zeugenmenge gegen $A$, wenn für alle $I \in \domain'$ gilt:
|
||||
\begin{equation*}
|
||||
\kappa_A(I) \ge \kappa'_A(\abs{I})
|
||||
\end{equation*}
|
||||
@ -185,19 +234,19 @@ Eine äquivalente Charakterisierung ist: Das NP-vollständige Entscheidungsprobl
|
||||
|
||||
\subsection{Unmöglichkeitsergebnis für das Rucksackproblem}
|
||||
\begin{satz}
|
||||
Falls $P \neq NP$, dann gibt es keine Konstante $n\in \mathbb{N}$, sodass es einen polynomiellen Approximationsalgorithmus $A$ für das Rucksackproblem gibt mit
|
||||
Falls $P \neq NP$, dann gibt es keine Konstante $n\in \naturals$, sodass es einen polynomiellen Approximationsalgorithmus $A$ für \rucksack{} gibt mit
|
||||
\begin{equation*}
|
||||
\abs{A(I) - \opt(I)} \le k
|
||||
\end{equation*}
|
||||
\end{satz}
|
||||
\begin{proof}[Widerspruchsbeweis]
|
||||
Unter der Annahme, dass $A$ und $k$ existieren, kann \problem{Rucksack} in Polynomzeit exakt gelöst werden, was $P = NP$ zur Folge hat:
|
||||
Unter der Annahme, dass $A$ und $k$ existieren, kann \rucksack in Polynomzeit exakt gelöst werden, was $P = NP$ zur Folge hat:
|
||||
|
||||
Konstruiere aus einer Instanz $I = \langle W, \mathrm{vol}, p, B \rangle$ eine neue Probleminstanz $I' = \langle W, \mathrm{vol}, p', B\rangle$ mit $p'(w) = (k + 1) \cdot p(w)$.
|
||||
Konstruiere aus einer Instanz $I = \encoded{ W, \vol, p, B \rangle$ eine neue Probleminstanz $I' = \langle W, \vol, p', B}$ mit $p'(w) = (k + 1) \cdot p(w)$.
|
||||
Eine zulässige Lösung $\sigma$ für $I$ ist auch eine zulässige Lösung für $I'$. Gleiches gilt aufgrund der Monotonie der Multiplikation auch für optimale Lösungen.
|
||||
Durch die Multiplikation aller Preise mit $k + 1$ beträgt die \enquote{Lücke} zwischen den optimalen und der ersten nicht-optimalen Lösung für $I'$ mindestens $k + 1$.
|
||||
|
||||
Da $A$ eine absolute Güte von $k$ garantiert und in Polynomzeit terminiert, kann es nur eine optimale Lösung für $I'$, welche auf optimal für $I$ ist, zurückgeben. Damit ist das $NP$-vollständige \problem{Rucksack} in Polynomzeit exakt lösbar.
|
||||
Da $A$ eine absolute Güte von $k$ garantiert und in Polynomzeit terminiert, kann es nur eine optimale Lösung für $I'$, welche auf optimal für $I$ ist, zurückgeben. Damit ist das $NP$-vollständige \rucksack{} in Polynomzeit exakt lösbar.
|
||||
\end{proof}
|
||||
|
||||
Die hierbei verwendete Vorgehensweise einer Selbstreduktion sowie das \enquote{Aufblasen} des Problems (\enquote{Scaling}, \enquote{Gap Amplification}) lässt sich auch auf viele andere Probleme wie etwa \problem{SetCover} anwenden. Folglich kann eine konstante Gütegarantie nur für vergleichsweise wenig Probleme erreicht werden.
|
||||
@ -211,26 +260,26 @@ Die hierbei verwendete Vorgehensweise einer Selbstreduktion sowie das \enquote{A
|
||||
\end{equation*}
|
||||
\item Die relative Worst-Case-Güte von $A$ ist die Funktion
|
||||
\begin{equation*}
|
||||
\rho_A^\mathrm{wc}(n) = \max\left\{\rho_A(I)\mid I \in \mathcal{D}, \abs{i}\le n\right\}
|
||||
\rho_A^\mathrm{wc}(n) = \max\left\{\rho_A(I)\mid I \in \domain, \abs{i}\le n\right\}
|
||||
\end{equation*}
|
||||
\item $A$ garantiert eine relative Güte von $\rho_A : \mathbb{N} \mapsto \mathbb{N}$, falls für alle $n \in \mathbb{N}$ gilt
|
||||
\item $A$ garantiert eine relative Güte von $\rho_A : \naturals \mapsto \naturals$, falls für alle $n \in \naturals$ gilt
|
||||
\begin{equation*}
|
||||
\rho_A^{\mathrm{wc}}(n) \le \rho_A(n)
|
||||
\end{equation*}
|
||||
\item $A$ macht für die Eingabe $I \in \mathcal{D}$ einen relativen Fehler von
|
||||
\item $A$ macht für die Eingabe $I \in \domain$ einen relativen Fehler von
|
||||
\begin{equation*}
|
||||
\varepsilon_A(I) = \frac{\abs{A(I) - \opt(I)}}{\opt(I)} = \abs{\frac{A(I)}{\opt(I)} - 1}
|
||||
\end{equation*}
|
||||
\item $A$ garantiert einen relativen Fehler von $\varepsilon_A(n)$, falls für alle $\{I\mid I \in \mathcal{D}, \abs{I}\le n\}$ gilt
|
||||
\item $A$ garantiert einen relativen Fehler von $\varepsilon_A(n)$, falls für alle $\{I\mid I \in \domain, \abs{I}\le n\}$ gilt
|
||||
\begin{equation*}
|
||||
\varepsilon_A(I) \le \varepsilon_A(n)
|
||||
\end{equation*}
|
||||
\item $A$ hat eine relative Abweichung von $\rho'_A : \mathbb{N} \mapsto \mathbb{N}$, falls für unendlich viele $n$ gilt
|
||||
\item $A$ hat eine relative Abweichung von $\rho'_A : \naturals \mapsto \naturals$, falls für unendlich viele $n$ gilt
|
||||
\begin{equation*}
|
||||
\rho_A^\mathrm{wc}(n) \ge \rho'_A(n)
|
||||
\end{equation*}
|
||||
|
||||
Eine unendlich große Menge $\mathcal{D}' \subseteq \mathcal{D}$ heißt $\rho'_A(n)$-Zeugenmenge gegen $A$, wenn für alle $I \in \mathcal{D}'$ gilt
|
||||
Eine unendlich große Menge $\domain' \subseteq \domain$ heißt $\rho'_A(n)$-Zeugenmenge gegen $A$, wenn für alle $I \in \domain'$ gilt
|
||||
\begin{equation*}
|
||||
\rho_A(I) \ge \rho'_A(\abs{I})
|
||||
\end{equation*}
|
||||
@ -263,14 +312,14 @@ Weiter lassen sich damit obere bzw. untere Schranken der Optimallösung aus eine
|
||||
\end{equation*}
|
||||
\end{enumerate}
|
||||
|
||||
\subsection{Unmöglichkeitsergebnis für das allgemeine (volle) \problem{TSP}}
|
||||
\subsection{Unmöglichkeitsergebnis für das allgemeine (volle) \tsp}
|
||||
\begin{satz}
|
||||
Wenn es einen polynomiellen Approximationsalgorithmus $A$ mit konstanter relativer Gütegarantie $r$ für das volle \problem{TSP} gibt, dann gilt $P = NP$.
|
||||
Wenn es einen polynomiellen Approximationsalgorithmus $A$ mit konstanter relativer Gütegarantie $r$ für das volle \tsp{} gibt, dann gilt $P = NP$.
|
||||
\end{satz}
|
||||
\begin{proof}[Beweis durch Reduktion]
|
||||
Durch Benutzung von $A$ mit beliebiger konstanter relativer Gütegarantie $r \in \mathbb{N}$ kann \problem{Hamilton} auf das volle \problem{TSP} reduziert werden. Es wird also $\problem{Hamilton} \le \mathrm{p} \problem{TSP}[r]$ für alle $r$ gezeigt:
|
||||
Durch Benutzung von $A$ mit beliebiger konstanter relativer Gütegarantie $r \in \naturals$ kann \hamilton{} auf das volle \tsp reduziert werden. Es wird also $\hamilton{} \le \mathrm{p} \tsp[r]$ für alle $r$ gezeigt:
|
||||
|
||||
Sei der Graph $G = (V, E)$ mit $n = \abs{V}$, gegeben. Dazu wird nun passend eine Probleminstanz $I_G = \langle K_n, c\rangle$ für \problem{TSP} erzeugt. $c$ wird wie folgt konstruiert:
|
||||
Sei der Graph $G = (V, E)$ mit $n = \abs{V}$, gegeben. Dazu wird nun passend eine Probleminstanz $I_G = \encoded{ K_n, c}$ für \tsp erzeugt. $c$ wird wie folgt konstruiert:
|
||||
\begin{equation*}
|
||||
c(u,v) = \begin{cases*}
|
||||
1 & falls $\{u, v\} \in E$ (\enquote{kurze} Kante)\\
|
||||
@ -279,8 +328,8 @@ Weiter lassen sich damit obere bzw. untere Schranken der Optimallösung aus eine
|
||||
\end{equation*}
|
||||
$I_G$ kann in Polynomzeit aus $G$ berechnet werden. Es gilt weiter:
|
||||
\begin{itemize}
|
||||
\item $G \in \problem{Hamilton} \Rightarrow$ kürzeste Rundreise in $I_G$ hat die Länge $n$
|
||||
\item $G \notin \problem{Hamilton} \Rightarrow$ kürzeste Rundreise in $I_G$ nimmt mindestens eine der langen Kanten und hat damit eine Länge von mindestens
|
||||
\item $G \in \hamilton{} \Rightarrow$ kürzeste Rundreise in $I_G$ hat die Länge $n$
|
||||
\item $G \notin \hamilton{} \Rightarrow$ kürzeste Rundreise in $I_G$ nimmt mindestens eine der langen Kanten und hat damit eine Länge von mindestens
|
||||
\begin{equation*}
|
||||
(r - 1) \cdot n + 2 + n - 1 = r \cdot n +1 > r \cdot n
|
||||
\end{equation*}
|
||||
@ -288,14 +337,14 @@ Weiter lassen sich damit obere bzw. untere Schranken der Optimallösung aus eine
|
||||
\end{itemize}
|
||||
|
||||
|
||||
Durch den folgenden Algorithmus kann also \problem{Hamilton} entschieden werden:
|
||||
\begin{algorithmic}[]
|
||||
Durch den folgenden Algorithmus kann also \hamilton{} entschieden werden:
|
||||
\begin{algorithmic}[1]
|
||||
\State konstruiere $I_G$
|
||||
\State approximiere mit $A$ eine kürzeste Rundreise $A(I_G)$
|
||||
\If{$A(I_G) > r \cdot \abs{V}$}
|
||||
\State \Return $G \notin \problem{Hamilton}$
|
||||
\State \Return $G \notin \hamilton{}$
|
||||
\Else
|
||||
\State \Return $G \in \problem{Hamilton}$
|
||||
\State \Return $G \in \hamilton{}$
|
||||
\EndIf
|
||||
\end{algorithmic}
|
||||
\end{proof}
|
||||
@ -308,12 +357,12 @@ Während die Ergebnisse von Approximationsalgorithmen mit absoluter oder relativ
|
||||
\subsection{Definition}
|
||||
Sei $\Pi$ ein Optimierungsproblem und $A$ ein Approximationsalgorithmus für $\Pi$, der eine Probleminstanz $I$ von $\Pi$ und ein $0 < \varepsilon < 1$ bekommt.
|
||||
\begin{enumerate}
|
||||
\item $A$ ist ein polynomielles Approximationsschema (PAS) für $\Pi$, wenn $A$ zu jedem $I$ und für jedes $\varepsilon$ in Zeit $\mathcal{O}(\mathrm{poly}(\abs{I}))$ eine zulässige Lösung zu $I$ mit relativem Fehler $\varepsilon_A(I, \varepsilon) \le \varepsilon$ berechnet.
|
||||
\item $A$ ist ein streng polynomielles Approximationsschema (FPAS), wenn $A$ ein PAS mit Laufzeit $\mathcal{O}(poly\left(\abs{I}, \frac{1}{\varepsilon}\right))$ ist.
|
||||
\item $A$ ist ein polynomielles Approximationsschema (PAS) für $\Pi$, wenn $A$ zu jedem $I$ und für jedes $\varepsilon$ in Zeit $\bigO(\poly(\abs{I}))$ eine zulässige Lösung zu $I$ mit relativem Fehler $\varepsilon_A(I, \varepsilon) \le \varepsilon$ berechnet.
|
||||
\item $A$ ist ein streng polynomielles Approximationsschema (FPAS), wenn $A$ ein PAS mit Laufzeit $\bigO(poly\left(\abs{I}, \frac{1}{\varepsilon}\right))$ ist.
|
||||
\end{enumerate}
|
||||
|
||||
\begin{satz}[Umwandlung eines (F)PAS in einen exakten Algorithmus]
|
||||
Sei $A$ ein (F)PAS und zu jeder Eingabe $I$ $Z(I)$ eine obere Schranke. Sei $\varepsilon^* = \frac{1}{Z(I) + 1}$, dann ist $A(I, \varepsilon^*) = \opt(I)$. Sofern $A$ ein FPAS ist, liegt die Laufzeit in $\mathcal{O}(\mathrm{poly}(\abs{I}, Z(I)))$.
|
||||
Sei $A$ ein (F)PAS und zu jeder Eingabe $I$ $Z(I)$ eine obere Schranke. Sei $\varepsilon^* = \frac{1}{Z(I) + 1}$, dann ist $A(I, \varepsilon^*) = \opt(I)$. Sofern $A$ ein FPAS ist, liegt die Laufzeit in $\bigO(\poly(\abs{I}, Z(I)))$.
|
||||
\end{satz}
|
||||
\begin{proof}
|
||||
Starte $A$ mit Eingabe $I$ und $\varepsilon^*$. Es wird eine zulässige Lösung zu $I$ gefunden, für ihren relativen Fehler gilt
|
||||
@ -329,14 +378,14 @@ Sei $\Pi$ ein Optimierungsproblem und $A$ ein Approximationsalgorithmus für $\P
|
||||
|
||||
\subsection{Unmöglichkeitsergebnisse für Approximationschemata}
|
||||
\begin{satz}
|
||||
Sei $\Pi$ ein Optimierungsproblem. Wenn es ein Polynom $q(\cdot, \cdot)$ gibt, sodass $\forall I \in \mathcal{D}: \opt(I) \le q(\abs{I}, \mathrm{maxnr}(I))$ gilt, dann folgt aus der Existenz eines FPAS für $\Pi$, dass ein pseudo-polynomieller exakter Algorithmus für $\Pi$ existiert.
|
||||
Sei $\Pi$ ein Optimierungsproblem. Wenn es ein Polynom $q(\cdot, \cdot)$ gibt, sodass $\forall I \in \domain: \opt(I) \le q(\abs{I}, \maxnr(I))$ gilt, dann folgt aus der Existenz eines FPAS für $\Pi$, dass ein pseudo-polynomieller exakter Algorithmus für $\Pi$ existiert.
|
||||
\end{satz}
|
||||
\begin{satz}
|
||||
Wenn es für eine Optimierungsvariante eines stark NP-vollständigen Problems ein FPAS gibt, dann folgt $P = NP$.
|
||||
\end{satz}
|
||||
|
||||
\section{\algo{GreedyIS} für \problem{IS}}
|
||||
\begin{algorithmic}[]
|
||||
\section{\greedyis für \is}
|
||||
\begin{algorithmic}[1]
|
||||
\State $U = \emptyset, t = 0, V^{(0)} = V$
|
||||
\While{$V^{(t)} \neq \emptyset$}
|
||||
\State $G^{(t)} =\, \text{der durch}\,V^{(t)}\,\text{induzierte Graph}$
|
||||
@ -351,7 +400,7 @@ Sei $\Pi$ ein Optimierungsproblem und $A$ ein Approximationsalgorithmus für $\P
|
||||
\begin{satz}
|
||||
Sei $G$ ein knoten-$k$-färbbarer Graph, dann ist
|
||||
\begin{equation*}
|
||||
\algo{GreedyIS}(G) \ge \left\lceil \log_k\left(\frac{\abs{V}}{3}\right) \right\rceil
|
||||
\greedyis(G) \ge \left\lceil \log_k\left(\frac{\abs{V}}{3}\right) \right\rceil
|
||||
\end{equation*}
|
||||
\end{satz}
|
||||
|
||||
@ -384,42 +433,42 @@ Sei $\Pi$ ein Optimierungsproblem und $A$ ein Approximationsalgorithmus für $\P
|
||||
\end{proof}
|
||||
|
||||
\section{Knotenfärbungsalgorithmen}
|
||||
\subsection{\algo{GreedyCol}}
|
||||
\begin{algorithmic}[]
|
||||
\subsection{\greedycol}
|
||||
\begin{algorithmic}[1]
|
||||
\ForAll{$u_i \in V$}
|
||||
\State $c_\mathrm{V}(u_i) = \infty$
|
||||
\State $c_\vertices(u_i) = \infty$
|
||||
\EndFor
|
||||
\ForAll{$i \in [1,\dots, \abs{V}]$}
|
||||
\State $c_\mathrm{V}(u_i) = \min\{\mathbb{N}\setminus\{c_\mathrm{V}(\Gamma(u_i))\}\}$
|
||||
\State $c_\vertices(u_i) = \min\{\naturals\setminus\{c_\vertices(\Gamma(u_i))\}\}$
|
||||
\EndFor
|
||||
\State\Return $c_\mathrm{V}$
|
||||
\State\Return $c_\vertices$
|
||||
\end{algorithmic}
|
||||
|
||||
\begin{satz}
|
||||
\algo{GreedyCol} berechnet in Zeit $\mathcal{O}(\abs{V} + \abs{E})$ eine Knotenfärbung aus höchstens $\Delta(G) + 1$ Farben.
|
||||
\greedycol{} berechnet in Zeit $\bigO(\abs{V} + \abs{E})$ eine Knotenfärbung aus höchstens $\Delta(G) + 1$ Farben.
|
||||
\end{satz}
|
||||
\begin{proof}
|
||||
Da ein Knoten $u$ maximal $\Delta(G)$ viele Nachbarn haben kann, muss in $[1,\dots,\Delta(G)+1]$ noch mindestens eine Farbe frei sein.
|
||||
\end{proof}
|
||||
|
||||
\begin{satz}
|
||||
\algo{GreedyCol} garantiert eine absolute Güte von
|
||||
\greedycol{} garantiert eine absolute Güte von
|
||||
\begin{equation*}
|
||||
\kappa_\algo{GreedyCol}(G) = \algo{GreedyCol}(G) - \opt(G) \le \Delta(G) + 1 - 2 = \Delta(G) - 1
|
||||
\kappa_\greedycol(G) = \greedycol(G) - \opt(G) \le \Delta(G) + 1 - 2 = \Delta(G) - 1
|
||||
\end{equation*}
|
||||
, weil die untere Schranke $\opt(G)\ge 2$ für Graphen mit $\abs{V} \ge 2$ gilt.
|
||||
\end{satz}
|
||||
|
||||
\begin{zeuge}
|
||||
$\Delta(G) - 1$-Zeuge gegen \algo{GreedyCol}: TODO (Abbildung 2.1)
|
||||
$\Delta(G) - 1$-Zeuge gegen \greedycol: TODO (Abbildung 2.1)
|
||||
\end{zeuge}
|
||||
|
||||
\subsection{\algo{GreedyCol2}}
|
||||
\begin{algorithmic}[]
|
||||
\subsection{\greedycoltwo}
|
||||
\begin{algorithmic}[1]
|
||||
\State $t = 1, V^{(1)} = V$
|
||||
\While{$V^{(t)} \neq \emptyset$}
|
||||
\State $G^{(t)} =$ der durch $V^{(t)}$ induzierte Graph
|
||||
\State $U_t = \algo{GreedyIS}(G^{(t)})$
|
||||
\State $U_t = \greedyis(G^{(t)})$
|
||||
\State färbe alle Knoten in $U_t$ mit Farbe $t$
|
||||
\State $V^{(t+1)} = V^{(t)} - U_t$
|
||||
\State $t = t + 1$
|
||||
@ -428,10 +477,10 @@ Sei $\Pi$ ein Optimierungsproblem und $A$ ein Approximationsalgorithmus für $\P
|
||||
\end{algorithmic}
|
||||
|
||||
\begin{satz}
|
||||
Für einen knoten-$k$-färbbaren Graph $G = (V, E)$ mit $n = \abs{V}$ gibt \algo{GreedyCol2} eine Färbung mit höchstens $\frac{3n}{\log_k \left(\frac{n}{16}\right)}$. Die relative Gütegarantie liegt als in $\mathcal{O}\left(\frac{n}{\log n}\right)$.
|
||||
Für einen knoten-$k$-färbbaren Graph $G = (V, E)$ mit $n = \abs{V}$ gibt \greedycoltwo{} eine Färbung mit höchstens $\frac{3n}{\log_k \left(\frac{n}{16}\right)}$. Die relative Gütegarantie liegt als in $\bigO\left(\frac{n}{\log n}\right)$.
|
||||
\end{satz}
|
||||
\begin{proof}
|
||||
Zur Vereinfachung bezeichne $n_t = \abs{V^{(t)}}$. Aus der Analyse von \algo{GreedyIS} folgt $\abs{U_t} \ge \log_k\left(\frac{n_t}{3}\right)$. Es ergibt sich die Rekursion
|
||||
Zur Vereinfachung bezeichne $n_t = \abs{V^{(t)}}$. Aus der Analyse von \greedyis{} folgt $\abs{U_t} \ge \log_k\left(\frac{n_t}{3}\right)$. Es ergibt sich die Rekursion
|
||||
\begin{align*}
|
||||
n_1 &= n\\
|
||||
n_{t + 1} &\le n_t - \log_k\left(\frac{n_t}{3}\right)
|
||||
@ -446,7 +495,7 @@ Sei $\Pi$ ein Optimierungsproblem und $A$ ein Approximationsalgorithmus für $\P
|
||||
|
||||
Mit $k = \chi_G = \opt(G)$ ergibt sich für die relative Gütegarantie:
|
||||
\begin{equation*}
|
||||
\frac{\algo{GreedyCol2(G)}}{\opt(G)} \le \frac{\frac{3n}{\log_k\left(\frac{n}{16}\right)}}{k} = \mathcal{O}\left(\frac{n}{\log n}\right)
|
||||
\frac{\algo{GreedyCol2(G)}}{\opt(G)} \le \frac{\frac{3n}{\log_k\left(\frac{n}{16}\right)}}{k} = \bigO\left(\frac{n}{\log n}\right)
|
||||
\end{equation*}
|
||||
\end{proof}
|
||||
|
||||
@ -454,32 +503,32 @@ Sei $\Pi$ ein Optimierungsproblem und $A$ ein Approximationsalgorithmus für $\P
|
||||
TODO: Übung
|
||||
|
||||
|
||||
\section{Christofides' Algorithmus \algo{CH} für das metrische TSP $\Delta\problem{TSP}$}
|
||||
Ein Matching $M$ eines kantengewichteten Graphen $G$ ist ein Teilgraph von $G$ mit $\Delta(G) \le 1$. Ist $G$ ein vollständiger Graph mit $\abs{V}$ gerade, dann gibt es perfekte Matchings. In einem perfekten Matching haben alle Knoten genau den Grad 1. Ein perfektes Matching mit kleinstmöglichem Gewicht wird als leichtestes Matching bezeichnet. Ein solches leichtestes Matching kann in $\mathcal{O}(n^{2.5}\cdot (\log n)^4)$ berechnet werden.
|
||||
\section{Christofides' Algorithmus \algo{CH} für das metrische \tsp $\deltatsp$}
|
||||
Ein Matching $M$ eines kantengewichteten Graphen $G$ ist ein Teilgraph von $G$ mit $\Delta(G) \le 1$. Ist $G$ ein vollständiger Graph mit $\abs{V}$ gerade, dann gibt es perfekte Matchings. In einem perfekten Matching haben alle Knoten genau den Grad 1. Ein perfektes Matching mit kleinstmöglichem Gewicht wird als leichtestes Matching bezeichnet. Ein solches leichtestes Matching kann in $\bigO(n^{2.5}\cdot (\log n)^4)$ berechnet werden.
|
||||
|
||||
Als Multi-Graph wird ein Graph bezeichnet, der um mehrere Kanten zwischen den gleichen Knoten erweitert wurde.
|
||||
|
||||
Wird in einem Pfad jede Kante des (Multi-)Graph genau einmal besucht, so spricht man von einem Euler-Pfad. Bildet der Pfad einen Kreis, so nennt man ihn Euler-Kreis oder Euler-Tour. Haben alle Knoten von $G$ geraden Grad, so existiert eine Euler-Tour in $G$. Diese lässt sich in $\mathcal{O}(\abs{V} + \abs{E})$ berechnen.
|
||||
Wird in einem Pfad jede Kante des (Multi-)Graph genau einmal besucht, so spricht man von einem Euler-Pfad. Bildet der Pfad einen Kreis, so nennt man ihn Euler-Kreis oder Euler-Tour. Haben alle Knoten von $G$ geraden Grad, so existiert eine Euler-Tour in $G$. Diese lässt sich in $\bigO(\abs{V} + \abs{E})$ berechnen.
|
||||
|
||||
Der Algorithmus von Christofides (\algo{CH}) geht wie folgt vor:
|
||||
\begin{algorithmic}[1]
|
||||
\State berechne einen minimalen Spannbaum $T_\mathrm{CH}$ von $I = \langle K_n, c\rangle$
|
||||
\State $S = \{v \in T_\mathrm{CH} \mid \mathrm{deg}_{T_\mathrm{CH}}(v)\, \text{ungerade}\}$ \Comment{$\abs{S}$ ist gerade}
|
||||
\State berechne auf dem durch $S$ induzierten Teilgraphen des $K_n$ ein leichtestes Matching $M_\mathrm{CH}$
|
||||
\State berechne eine Euler-Tour $E = (u_1, u_2, \dots)$ auf $T_\mathrm{CH} \cupdot M_\mathrm{CH}$ \Comment{$T_\mathrm{CH} \cupdot M_\mathrm{CH}$ kann Multi-Graph sein, alle Knoten haben geraden Grad}
|
||||
\State berechne einen minimalen Spannbaum $T_\ch$ von $I = \encoded{ K_n, c}$
|
||||
\State $S = \{v \in T_\ch \mid \mathrm{deg}_{T_\ch}(v)\, \text{ungerade}\}$ \Comment{$\abs{S}$ ist gerade}
|
||||
\State berechne auf dem durch $S$ induzierten Teilgraphen des $K_n$ ein leichtestes Matching $M_\ch$
|
||||
\State berechne eine Euler-Tour $E = (u_1, u_2, \dots)$ auf $T_\ch \cupdot M_\ch$ \Comment{$T_\ch \cupdot M_\ch$ kann Multi-Graph sein, alle Knoten haben geraden Grad}
|
||||
\State entferne Wiederholungen von Knoten in $E$, sodass man $E'$ erhält
|
||||
\State\Return $E'$
|
||||
\end{algorithmic}
|
||||
|
||||
\begin{satz}
|
||||
\algo{CH}, gestartet mit einer Eingabe auf $n$ Knoten, garantiert eine relative Güte von $\rho_\mathrm{CH} \le \frac{3}{2} - \frac{1}{n}$ in einer Laufzeit von $\mathcal{O}(n^{2.5}\cdot (\log n)^4)$.
|
||||
\algo{CH}, gestartet mit einer Eingabe auf $n$ Knoten, garantiert eine relative Güte von $\rho_\ch \le \frac{3}{2} - \frac{1}{n}$ in einer Laufzeit von $\bigO(n^{2.5}\cdot (\log n)^4)$.
|
||||
\end{satz}
|
||||
\begin{proof}
|
||||
Sei $R^*$ eine optimale Rundreise für $I$, d.h. $c(R^*) = \opt(I)$. Es gilt $\algo{CH}(I) = c(E') \le (\frac{3}{2} - \frac{1}{n}) \cdot c(R^*)$ zu zeigen.
|
||||
\begin{enumerate}
|
||||
\item Da $R^*$ aus $n$ Kanten besteht, muss durch ein Durchschnittsargument mindestens eine Kante $e$ mit $c(e) \ge \frac{c(R^*)}{n}$ existieren. Wird diese aus $R^*$ entfernt, so enthält man einen Spannbaum des $K_n$. Da $T_\mathrm{CH}$ minimal ist, gilt
|
||||
\item Da $R^*$ aus $n$ Kanten besteht, muss durch ein Durchschnittsargument mindestens eine Kante $e$ mit $c(e) \ge \frac{c(R^*)}{n}$ existieren. Wird diese aus $R^*$ entfernt, so enthält man einen Spannbaum des $K_n$. Da $T_\ch$ minimal ist, gilt
|
||||
\begin{equation*}
|
||||
c(T_\mathrm{CH}) \le c(R^*) - \frac{c(R^*)}{n} = \left(1 - \frac{1}{n}\right) \cdot c(R^*)
|
||||
c(T_\ch) \le c(R^*) - \frac{c(R^*)}{n} = \left(1 - \frac{1}{n}\right) \cdot c(R^*)
|
||||
\end{equation*}
|
||||
\item In beliebigen Bäumen ist die Anzahl der Knoten mit ungeradem Grad gerade.
|
||||
\item Zur Vereinfachung werden die Knoten so umbenannt, dass $R^* = (u_1, u_2, \dots, u_n, u_1)$ ist.
|
||||
@ -487,13 +536,13 @@ Der Algorithmus von Christofides (\algo{CH}) geht wie folgt vor:
|
||||
|
||||
Aus $S$ kann ein Kreis $H = (u_{i_1}, \dots, u_{i_{\abs{S}}}, u_{i_1})$ gebildet werden. Durch die Dreiecksungleichung ($\abs{H} \le n$ und jede \enquote{Abkürzung} ist maximal gleich lang wie der Weg in $R^*$) gilt $c(H) \le c(R^*)$.
|
||||
|
||||
Es können zwei perfekte Matching $M_1$ und $M_2$ auf $H$ berechnet werden, denn $\abs{S}$ ist gerade. Weil $M_\mathrm{CH}$ minimal ist, folgt o.B.d.A. mit $c(M_1) \le c(M_2)$ die Aussage
|
||||
Es können zwei perfekte Matching $M_1$ und $M_2$ auf $H$ berechnet werden, denn $\abs{S}$ ist gerade. Weil $M_\ch$ minimal ist, folgt o.B.d.A. mit $c(M_1) \le c(M_2)$ die Aussage
|
||||
\begin{equation*}
|
||||
c(M_\mathrm{CH}) \leq c(M_1) \le \frac{1}{2} \cdot (c(M_1) + c(M_2)) = \frac{1}{2} \cdot c(H) \le \frac{1}{2} \cdot c(R^*)
|
||||
c(M_\ch) \leq c(M_1) \le \frac{1}{2} \cdot (c(M_1) + c(M_2)) = \frac{1}{2} \cdot c(H) \le \frac{1}{2} \cdot c(R^*)
|
||||
\end{equation*}
|
||||
\item Da jeder Knoten in $T_\mathrm{CH} \cupdot M_\mathrm{CH}$ geraden Grad hat, kann eine Euler-Tour $E$ berechnet werden. Weil diese nur Kanten aus $T_\mathrm{CH} \cupdot M_\mathrm{CH}$ benutzt, kann ihre Länge mit den vorherigen Ergebnissen wie folgt beschränkt werden:
|
||||
\item Da jeder Knoten in $T_\ch \cupdot M_\ch$ geraden Grad hat, kann eine Euler-Tour $E$ berechnet werden. Weil diese nur Kanten aus $T_\ch \cupdot M_\ch$ benutzt, kann ihre Länge mit den vorherigen Ergebnissen wie folgt beschränkt werden:
|
||||
\begin{equation*}
|
||||
c(E) = c(T_\mathrm{CH} \cupdot M_\mathrm{CH}) \le \left(1 - \frac{1}{n}\right)\cdot c(R^*) + \frac{1}{n}\cdot c(R^*) = \left(\frac{3}{2} - \frac{1}{n}\right) \cdot \opt(I)
|
||||
c(E) = c(T_\ch \cupdot M_\ch) \le \left(1 - \frac{1}{n}\right)\cdot c(R^*) + \frac{1}{n}\cdot c(R^*) = \left(\frac{3}{2} - \frac{1}{n}\right) \cdot \opt(I)
|
||||
\end{equation*}
|
||||
\item Durch die Dreiecksungleichung kann $E'$ nicht länger als $E$ werden.
|
||||
\end{enumerate}
|
||||
@ -502,62 +551,62 @@ Der Algorithmus von Christofides (\algo{CH}) geht wie folgt vor:
|
||||
TODO
|
||||
\end{zeuge}
|
||||
|
||||
\section{Approximationsschema für \problem{Rucksack}}
|
||||
\subsection{\algo{DynRucksack} zur exakten Lösung von \problem{Rucksack}}
|
||||
Für eine Instanz $I = \langle W, \mathrm{vol}, p, B\rangle$ kann direkt eine obere und eine untere Grenze für den maximalen Wert der Füllung angegeben werden:
|
||||
\section{Approximationsschema für \rucksack}
|
||||
\subsection{\dynrucksack{} zur exakten Lösung von \rucksack}
|
||||
Für eine Instanz $I = \encoded{ W, \vol, p, B}$ kann direkt eine obere und eine untere Grenze für den maximalen Wert der Füllung angegeben werden:
|
||||
\begin{equation*}
|
||||
P_{\max} \le \opt(I) \le n \cdot P_{\max}
|
||||
\end{equation*}
|
||||
|
||||
Sei $F_j(\alpha)$, wobei $j \in \{0, 1, \dots, n\} und $$\alpha \in \mathbb{Z}$ gilt, das kleinste benötigte Rucksackvolumen, mit dem man einen Wert von mindestes $\alpha$ erreichen kann, wenn man die ersten $j$ Waren einpacken darf.
|
||||
Sei $F_j(\alpha)$, wobei $j \in \{0, 1, \dots, n\}$ und $\alpha \in \mathbb{Z}$ gilt, das kleinste benötigte Rucksackvolumen, mit dem man einen Wert von mindestens $\alpha$ erreichen kann, wenn man die ersten $j$ Waren einpacken darf.
|
||||
Die formale Definition
|
||||
\begin{equation*}
|
||||
F_j(\alpha) = \min\{\mathrm{vol}(R)\mid R \subseteq \{1, \dots, j\}, p(R) \ge \alpha\}
|
||||
F_j(\alpha) = \min\{\vol(R)\mid R \subseteq \{1, \dots, j\}, p(R) \ge \alpha\}
|
||||
\end{equation*}
|
||||
lässt sich durch die folgende Rekursion ausdrücken:
|
||||
\begin{equation*}
|
||||
f_j(\alpha) = \begin{cases*}
|
||||
0 & falls $\alpha \le 0$\\
|
||||
\infty & falls $\alpha \ge 1, j = 0$\\
|
||||
\min\{F_{j-1}(\alpha - p_j) + \mathrm{vol}(j), F_{j-1}(\alpha)\} & sonst (sog. Bellmannsche Optimalitätsgl.)
|
||||
\min\{F_{j-1}(\alpha - p_j) + \vol(j), F_{j-1}(\alpha)\} & sonst (sog. Bellmannsche Optimalitätsgl.)
|
||||
\end{cases*}
|
||||
\end{equation*}
|
||||
|
||||
Der Algorithmus \algo{DynRucksack} setzt diese durch dynamische Programmierung um:
|
||||
\begin{algorithmic}[]
|
||||
Der Algorithmus \dynrucksack{} setzt diese durch dynamische Programmierung um:
|
||||
\begin{algorithmic}[1]
|
||||
\State $\alpha = 0$
|
||||
\Repeat
|
||||
\State $\alpha = \alpha + 1$
|
||||
\For{$j = 1$ to $n$}
|
||||
\State $F_j(\alpha) = \min\{F_{j-1}(\alpha - p_j) + \mathrm{vol}(j), F_{j-1}(\alpha)\}$
|
||||
\State $F_j(\alpha) = \min\{F_{j-1}(\alpha - p_j) + \vol(j), F_{j-1}(\alpha)\}$
|
||||
\EndFor
|
||||
\Until{$B < F_n(\alpha)$}
|
||||
\State \Return $\alpha - 1$
|
||||
\end{algorithmic}
|
||||
|
||||
\begin{satz}
|
||||
\algo{DynRucksack} berechnet zur Eingabe $I$ den Wert $\opt(I)$ in Zeit $\mathcal{O}(n \cdot \opt(I)) = \mathcal{O}(n^2 \cdot P_{\max})$.
|
||||
\dynrucksack{} berechnet zur Eingabe $I$ den Wert $\opt(I)$ in Zeit $\bigO(n \cdot \opt(I)) = \bigO(n^2 \cdot P_{\max})$.
|
||||
\end{satz}
|
||||
|
||||
\subsection{\algo{AR\textsubscript{$k$}} zur Approximation mit konstantem relativen Fehler}
|
||||
Der Algorithmus \algo{AR\textsubscript{$k$}} rechnet mit um den Faktor $k$ reduzierten, gerundeten Preisen:
|
||||
\begin{algorithmic}[]
|
||||
\State $p_\mathrm{red}(w) = \left\lfloor\frac{p(w)}{k}\right\rfloor$
|
||||
\State $I_\mathrm{red} = \langle W, \mathrm{vol}, p_\mathrm{red}, B \rangle$
|
||||
\State $R_k = \Call{\algo{DynRucksack}}{I_\mathrm{red}}$
|
||||
\begin{algorithmic}[1]
|
||||
\State $p_\red(w) = \left\lfloor\frac{p(w)}{k}\right\rfloor$
|
||||
\State $I_\red = \encoded{ W, \vol, p_\red, B }$
|
||||
\State $R_k = \Call{\dynrucksack{}}{I_\red}$
|
||||
\State \Return $R_k$
|
||||
\end{algorithmic}
|
||||
|
||||
\begin{satz}
|
||||
\algo{AR\textsubscript{$k$}} macht bei Eingabe $I$ einen relativen Fehler von $\varepsilon_{\algo{AR\textsubscript{$k$}}} \le \frac{k \cdot n}{P_{\max}}$ und hat eine Laufzeit von $\mathcal{O}(n^2 \cdot \frac{P_{\max}}{k})$.
|
||||
\algo{AR\textsubscript{$k$}} macht bei Eingabe $I$ einen relativen Fehler von $\varepsilon_{\algo{AR\textsubscript{$k$}}} \le \frac{k \cdot n}{P_{\max}}$ und hat eine Laufzeit von $\bigO(n^2 \cdot \frac{P_{\max}}{k})$.
|
||||
\end{satz}
|
||||
\begin{proof}
|
||||
Sei $R^*$ die Indexmenge einer optimalen Rucksackfüllung für $I$ und $R_k$ die berechnete Indexmenge der Lösung des um $k$ reduzierten Problems $I_\mathrm{red}$.
|
||||
Sei $R^*$ die Indexmenge einer optimalen Rucksackfüllung für $I$ und $R_k$ die berechnete Indexmenge der Lösung des um $k$ reduzierten Problems $I_\red$.
|
||||
|
||||
Da $R_k$ eine optimale Lösung für $I_\mathrm{red}$ ist, gilt $\opt(I_\mathrm{red}) \geq \sum_{j\in R^*}\left\lfloor\frac{p_j}{k}\right\rfloor$. Weiterhin ist $R_k$ eine zulässige Lösung für $I$.
|
||||
Da $R_k$ eine optimale Lösung für $I_\red$ ist, gilt $\opt(I_\red) \geq \sum_{j\in R^*}\left\lfloor\frac{p_j}{k}\right\rfloor$. Weiterhin ist $R_k$ eine zulässige Lösung für $I$.
|
||||
Es gilt dann:
|
||||
\begin{align*}
|
||||
\algo{AR}_k(I) &= p(R_k) \ge k \cdot \sum_{j\in R_k} \left\lfloor \frac{p_j}{k}\right\rfloor = k \cdot \opt(I_\mathrm{red})\\
|
||||
\algo{AR}_k(I) &= p(R_k) \ge k \cdot \sum_{j\in R_k} \left\lfloor \frac{p_j}{k}\right\rfloor = k \cdot \opt(I_\red)\\
|
||||
&\ge k\cdot \sum_{j\in R^*} \left\lfloor \frac{p_j}{k}\right\rfloor \ge k \cdot \sum_{j\in R^*}\left(\frac{p_j}{k} - 1\right) = \sum_{j\in R^*}\left(p_j - k\right) = p(R^*) - k \cdot \abs{R^*}\\
|
||||
&= \opt(I) - k \cdot \abs{R^*} \ge \opt(I) - k \cdot n
|
||||
\end{align*}
|
||||
@ -568,17 +617,17 @@ Der Algorithmus \algo{AR\textsubscript{$k$}} rechnet mit um den Faktor $k$ reduz
|
||||
\end{equation*}
|
||||
\end{proof}
|
||||
|
||||
\subsection{\algo{FPASRucksack} zur Umwandlung in ein streng polynomielles Approximationsschema}
|
||||
\subsection{\fpasrucksack{} zur Umwandlung in ein streng polynomielles Approximationsschema}
|
||||
Um ein FPAS zu erreichen, muss gezeigt werden, dass jedes $\varepsilon \in ]0, 1[$ als relativer Fehler erreichbar ist.
|
||||
Der Algorithmus \algo{FPASRucksack} verwendet dazu \algo{AR\textsubscript{$k$}} und konstruiert ein passendes $k$:
|
||||
\begin{algorithmic}[]
|
||||
Der Algorithmus \fpasrucksack{} verwendet dazu \algo{AR\textsubscript{$k$}} und konstruiert ein passendes $k$:
|
||||
\begin{algorithmic}[1]
|
||||
\State bestimme $n$ und $P_{\max}$ aus der Eingabe $I$
|
||||
\State $k = \varepsilon \cdot \frac{P_{\max}}{n}$
|
||||
\State \Return \Call{\algo{AR\textsubscript{$k$}}}{$I$}
|
||||
\end{algorithmic}
|
||||
|
||||
\begin{satz}
|
||||
\algo{FPASRucksack} ist ein FPAS für \problem{Rucksack} mit einer Laufzeit von $\mathcal{O}\left(n \cdot \log \frac{1}{\varepsilon} + \frac{1}{\varepsilon^4}\right)$.
|
||||
\fpasrucksack{} ist ein FPAS für \rucksack{} mit einer Laufzeit von $\bigO\left(n \cdot \log \frac{1}{\varepsilon} + \frac{1}{\varepsilon^4}\right)$.
|
||||
\end{satz}
|
||||
|
||||
\section{Randomisierte Approximationsalgorithmen}
|
||||
@ -586,7 +635,7 @@ Der Algorithmus \algo{FPASRucksack} verwendet dazu \algo{AR\textsubscript{$k$}}
|
||||
\begin{satz}
|
||||
Sei $\Phi$ eine boolesche $(n,m)$-Formel in KNF, dann gilt
|
||||
\begin{equation*}
|
||||
\max\{\mathrm{wahr}\left(\textsc{False}, \dots, \textsc{False}, \Phi\right), \mathrm{wahr}\left(\textsc{True}, \dots, \textsc{True}, \Phi\right)\} \ge \frac{1}{2}\cdot m
|
||||
\max\{\\wahr\left(\false{}, \dots, \false{}, \Phi\right), \\wahr\left(\true{}, \dots, \true{}, \Phi\right)\} \ge \frac{1}{2}\cdot m
|
||||
\end{equation*}
|
||||
\end{satz}
|
||||
\begin{proof}
|
||||
@ -594,11 +643,11 @@ Der Algorithmus \algo{FPASRucksack} verwendet dazu \algo{AR\textsubscript{$k$}}
|
||||
\end{proof}
|
||||
|
||||
Der folgende Algorithmus $A$ nutzt die sogenannte probabilistische Methode aus, in dem eine Belegung für jede Variable stochastisch unabhängig durchgeführt wird:
|
||||
\begin{algorithmic}
|
||||
\begin{algorithmic}[1]
|
||||
\For{$i = 1\dots n$}
|
||||
\State $x_i = \begin{cases*}
|
||||
\textsc{True} & mit Wahrscheinlichkeit $\frac{1}{2}$\\
|
||||
\textsc{False} & mit Wahrscheinlichkeit $\frac{1}{2}$
|
||||
\true{} & mit Wahrscheinlichkeit $\frac{1}{2}$\\
|
||||
\false{} & mit Wahrscheinlichkeit $\frac{1}{2}$
|
||||
\end{cases*}$
|
||||
\EndFor
|
||||
\State \Return $b_A = (x_1, \dots, x_n)$
|
||||
@ -619,19 +668,19 @@ Der folgende Algorithmus $A$ nutzt die sogenannte probabilistische Methode aus,
|
||||
\begin{equation*}
|
||||
E\left[A(\Phi)\right] \ge \left(1 - \frac{1}{2^k}\right) \cdot m
|
||||
\end{equation*}
|
||||
Des Weiteren existiert eine Belegung $b$ mit $\mathrm{wahr}(b, \Phi) \ge \left(1 - \frac{1}{2^k}\right) \cdot m$.
|
||||
Des Weiteren existiert eine Belegung $b$ mit $\\wahr(b, \Phi) \ge \left(1 - \frac{1}{2^k}\right) \cdot m$.
|
||||
\end{satz}
|
||||
\begin{proof}
|
||||
Für jede Klausel $C_j$ wird eine Indikator-Variable $Z_j$ mit
|
||||
\begin{equation*}
|
||||
Z_j = \begin{cases*}
|
||||
1 & falls $b_A(C_j) = $\textsc{True}\\
|
||||
1 & falls $b_A(C_j) = $\true{}\\
|
||||
0 & sonst
|
||||
\end{cases*}
|
||||
\end{equation*}
|
||||
eingeführt. Da ihr Erwartungswert gleich der Wahrscheinlichkeit, dass sie 1 annimmt, ist, folgt
|
||||
\begin{equation*}
|
||||
E\left[A(\Phi)\right] = E\left[\mathrm{wahr}(b_A, \Phi)\right] = E\left[\sum_{j=1}^{m} Z_j\right] = \sum_{j=1}^{m} \left(1 - \frac{1}{2^{k_j}}\right) \ge \left(1 - \frac{1}{2^k}\right) \cdot m
|
||||
E\left[A(\Phi)\right] = E\left[\\wahr(b_A, \Phi)\right] = E\left[\sum_{j=1}^{m} Z_j\right] = \sum_{j=1}^{m} \left(1 - \frac{1}{2^{k_j}}\right) \ge \left(1 - \frac{1}{2^k}\right) \cdot m
|
||||
\end{equation*}
|
||||
Die Existenz einer solchen Belegung folgt aus einem klassischen Durchschnittsargument.
|
||||
\end{proof}
|
||||
@ -640,7 +689,7 @@ Der folgende Algorithmus $A$ nutzt die sogenannte probabilistische Methode aus,
|
||||
Sei $2^k > m$, dann ist jede boolesche $(n,m)$-Formel $\Phi$ in KNF, in der jede Klausel mindestens $k$ Literale hat, erfüllbar.
|
||||
\end{satz}
|
||||
\begin{proof}
|
||||
Eingesetzt in die vorherige Aussage, erhält man dann $\left(1 - \frac{1}{2^k}\right) \cdot m = m - \overbrace{\frac{m}{2^k}}^{< 1}$. Aus einem Durchschnittsargument folgt auch hier, dass es eine Belegung $b$ mit $m - 1 < \mathrm{wahr}(b, \Phi) \le m$ geben muss, wegen der Ganzzahligkeit von $\mathrm{wahr}$ werden also alle $m$ Klauseln erfüllt.
|
||||
Eingesetzt in die vorherige Aussage, erhält man dann $\left(1 - \frac{1}{2^k}\right) \cdot m = m - \overbrace{\frac{m}{2^k}}^{< 1}$. Aus einem Durchschnittsargument folgt auch hier, dass es eine Belegung $b$ mit $m - 1 < \\wahr(b, \Phi) \le m$ geben muss, wegen der Ganzzahligkeit von $\\wahr$ werden also alle $m$ Klauseln erfüllt.
|
||||
\end{proof}
|
||||
|
||||
\begin{satz}
|
||||
@ -648,7 +697,7 @@ Der folgende Algorithmus $A$ nutzt die sogenannte probabilistische Methode aus,
|
||||
\begin{equation*}
|
||||
E\left[\rho_A(\Phi)\right] = \frac{\opt(\Phi)}{E\left[A(\Phi)\right]} \le \frac{m}{\left(1 - \frac{1}{2^k}\right)\cdot m} = \frac{1}{1 - \frac{1}{2^k}}
|
||||
\end{equation*}
|
||||
. Die Laufzeit des Algorithmus ist $\mathcal{O}(n)$. Wenn die kürzeste Klausel mindestens 2 Literale hat, hat $A$ die erwartete relative Güte $\frac{4}{3}$.
|
||||
. Die Laufzeit des Algorithmus ist $\bigO(n)$. Wenn die kürzeste Klausel mindestens 2 Literale hat, hat $A$ die erwartete relative Güte $\frac{4}{3}$.
|
||||
\end{satz}
|
||||
|
||||
\begin{satz}
|
||||
@ -656,41 +705,41 @@ Der folgende Algorithmus $A$ nutzt die sogenannte probabilistische Methode aus,
|
||||
\end{satz}
|
||||
|
||||
\subsection{Arithmetisierung und Randomized Rounding mit Algorithmus $B$}
|
||||
\problem{Max-SAT} kann auch als Lineares Programm (LP) ausgedrückt werden.
|
||||
\maxsat kann auch als Lineares Programm (LP) ausgedrückt werden.
|
||||
Es bezeichnen im Folgenden $S_j^{\oplus}$ die Menge der Variablen, die in $C_j$ nicht negiert vorkommen, und $S_j^{\ominus}$ die Menge der Variablen, die in $C_j$ negiert vorkommen.
|
||||
Für jede boolesche Variable $x_i$ wird eine 0-1-Variable $\hat{x}_i$ eingeführt; für jede Klausel $C_j$ eine 0-1-Variable $\hat{Z}_j$.
|
||||
Es ergibt sich also das folgende ganzahlige lineare Programm (ILP) $B$ für \problem{Max-SAT}:
|
||||
Es ergibt sich also das folgende ganzahlige lineare Programm (ILP) $B$ für \maxsat:
|
||||
\begin{align*}
|
||||
\text{maximiere} &\quad\sum_{j=1}^{m} \hat{Z}_j\\
|
||||
\text{gemäß} &\quad\sum_{x_i \in S_j^{\oplus}} \hat{x}_i + \sum_{x_i \in S_j^{\ominus}} \left(1 - \hat{x}_i\right) \ge \hat{Z}_j &\forall j\\
|
||||
&\quad\hat{x}_i \in \{0, 1\} &\forall i\\
|
||||
&\quad\hat{Z}_j \in \{0, 1\} &\forall j
|
||||
\end{align*}
|
||||
Relaxiert man die Bedingungen, dass $\hat{x}_i, \hat{Z}_j \in \{0, 1\}$ gelten muss, und stellt fordert stattdessen $\forall i, j: 0\le \hat{x}_i, \hat{Z}_j \le 1$, kann das resultierende LP $B_\mathrm{rel}$ in Polynomzeit gelöst werden. Das LP selbst hat ebenfalls eine polynomiell beschränkte Anzahl an Bedingungen, sodass die Gesammtlaufzeit auch polynomiell beschränkt ist.
|
||||
Relaxiert man die Bedingungen, dass $\hat{x}_i, \hat{Z}_j \in \{0, 1\}$ gelten muss, und stellt fordert stattdessen $\forall i, j: 0\le \hat{x}_i, \hat{Z}_j \le 1$, kann das resultierende LP $B_\rel$ in Polynomzeit gelöst werden. Das LP selbst hat ebenfalls eine polynomiell beschränkte Anzahl an Bedingungen, sodass die Gesammtlaufzeit auch polynomiell beschränkt ist.
|
||||
|
||||
Durch die Relaxierung entsteht die folgende Beziehung (exemplarisch für ein Maximierungsproblem), die als Superoptimalität bezeichnet wird:
|
||||
\begin{equation*}
|
||||
\opt(B_\mathrm{rel}) \ge \opt(B) = \opt(\Phi)
|
||||
\opt(B_\rel) \ge \opt(B) = \opt(\Phi)
|
||||
\end{equation*}
|
||||
|
||||
Im Allgemeinen ist die rationale Lösung $\sigma_\mathrm{rel}$ von $B_\mathrm{rel}$ also keine zulässige Lösung für $B$.
|
||||
Hierzu müssen die $\hat{x}_i$ auf 0 oder 1 (bzw. die $x$ auf \textsc{False} oder \textsc{True}) gerundet müssen.
|
||||
Im Allgemeinen ist die rationale Lösung $\sigma_\rel$ von $B_\rel$ also keine zulässige Lösung für $B$.
|
||||
Hierzu müssen die $\hat{x}_i$ auf 0 oder 1 (bzw. die $x$ auf \false{} oder \true{}) gerundet müssen.
|
||||
Eine Möglichkeit hierzu stellt der durch die stochastische Funktion $\phi: \left[0, 1\right] \mapsto \left[0, 1\right]$ parametrisierte Algorithmus $\algo{RandomizedRounding}[\pi]$ dar:
|
||||
\begin{algorithmic}[]
|
||||
\begin{algorithmic}[1]
|
||||
\For{$i = 1\dots n$}
|
||||
\State $x_i = \begin{cases*}
|
||||
\textsc{True} & mit Wahrscheinlichkeit $\pi(\hat{x}_i)$\\
|
||||
\textsc{False} & mit Wahrscheinlichkeit $1 - \pi(\hat{x}_i)$\\
|
||||
\true{} & mit Wahrscheinlichkeit $\pi(\hat{x}_i)$\\
|
||||
\false{} & mit Wahrscheinlichkeit $1 - \pi(\hat{x}_i)$\\
|
||||
\end{cases*}$
|
||||
\EndFor
|
||||
\State \Return $b_B = (x_1,\dots,x_n)$
|
||||
\end{algorithmic}
|
||||
|
||||
Damit kann dann der Algorithmus $B$ gebildet werden, der \problem{Max-SAT} approximiert:
|
||||
\begin{algorithmic}[]
|
||||
\State konstruiere das LP $B_\mathrm{rel}$ zur Eingabe $\Phi$
|
||||
\State ermittle die rationale Lösung $b_\mathrm{rel}$ von $B_\mathrm{rel}$
|
||||
\State \Return \Call{$\algo{RandomizedRounding}[\pi(x) = x]$}{$b_\mathrm{rel}$}
|
||||
Damit kann dann der Algorithmus $B$ gebildet werden, der \maxsat{} approximiert:
|
||||
\begin{algorithmic}[1]
|
||||
\State konstruiere das LP $B_\rel$ zur Eingabe $\Phi$
|
||||
\State ermittle die rationale Lösung $b_\rel$ von $B_\rel$
|
||||
\State \Return \Call{$\algo{RandomizedRounding}[\pi(x) = x]$}{$b_\rel$}
|
||||
\end{algorithmic}
|
||||
|
||||
\begin{satz}
|
||||
@ -721,7 +770,7 @@ Damit kann dann der Algorithmus $B$ gebildet werden, der \problem{Max-SAT} appro
|
||||
\end{equation*}
|
||||
\end{satz}
|
||||
\begin{satz}
|
||||
Mit der bekannten Abschätzung $1 - \left(1 - \frac{1}{k}\right)^k \ge 1 -\frac{1}{e}$ für alle $k \in \mathbb{N}$
|
||||
Mit der bekannten Abschätzung $1 - \left(1 - \frac{1}{k}\right)^k \ge 1 -\frac{1}{e}$ für alle $k \in \naturals$
|
||||
beträgt die erwartete Anzahl an erfüllten Klauseln von Algorithmus $B$ bei einer Eingabe $\Phi$ in KNF mindestens $\left(1 - \frac{1}{e}\right)\cdot\opt(\Phi) \approx 0.632\cdot\opt(\Phi)$.
|
||||
|
||||
Algorithmus $B$ hat also eine erwartete relative Güte von
|
||||
@ -739,14 +788,14 @@ Aus den bestimmten Gütegarantien lässt sich ablesen, dass Algorithmus $A$ beso
|
||||
|
||||
Beide Verfahren können nun automatisch kombiniert werden, um eine insgesamt bessere Gütegarantie zu erreichen.
|
||||
Dier erste Möglichkeit hierzu ist der Algorithmus $C_{p_A}$:
|
||||
\begin{algorithmic}[]
|
||||
\begin{algorithmic}[1]
|
||||
\State \Return $\begin{cases*}
|
||||
A(\Phi) & mit Wahrscheinlichkeit $p_A$\\
|
||||
B(\Phi) & mit Wahrscheinlichkeit $1 - p_A$
|
||||
\end{cases*}$
|
||||
\end{algorithmic}
|
||||
Alternativ startet der Algorithmus $C_\mathrm{alle}$ immer beide Algorithmen:
|
||||
\begin{algorithmic}[]
|
||||
\begin{algorithmic}[1]
|
||||
\State $b_A = A(\Phi)$
|
||||
\State $b_B = B(\Phi)$
|
||||
\State \Return $\max\{b_A, b_B\}$
|
||||
@ -777,20 +826,24 @@ Es gilt offensichtlich \begin{equation*}
|
||||
Die Ansätze mancher randomisierten Algorithmen können so modifiziert werden, dass sie deterministisch ein Ergebnis zurückliefern, was mindestens so gut wie der Erwartungswert des nicht-deterministischen Algorithmus ist.
|
||||
Man macht sich hierbei unter anderem die Eigenschaft des randomisierten Algorithmus zu Nutze, dass der Erwartungswert auch ohne wirkliche Ausführung des Algorithmus berechenbar ist.
|
||||
|
||||
Der Algorithmus \algo{Derand\_$A$} benutzt den Erwartungswert für Algorithmus $A$ um nach und nach alle Variablen $x_i$ zu belegen. Für jede Variable wird einmal \textsc{True} und \textsc{False} eingesetzt, dann mit der resultierenden Formel mit höherem Erwartungswert fortgefahren:
|
||||
\begin{algorithmic}[]
|
||||
Der Algorithmus \algo{Derand\_$A$} benutzt den Erwartungswert für Algorithmus $A$ um nach und nach alle Variablen $x_i$ zu belegen. Für jede Variable wird einmal \true{} und \false{} eingesetzt, dann mit der resultierenden Formel mit höherem Erwartungswert fortgefahren:
|
||||
\begin{algorithmic}[1]
|
||||
\For{$i = 1\dots n(I)$}
|
||||
\State $W_\textsc{False} = E\left[A(I)\mid x_1,\dots,x_{i-1}, x_i = \textsc{False}\right]$
|
||||
\State $W_\textsc{True} = E\left[A(I)\mid x_1,\dots,x_{i-1}, x_i = \textsc{True}\right]$
|
||||
\If{$W_\textsc{False} < W_\textsc{True}$}
|
||||
\State $x_i = \textsc{True}$
|
||||
\State $W_\false{} = E\left[A(I)\mid x_1,\dots,x_{i-1}, x_i = \false{}\right]$
|
||||
\State $W_\true{} = E\left[A(I)\mid x_1,\dots,x_{i-1}, x_i = \true{}\right]$
|
||||
\If{$W_\false{} < W_\true{}$}
|
||||
\State $x_i = \true{}$
|
||||
\Else
|
||||
\State $x_i = \textsc{False}$
|
||||
\State $x_i = \false{}$
|
||||
\EndIf
|
||||
\EndFor
|
||||
\State \Return $b = (x_1, \dots, x_{n(I)})$
|
||||
\end{algorithmic}
|
||||
\begin{satz}
|
||||
Der Algorithmus \algo{Derand\_$A$} approximiert \problem{Max-SAT} mit relativer Worst-Case-Güte $\rho_{\algo{Derand\_}A} = \frac{1}{1 - \frac{1}{2^k}}$ in Polynomzeit.
|
||||
Der Algorithmus \algo{Derand\_$A$} approximiert \maxsat mit relativer Worst-Case-Güte $\rho_{\algo{Derand\_}A} = \frac{1}{1 - \frac{1}{2^k}}$ in Polynomzeit.
|
||||
\end{satz}
|
||||
|
||||
\section{Approximation durch Lineare Optimierung}
|
||||
Die zum Lösen eines LP mit $k$ Variablen benötigte Zeit wird im Folgenden als $L\left(\abs{\mathrm{LP}}, k\right)$ bezeichnet.
|
||||
Sie liegt in der Größenordnung $\bigO()$
|
||||
\end{document}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user