diff --git a/übung_3/agt_übung_3.pdf b/übung_3/agt_übung_3.pdf
index 0b28dd9..2746b6e 100644
Binary files a/übung_3/agt_übung_3.pdf and b/übung_3/agt_übung_3.pdf differ
diff --git a/übung_3/aufgabe_1.tex b/übung_3/aufgabe_1.tex
index 0bf9bb5..f36a6d8 100644
--- a/übung_3/aufgabe_1.tex
+++ b/übung_3/aufgabe_1.tex
@@ -1,6 +1,55 @@
 \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}