\section{Triangulierungen und Dynamische Programmierung}
\begin{tasks}
	\item
	$$
	T(P)=\begin{cases}
		0 &\textnormal{falls } P \textnormal{ nur 2 Ecken hat}\\
	\min_{i\in \{2,...,n-1\}} [T(p_{1,i})+T(P_{i,n}) \\ 
	+ \textnormal{Diagonalkosten}(i)] &\textnormal{sonst}
	\end{cases} 
	$$
	$$
	\textnormal{Diagonalkosten}(i)= \begin{cases}
		d(p_2, p_n) &\textnormal{falls } i=2\\
		d(p_1, p_{n-1}) &\textnormal{falls } i=n-1\\
		d(p_1, p_i)+d(p_i, p_{n}) &\textnormal{sonst}
	\end{cases}
	$$
	Die Kosten der minimalen Triangulierung $T(P)$ lassen sich aus der minimalsten Summe der konstenminimalsten Triangulierung der entstehenden Teilpolygone $T(p_{1,i})$ und $T(p_{i,n})$ und den entstehenden Diagonalenkosten berechnen.
	
	Die Diagonalenkosten unterscheiden sich, je nachdem ob eine oder zwei der drei Kanten Polygonkanten sind. Sobald ein (Teil-)Polygon nur noch zwei Ecken hat bricht die Rekursion ab.
	\points{2}
	
	\item
	Man nutzt die Idee aus a.
	
	\textbf{Tabelle $A[i,j]$} speichert die kostenminimalen Triangulierung des Teilpolygons mit den Ecken $p_i,...,p_j$.
	
	Für alle $i$ gilt $A[i,i+1]=0$, da diese Teilpolygone mit nur zwei Ecken darstellen, welche keine Triangulierung benötigen.
	
	Für $j>i+1$ gilt:
	$$
	A[i,j]=\min_{k\in\{i+1,...,j-1\}}[A[i,k]+A[k,j]+\textnormal{Diagonalkosten}(i,k,j)]
	$$
	$$
	\textnormal{Diagonalkosten}(i,k,j)=\begin{cases}
		d(p_k,p_j) &\textnormal{falls } k=i+1\\
		d(p_i,p_k) &\textnormal{falls } k=j-1\\
		d(p_i, p_k)+d(p_k, p_j) &\textnormal{sonst}
	\end{cases}
	$$
	Man berechnet dabei die Einträge nach nach wachsendem Abstand $r=j-i$, also von $r=2$ bis $r=n-1$. Dadurch sind die Einträge $A[i,k]$ und $A[k,j]$ immer bereits berechnet wenn man den $A[i,j]$ benötigt, da $k-i<r$ und $j-k<r$ gilt.
	
	Das Ergebnis steht dann in $A[1,n]$.
	\points{4}
	
	\item
	Die polynomielle Laufzeit kann über die Schleifen des DP begründet werden.
	
	Äußere Schleife: $r$ läuft von 1 bis $n-1$ benötigt also $\Oh(n)$ Schritte.
	
	Mittlere Schleife: für jedes $r$ gibt es $\Oh(n)$ Paare $(i,j)$ bei welchen $j-i=r$ gilt.
	
	Innere Schleife: Für jedes Paar probiert man alle $k$ zwischen $i$ und $j$ also $\Oh(n)$ Werte.
	
	Pro Iteration der inneren Schleife benötigt man $\Oh(1)$ um die Einträge zu berechnen.
	
	Daraus folgt:
	$$
	T(n)=\Oh(n)\cdot\Oh(n)\cdot\Oh(n)\cdot\Oh(1)=\Oh(n³)
	$$
	Diese Schranke ist auch scharf, da jeder der $\Oh(n²)$ Tabelleneinträgen auch tatsächlich befüllt wird und für jeden der Einträge im Durchschnitt $\Theta(n)$ Werte von $k$ durchprobiert werden. Es gilt also $\Theta(n³)$.
	
	Der Speicherbedarf des Programms ist $\Oh(n²)$, da die Tabelle so viele Einträge für die Paare $(i,j)$ mit $1\leq i<j\leq n$ hat.
	\points{2}
	
\end{tasks}
