|
- \documentclass{../../../lecture}
-
- \usepackage{enumerate}
-
- \begin{document}
-
- \begin{aufgabe} Algorithmische Komplexität
- \begin{enumerate}[a)]
- \item Laufzeiten der verschiedenen algorithmischen Komplexitäten $f(n)$ für $2n$ in Abhängigkeit von
- der Ausgangslaufzeit für $n$.
-
- \begin{tabular}{|l|l|l|l|}
- \hline
- $f(n)$ & 4 Sekunden & 10 Sekunden & 100 Sekunden \\ \hline
- $\text{ld}(2n)$ & 5s & 11s & 101s \\ \hline
- $2n$ & 8s & 20s & 200s \\ \hline
- $2n \text{ ld}(2n)$ & 13,49s & 29,13s & 244,64s\\ \hline
- $(2n)^{3}$ & 32s & 80s & 800s \\ \hline
- $2^{2n}$ & 16s & 100s & 10000s\\ \hline
- \end{tabular}
-
- \item
- \begin{enumerate}[1.]
- \item $1$
- \item $\log \log n$
- \item $\log n$
- \item $n^{\epsilon}$
- \item $n^{c}$
- \item $n^{\log n}$
- \item $c^{n}$
- \item $n^{n}$
- \item $c^{\left( c^{n} \right) }$
- \end{enumerate}
-
- \item Beweisen Sie folgende Behauptungen
- \begin{enumerate}
- \item $x^{a} = O(x^{b}) \iff a -b \le 0$
- \begin{proof}
- Seien $a, b, x \in \R$ mit $x > 1 $
-
- Zu zeigen: $\exists c \in \R$: $x^{a} \le c x^{b} \iff a \le b$
-
- Wegen $x > 1$ ist $\ln(x) > 0$ und $\ln(x)$ streng monoton steigend, wähle $c \ge 1$, dann
- folgt:
- \begin{align*}
- &a \le b \\
- \iff &\ln(x) \cdot a \le \ln(x) \cdot b \le \ln(c) + \ln(x) \cdot b \\
- \iff &\ln(x^{a}) \le \ln(c\cdot b^{x})\\
- \iff & x^{a} \le c x^{b}
- .\end{align*}
- \end{proof}
- \item $\log_a(x) = \Theta(\log_b(x))$ $\forall a, b \in \R^{+}$
- \begin{proof}
- Seien $a, b, x \in \R^{+}$.
-
- Zu zeigen: $\exists c \in \R$: $\log_a(x) = c \cdot \log_b(x)$.
- \begin{align*}
- &\log_a(x) = \log_a(x) \\
- \implies & \log_a(x) = \log_a(b) \cdot \frac{\log_a(x)}{\log_a(b)} \\
- \implies & \log_a(x) = \log_a(b) \cdot \log_b(x)
- .\end{align*}
- Mit $c := \log_a(b)$ folgt damit:
- \[
- \log_a(x) = c \cdot \log_b(x)
- .\]
- \end{proof}
- \item $a^{x} = O(b^{x}) \iff 0 \le a \le b$
- \begin{proof}
- Seien $a, b, x \in \R$ mit $x \ge 0$
-
- Zu zeigen: $\exists c \in \R$: $a^{x} \le c b^{x} \iff 0 \le a \le b$
- \begin{align*}
- &0 \le a \le b \\
- \iff &a^{x} \le b^{x} \le b^{x+1} = b \cdot b^{x}
- .\end{align*}
- Mit $c := b$ folgt damit:
- \[
- a^{x} \le c \cdot b^{x} \iff 0 \le a \le b
- .\]
- \end{proof}
- \end{enumerate}
- \end{enumerate}
-
- \end{aufgabe}
-
- \begin{aufgabe} Klassischer Euklidischer Algorithmus
-
- Sei $a, b \in \N_0, a+b > 0$ gegeben.
- \[
- \text{ggT}(a, b) = \begin{cases}
- a & b =0 \\
- \text{ggT}(b,a) & a < b \\
- \text{ggT}(a - b, b) & a \ge b \\
- \end{cases}
- .\]
-
- \begin{enumerate}
- \item Für $a \ge b > 0$ gilt:
- \[
- \text{ggT}(a,b) = \text{ggT}(a -b, b)
- .\]
- \begin{proof}
- Wegen $b \neq 0$ und $a \ge b$ folgt nach Definition:
- \[
- \text{ggT}(a, b) = \text{ggT}(a -b, b)
- .\]
- \end{proof}
- \item Der klassische Euklidische Algorithmus terminiert.
- \begin{proof}
- Seien $(a_n)_{n\in\N} \in \N_0$ und $(b_n)_{n\in\N} \in \N_0$ Folgen mit $a_1 = a$ und
- $b_1 = b$.
-
- Sei $n \in \N$ beliebig.
-
- \begin{itemize}
- \item Falls $b_n = 0$ terminiert der Algorithmus direkt.
- \item
- Falls $a_n < b_n$, folgt nach Definition:
- \[
- a_{n+1} = b_n \text{ und } b_{n+1} = a_n < b_n
- .\] Damit folgt:
- \[
- b_{n+1} < b_n
- .\]
- \item Falls $a_n \ge b_n$ folgt nach Definition:
- \[
- a_{n+1} = (a_n - b_n) \in \N_0 \text{ und } b_{n+1} = b_n
- .\] Wegen $a_{n+1} < a_n $ folgt, dass $\exists k \in \N$: $a_{n+k} < b_n$. Dann
- tritt wieder der zweite Fall ein, d.h.
- \[
- b_{n+k+1} < b_n
- .\]
- \end{itemize}
-
- Damit folgt, dass $(b_n)_{n\in\N}$ für fast alle $n \in \N$ streng monoton fällt.
- Da $(b_n)_{n \in \N} \in \N_0$, folgt:
- \[
- \exists k \in \N\text{: } b_k = 0
- .\]
- Damit terminiert der \textit{klassische Euklidische Algorithmus} immer.
- \end{proof}
- \end{enumerate}
- \end{aufgabe}
-
- \begin{aufgabe}
- Binomialkoeffizient
- \begin{enumerate}[a)]
- \item Programm siehe \textit{binomial.cc}
-
- Für $n = 35$ und $k = 18$ benötigt das Programm mehr als 20 Sekunden für die Berechnung.
-
- Für $n = 34$ und $k = 18$ liefert das Programm $-2091005866$. Das liegt an der
- begrenzten Größe des Datentyps \textbf{int}. Bei Überschreitung der maximalen Größe
- beginnt der Wert erneut bei dem Minimalwert des Datentyps \textbf{int}. Deshalb können
- wir dann negative Ergebnisse erhalten.
- \item Der Rechenaufwand für die rekursive Berechnung des Binomialkoeffizienten ist:
- \begin{align*}
- A_{n, 0} = A_{n, n} = A_{n, k>n} = 1 \\
- A_{n,k} = A_{n-1, k-1} + A_{n-1, k}
- .\end{align*}
- \item Programm siehe \textit{binomial\_fast.cc}
-
- Die schnellere Variante hat die Komplexität $O(n)$, da die Komplexität der Fakultätsfunktion
- $O(n)$ ist und diese einfach dreimal ausgeführt wird.
-
- Programm (c) ist deutlich schneller als Programm (a) für größere Zahlen $n$ und $k$. Aufgrund
- der Verwendung der Fakultät, wird allerdings schneller die maximale Größe eines \textbf{int}'s
- erreicht. Dadurch erhalten wir bereits für recht kleine Werte für $n$ und $k$ falsche Ergebnisse.
- \item Ein effizienter Algorithmus berechnet jede Zeile linear iterativ, aus der vorhergehenden
- Zeile, damit ist die Komplexität $O(n)$.
-
- Der Unterschied entsteht daraus, dass bei (a) einzelne Binomialkoeffizienten mehrfach
- ausgerechnet werden müssen und bei (d) jeder Binomialkoeffizient genau einmal ausgerechnet wird.
- \end{enumerate}
- \end{aufgabe}
-
- \end{document}
|
