diff --git a/school/di-ma/20181031_1-adj_ex.dot b/school/di-ma/20181031_1-adj_ex.dot
new file mode 100644
index 0000000..7a32ad0
--- /dev/null
+++ b/school/di-ma/20181031_1-adj_ex.dot
@@ -0,0 +1,17 @@
+graph g {
+    node [ shape="point" ];
+    {
+        rank="same";
+        1 [ xlabel="1" ];
+        2 [ xlabel="2" ];
+    }
+    {
+        rank="same";
+        3 [ xlabel="3" ];
+        4 [ xlabel="4" ];
+    }
+    1 -- 2;
+    1 -- 3;
+    1 -- 4;
+    3 -- 4;
+}
diff --git a/school/di-ma/20181031_1-c4.dot b/school/di-ma/20181031_1-c4.dot
new file mode 100644
index 0000000..857cd17
--- /dev/null
+++ b/school/di-ma/20181031_1-c4.dot
@@ -0,0 +1,18 @@
+graph c4 {
+    node [ shape="point" ];
+
+    {
+        rank="same";
+        1; 2;
+    }
+
+    {
+        rank="same";
+        3; 4;
+    }
+
+    1 -- 2;
+    3 -- 4;
+    1 -- 3;
+    2 -- 4;
+}
diff --git a/school/di-ma/20181031_1-c5.dot b/school/di-ma/20181031_1-c5.dot
new file mode 100644
index 0000000..cd251f1
--- /dev/null
+++ b/school/di-ma/20181031_1-c5.dot
@@ -0,0 +1,21 @@
+graph c5 {
+    node [ shape="point" ];
+
+    {
+        rank="same";
+        1;
+        2;
+    }
+
+    {
+        rank="same";
+        3;
+        5;
+    }
+
+    1 -- 2;
+    2 -- 3;
+    3 -- 4;
+    4 -- 5;
+    5 -- 1;
+}
diff --git a/school/di-ma/20181031_1-dag.dot b/school/di-ma/20181031_1-dag.dot
new file mode 100644
index 0000000..f2ab69a
--- /dev/null
+++ b/school/di-ma/20181031_1-dag.dot
@@ -0,0 +1,19 @@
+digraph g {
+    rankdir="LR";
+    node [
+        label="";
+        shape="point";
+    ];
+
+    {
+        rank="same";
+        1;
+        2;
+        1 -> 2;
+    }
+
+    0 -> 1;
+    0 -> 2;
+    1 -> 3;
+    2 -> 3 [ dir="back" ];
+}
diff --git a/school/di-ma/20181031_1-double_undirected.dot b/school/di-ma/20181031_1-double_undirected.dot
new file mode 100644
index 0000000..9a30269
--- /dev/null
+++ b/school/di-ma/20181031_1-double_undirected.dot
@@ -0,0 +1,7 @@
+graph g {
+    rankdir="LR";
+    n [ label=""; shape="point" ];
+    m [ label=""; shape="point" ];
+    n -- m;
+    n -- m;
+}
diff --git a/school/di-ma/20181031_1-ex_digraph.dot b/school/di-ma/20181031_1-ex_digraph.dot
new file mode 100644
index 0000000..de2ff9c
--- /dev/null
+++ b/school/di-ma/20181031_1-ex_digraph.dot
@@ -0,0 +1,11 @@
+digraph g {
+    {
+        rank="same";
+        1;
+        3;
+    }
+    2;
+
+    2 -> 3 -> 1 -> 2;
+    3 -> 2;
+}
diff --git a/school/di-ma/20181031_1-ex_graph.dot b/school/di-ma/20181031_1-ex_graph.dot
new file mode 100644
index 0000000..f935827
--- /dev/null
+++ b/school/di-ma/20181031_1-ex_graph.dot
@@ -0,0 +1,7 @@
+graph g {
+    node [ shape="point" ];
+    1 [ xlabel="1" ];
+    2 [ xlabel="2" ];
+    3 [ xlabel="3" ];
+    1 -- 2 -- 3 -- 1;
+}
diff --git a/school/di-ma/20181031_1-ex_tg.dot b/school/di-ma/20181031_1-ex_tg.dot
new file mode 100644
index 0000000..969af05
--- /dev/null
+++ b/school/di-ma/20181031_1-ex_tg.dot
@@ -0,0 +1,20 @@
+graph g {
+    {
+        rank="same";
+        1;
+        2;
+    }
+
+    {
+        rank="same";
+        4;
+        3 [ style="invisible" ];
+    }
+
+    1 -- 2;
+    1 -- 3 [ style="invisible" ];
+    1 -- 4 [ style="invisible" ];
+    3 -- 2 [ style="invisible" ];
+    2 -- 4;
+    2 -- 5;
+}
diff --git a/school/di-ma/20181031_1-ex_tg_ug.dot b/school/di-ma/20181031_1-ex_tg_ug.dot
new file mode 100644
index 0000000..1086a86
--- /dev/null
+++ b/school/di-ma/20181031_1-ex_tg_ug.dot
@@ -0,0 +1,20 @@
+graph g {
+    {
+        rank="same";
+        1;
+        2;
+    }
+
+    {
+        rank="same";
+        4;
+        3;
+    }
+
+    1 -- 2;
+    1 -- 3;
+    1 -- 4;
+    3 -- 2;
+    2 -- 4;
+    2 -- 5;
+}
diff --git a/school/di-ma/20181031_1-ex_ug.dot b/school/di-ma/20181031_1-ex_ug.dot
new file mode 100644
index 0000000..fd60bb7
--- /dev/null
+++ b/school/di-ma/20181031_1-ex_ug.dot
@@ -0,0 +1,20 @@
+graph g {
+    {
+        rank="same";
+        1;
+        2;
+    }
+
+    {
+        rank="same";
+        4;
+        3 [ style="invisible" ];
+    }
+
+    1 -- 2;
+    1 -- 3 [ style="invisible" ];
+    1 -- 4;
+    3 -- 2 [ style="invisible" ];
+    2 -- 4;
+    2 -- 5;
+}
diff --git a/school/di-ma/20181031_1-graphentheorie.md b/school/di-ma/20181031_1-graphentheorie.md
new file mode 100644
index 0000000..c6f2504
--- /dev/null
+++ b/school/di-ma/20181031_1-graphentheorie.md
@@ -0,0 +1,277 @@
+---
+title: Graphentheorie
+date: 2018-10-31
+---
+
+Idee:
+
+![Knoten](20181031_1-knoten.png)
+
+![Kante](20181031_1-kante.png)
+
+Knoten entsprechen Objekten, Kanten Beziehungen zwischen den Objekten.
+
+Was wir nicht erlauben:
+
+* Schleifen, d.h. Kanten von einem Konten zu sich selbst
+  ![Schleife](20181031_1-loop.png)
+* Mehrfache ungerichtete Kanten zwischen zwei Knoten
+  ![Mehrfach ungerichtet](20181031_1-double_undirected.png)
+
+
+# Gerichtete Graphen
+
+Hier haben Kanten eine Richtung.
+
+![Gerichteter Graph](20181031_1-dag.png)
+
+Bei gerichteten Graphen erlauben wir zwischen zwei Knoten zwei Kanten mit
+unterschiedlicher Richtung.
+
+
+# Definition (Graph)
+
+Sei $V$ eine endliche Menge und $E$ eine Teilmenge von $E \subseteq
+\binom{V}{2} = \{ \{u,v\} | u,v \in V, u \neq v \}$ (alle 2-elementingen
+Teilmengen).
+
+Ein Graph ist ein Tupel
+
+$$
+G = (V, E)
+$$
+
+**Beispiel**: $V = \{1,2,3\}$, $E = \{ \{1,2\}, \{2,3\}, \{1,3\} \}$
+
+![Beispiel Graph](20181031_1-ex_graph.png)
+
+
+# Definition (Gerichteter Graph; Digraph)
+
+Sei $V$ eine endliche Menge und $E \subseteq V \times V = \{ (u,v) | u,v \in E,
+u \neq v \}$.
+
+Ein Digraph ist ein Tupel $G = (V, E)$.
+
+**Beispiel**: $V = \{1,2,3\}$, $E = \{ (2,3), (1,2), (3,1), (3,2) \}$
+
+![Beispiel Digraph](20181031_1-ex_digraph.png)
+
+
+# Wichtige Beispiele von Graphen
+
+a) Vollständiger Graph
+
+    Je zwei Knoten sind miteinander verbunden, d.h. für endliche Menge $V$ mit
+    $|V| = n$ ist $E = \binom{V}{2}$ für $K_n = (V,E)$
+
+    ![$K_3$](20181031_1-ex_graph.png)
+
+    ![$K_4$](20181031_1-k4.png)
+
+    ![$K_5$](20181031_1-k5.png)
+
+b) Kreisgraph $C_n$
+
+    ![$C_4$](20181031_1-c4.png)
+
+    ![$C_5$](20181031_1-c5.png)
+
+    Allgemein für $V = \{ v_1, ..., v_n \}$ dann ist $E = \{ \{v_i, v_{i+1}\} |
+    i \in \{1,..., n-1\} \} \cup \{v_n, v_1\}$
+
+c) Pfad mit $n$ Knoten $P_n$
+
+    ![Pfad](20181031_1-path.png)
+
+d) $d$-dimensionaler Würfel $Q_d$
+
+    Knoten sind alle Elemente aus $\{0,1\}^d$, $V = \{0,1\} \times ... \times
+    \{0,1\} = \{0,1\}^d$ und es gibt eine Kante zwischen zwei Knoten genau
+    dann, wenn sich die beiden Knoten an genau einer Stelle unterscheiden.
+
+
+# Definition (Benachbart, Randknoten, Nachbarschaft, $k$-regulär)
+
+Sei $G = (V, E)$ ein Graph.
+
+a) Zwei Knoten $u,v \in V$ heißen *benachbart* oder *adjazent*, falls $e =
+\{u,v\} \in E$. In diesem Fall heißen $u$ und $v$ *Randknoten* von $e$ oder
+*inzident* zu $e$
+
+b) Die Nachbarschaft eines Knoten $u \in V$ ist die Menge aller zu $u$
+benachbarten Knoten.
+
+    $$
+    \Gamma(u) = \{ v \in V | \{u,v\} \in V \}
+    $$
+
+    Die Größe der Nachbarschaft eines Knotens $u$ heißt **Grad** von $u$
+
+    $$
+    deg(u) = | \Gamma(u) |
+    $$
+
+c) Ein Graph heißt **$k$-regulär**, falls gilt $deg(u) = k, \forall u \in V$
+
+
+**Beispiel**: In $Q_2$ sind
+
+* $(00)$ und $(01)$ Nachbarn
+* $\Gamma((00)) = \{(01,10)\}$
+* $Q_2$ ist 2-regulär, da $deg(u) = 2, \forall u \in V$
+* $Q_d$ ist $d$-regulär
+* Der Pfad $P_n$ ist nicht regulär
+
+
+# Andere Darstellung eines Graphen
+
+a) **Adjazenzmatrix**
+
+    Wir stellen Nachbarschaftsbeziehungen, d.h. Kanten in Form einer Matrix
+    dar. Genauer sei $G = (V, E)$ ein Graph mit $V = \{v_1, ..., v_n\}$.
+
+    Die Adjazenzmatrix $A$ ist eine $n \times n$ Matrix $A = (a_{ij})$ wobei
+    $a_{ij} = \begin{cases}
+    1 & \{v_i, v_j\} \in E \\
+    0 & \text{sonst}
+    \end{cases}$
+
+    **Beispiel 1**: ![Beispiel Graph](20181031_1-adj_ex.png)
+
+    $$
+    A = \left( \begin{matrix}
+    0 & 1 & 1 & 1 \\
+    1 & 0 & 0 & 0 \\
+    1 & 0 & 0 & 1 \\
+    1 & 0 & 1 & 0
+    \end{matrix} \right)
+    $$
+
+b) **Inzidenzmatrix**
+
+    Sei $G = (V,E)$ mit $V = \{v_1, ..., v_n\}$, $E = \{e_1, ..., e_m\}$. Die
+    Inzidenzmatrix $B$ von $G$ ist eine $n \times m$ Matrix $B = (b_{ij})$
+    wobei $b_{ij} = \begin{cases}
+    1 & \text{falls } v_i \text{ inzident zu } e_j \\
+    0 & \text{sonst}
+    \end{cases}$.
+
+    **Beispiel 2**: ![Beispiel Graph](20181031_1-inzidenz_ex.png)
+
+    $$
+    B = \left(\begin{matrix}
+    1 & 0 \\
+    1 & 1 \\
+    0 & 1
+    \end{matrix}\right)
+    $$
+
+    **Bemerkung**: Andere Nummerierung von Knoten und Kanten liefert andere
+    Adjazenz- und Inzidenzmatrix.
+
+
+**Nochmal Beispiel 1 und 2**:
+
+In Beispiel 1 gilt
+$$
+deg(1) = 3 \\
+deg(2) = 1 \\
+deg(3) = 2 \\
+deg(4) = 2
+$$
+
+Es gilt $deg(1) + deg(2) + deg(3) + deg(4) = 4 \cdot 2 = 8$ und es gibt zwei
+Knoten mit ungeradem Grad.
+
+In Beispiel 2 gilt
+$$
+deg(1) = 1 \\
+deg(2) = 2 \\
+deg(3) = 1 \\
+\\
+\sum\limits_{i=1}^3 deg(i) = 4 = 2 \cdot 2
+$$
+
+Und es gibt zwei Knoten mit ungeradem Grad.
+
+Allgemein gilt:
+
+# Satz
+
+Sei $G = (V, E)$ ein Graph, dann gilt $\sum\limits_{u \in V} deg(u) = 2 |E|$
+
+# Beweis
+
+Durch doppeltes Abzählen der Inzidenzmatrix $B = (b_{ij})$.
+
+a) Spaltensumme liefert in jeder Spalte 2. Da es genau $|E|$ Spalten gibt, ist
+$\sum\limits_{i,j} b_{ij} = 2 |E|$
+
+b) Zeilensumme liefert in Zeile $i$ $deg(v_i)$ und damit insgesamt
+$\sum\limits_{i,j} b{ij} = \sum\limits_{v \in V} deg(v)$
+
+$$
+\tag*{$\Box$}
+$$
+
+**Folgerung**: Sei $G=(V,E)$ ein Graph. Die Anzahl der Knoten mit ungeradem
+Grad ist gerade.
+
+## Beweis
+
+Wir teilen die Menge $V$ der Knoten in $V_1$ und $V_2$, wobei
+
+$$
+\begin{align*}
+V_1 &= \{ v \in V | deg(v) \text{ ist ungerade} \} \\
+V_2 &= \{ v \in V | deg(v) \text{ ist gerade} \} \\
+\\
+V_1 \cup V_2 &= V \\
+V_1 \cap V_2 &= \emptyset
+\end{align*}
+$$
+
+Es gilt
+
+$$
+\begin{align*}
+& \sum\limits_{v \in V} deg(v) &= \sum\limits_{v \in V_1} deg(v) + \sum\limits_{v
+\in V_2} deg(v) = 2 |E| \\
+\Rightarrow & \sum\limits_{v \in V_1} deg(v) &= \underbrace{2 |E| - \sum\limits_{v
+\in V_2} deg(v)}_\text{gerade} \\
+\Rightarrow & \sum\limits_{v \in V_1} deg(v) \text{ ist gerade} \\
+\Rightarrow & |V_1| \text{ ist gerade}
+\end{align*}
+$$
+
+$$
+\tag*{$\Box$}
+$$
+
+
+# Definition (Teilgraph/Untergraph)
+
+Sei $G=(V,E)$ ein Graph.
+
+a) Ein Graph $G' = (V',E')$ heißt Teilgraph von $G$, falls $V' \subseteq V$ und
+$E' \subseteq E$.
+
+b) Ein Teilgraph $G' = (V',E')$ heißt Untergraph von $G$, falls $E' = \{
+\{u,v\} | u,v \in V' \land \{u,v\} \in E \} = E \cap \binom{V'}{2}$
+
+**Beispiel**:
+
+![$G$](20181031_1-ex_tg_ug.png)
+
+dann ist ![$G$](20181031_1-ex_tg.png) ein Teilgraph von $G$ (aber kein
+Untergraph)
+
+und ![$G$](20181031_1-ex_ug.png) ist ein Untergraph von $G$
+
+**Notation**: Sei $G=(V,E)$ ein Graph und $V' \subseteq V$, $E' \subseteq E$,
+dann bezeichnet
+
+a) $G[V']$ den von $V'$ induzierten Untergraph
+b) $G \setminus E' = (V, E \setminus E')$
+c) $G \setminus V' = (V \setminus V', E) = G[V \setminus V']$
diff --git a/school/di-ma/20181031_1-inzidenz_ex.dot b/school/di-ma/20181031_1-inzidenz_ex.dot
new file mode 100644
index 0000000..d1986bd
--- /dev/null
+++ b/school/di-ma/20181031_1-inzidenz_ex.dot
@@ -0,0 +1,5 @@
+graph g {
+    node [ shape="point" ];
+    1 -- 2 [ label="e1" ];
+    2 -- 3 [ label="e2" ];
+}
diff --git a/school/di-ma/20181031_1-k4.dot b/school/di-ma/20181031_1-k4.dot
new file mode 100644
index 0000000..784f4de
--- /dev/null
+++ b/school/di-ma/20181031_1-k4.dot
@@ -0,0 +1,11 @@
+graph g {
+    node [ shape="point" ];
+    {
+        rank="same";
+        1;
+        2;
+    }
+
+    1 -- 2 -- 3 -- 4 -- 1 -- 3;
+    2 -- 4;
+}
diff --git a/school/di-ma/20181031_1-k5.dot b/school/di-ma/20181031_1-k5.dot
new file mode 100644
index 0000000..78df127
--- /dev/null
+++ b/school/di-ma/20181031_1-k5.dot
@@ -0,0 +1,17 @@
+graph k5 {
+    node [ shape="point" ];
+
+    {
+        rank="same";
+        1;
+        2;
+    }
+
+    {
+        rank="same";
+        3;
+        5;
+    }
+
+    1 -- 2 -- 3 -- 4 -- 5 -- 1 -- 3 -- 5 -- 2 -- 4 -- 1;
+}
diff --git a/school/di-ma/20181031_1-kante.dot b/school/di-ma/20181031_1-kante.dot
new file mode 100644
index 0000000..83a12b2
--- /dev/null
+++ b/school/di-ma/20181031_1-kante.dot
@@ -0,0 +1,6 @@
+graph g {
+    rankdir="LR";
+    n [ label=""; shape="point" ];
+    m [ label=""; shape="point" ];
+    n -- m;
+}
diff --git a/school/di-ma/20181031_1-knoten.dot b/school/di-ma/20181031_1-knoten.dot
new file mode 100644
index 0000000..1c34aff
--- /dev/null
+++ b/school/di-ma/20181031_1-knoten.dot
@@ -0,0 +1,3 @@
+digraph g {
+    n [ label=""; shape="point" ];
+}
diff --git a/school/di-ma/20181031_1-loop.dot b/school/di-ma/20181031_1-loop.dot
new file mode 100644
index 0000000..4793892
--- /dev/null
+++ b/school/di-ma/20181031_1-loop.dot
@@ -0,0 +1,4 @@
+graph g {
+    n [ label=""; shape="point" ];
+    n -- n
+}
diff --git a/school/di-ma/20181031_1-path.dot b/school/di-ma/20181031_1-path.dot
new file mode 100644
index 0000000..f515b50
--- /dev/null
+++ b/school/di-ma/20181031_1-path.dot
@@ -0,0 +1,8 @@
+graph path {
+    rankdir="LR";
+    node [ shape="point" ];
+
+    1 -- 2 -- 3;
+    3 -- 4 [ style="dotted" ];
+    4 -- 5;
+}
diff --git a/school/di-ma/20181106_1-weg_pfad_kreis.dot b/school/di-ma/20181106_1-weg_pfad_kreis.dot
new file mode 100644
index 0000000..c3f4b52
--- /dev/null
+++ b/school/di-ma/20181106_1-weg_pfad_kreis.dot
@@ -0,0 +1,19 @@
+graph g {
+    node [ shape="circle" ];
+    {
+        rank="same";
+        1;
+        2;
+    }
+
+    {
+        rank="same";
+        3;
+        4;
+    }
+
+    1 -- 2;
+    1 -- 3;
+    1 -- 4;
+    2 -- 4;
+}
diff --git a/school/di-ma/20181106_1-zhk.dot b/school/di-ma/20181106_1-zhk.dot
new file mode 100644
index 0000000..0a43344
--- /dev/null
+++ b/school/di-ma/20181106_1-zhk.dot
@@ -0,0 +1,23 @@
+graph g {
+    node [ shape="circle" ];
+    {
+        rank="same";
+        1;
+        2;
+        5;
+        6;
+    }
+
+    {
+        rank="same";
+        3;
+        4;
+        7;
+    }
+
+    1 -- 2;
+    1 -- 3;
+    1 -- 4;
+    2 -- 4;
+    5 -- 7;
+}
diff --git a/school/di-ma/20181106_1-zusammenhangskomponenten.md b/school/di-ma/20181106_1-zusammenhangskomponenten.md
new file mode 100644
index 0000000..b28b695
--- /dev/null
+++ b/school/di-ma/20181106_1-zusammenhangskomponenten.md
@@ -0,0 +1,111 @@
+---
+title: Zusammenhangskomponenten
+date: 2018-11-06
+---
+
+# Definition (Weg, Pfad, Kreis)
+
+Sei $G=(V,E)$ ein Graph.
+
+a) Ein Weg $w = (v_0, v_1, ..., v_{l-1})$ (der Länge $l$) ist ein Tupel mit
+$v_i \in V$ und $\{v_i, v_{i+1}\} \in E, \forall i \in \{0, ... l-2\}$
+
+b) Ein Pfad ist ein Weg ohne Kontenwiederholung, d.h. $p = \{v_0, v_1, ...
+v_{l-1}\}$ mit $v_i \in V$, $\{v_i, v_{i+1}\} \in E, \forall i \in
+\{0,...,l-2\}$ und $v_i \neq v_j, \forall i = j$
+
+c) Ein Kreis ist ein Pfad $k = (v_0, ... v_{l-1})$ mit $\{v_{l-1}, v_0\} \in E$
+
+
+**Beispiel**: ![Beispiel Graph](20181106_1-weg_pfad_kreis.png)
+
+* $(1,2,3,2,1,3)$ Weg, aber kein Pfad
+* $(3,1,2,4)$ Weg und Pfad, aber kein Kreis
+* $(2,4,1)$ Weg, Pfad und Kreis
+
+
+# Definition (Verbindbar)
+
+Sei $G=(V,E)$ und $u,v \in V$, dann heißen $u$ und $v$ verbindbar, falls es
+einen Weg von $u$ nach $v$ gibt.
+
+Verbindbar ist eine Relation auf der Menge der Knoten. Bei $u$ verbindbar mit
+$v$: $u \sim v$
+
+Diese Relation ist
+
+a) **reflexiv**: $u \sim u, \forall u \in V$ (durch den Punktpfad $(u)$)
+
+a) **symmetrisch**: Falls $u \sim v$, dann auch $v \sim u$ (da Graph
+ungerichtet)
+
+a) **transitiv**: Falls $u \sim v$ und $v \sim w$, dann gilt auch $u \sim w$
+(hängen die Wege von $u$ nach $v$ und $v$ nach $u$ aneinander)
+
+
+$\Rightarrow$ *Verbindbar* ist eine Äquivalenzrelation
+
+
+Es gibt Äquivalenzklassen. Für $u \in V$ betrachte $[v] = \{v \in V | u \sim
+v\}$ Äquivalenzklasse von $u$. Es gilt für $u,v \in V$
+
+$$
+[u] \cap [v] = \begin{cases}
+\emptyset & \lnot (u \sim v) \\
+[u] = [v] & u \sim v
+\end{cases}
+$$
+
+und $\bigcup\limits_{u \in V} [u] = V$, d.h. Äquivalenzklassen bilden Partition
+von $V$.
+
+
+# Definition (Zusammenhangskomponente)
+
+Sei $G=(V,E)$ ein Graph. Die Untergraphen $G[[u]]$, $u \in V$ heißen
+Zusammenhangskomponenten von $G$. $G$ heißt zusammenhängend, falls er nur aus
+einer Zusammenhangskomponente besteht, d.h. $[u] = V, \forall u \in V$
+
+**Beispiel**: ![Beispiel Graph](20181106_1-zhk.png)
+Hat 3 Zusammenhangskomponenten:
+$$
+\begin{align*}
+[1] &= &\{ 1,2,3,4 \} \\
+[2] &= [3] = [4] = &\{ 1,2,3,4 \} \\
+[5] &= [7] = &\{ 5,7 \} \\
+[6] &= &\{ 6 \} \\
+\end{align*}
+$$
+
+
+# Satz
+
+Jeder Graph $G=(V,E)$ hat mindestens $|V| - |E|$ Zusammenhangskomponenten.
+
+
+# Beweis
+
+Per Induktion über die Anzahl der Kanten $|E|$.
+
+Für $|E| = 0$ hat $G=(V,E)$ $|V|$ Komponenten. Sei der Satz richtig für alle
+Graphen mit $|E| \geq m$. Betrachte nun $G=(V,E)$ mit $|E| = m+1$.
+
+Sei $e = \{u,v\} \in E$ und $G' = G \setminus \{e\} = (V, E')$, dann gilt $|E'|
+= m$ und nach Voraussetzung hat $G'$ mindestens $|V| - |E'| = |V| - m$
+Komponenten.
+
+2 Fälle:
+
+a) $u$ und $v$ liegen in der gleichen Zusammenhangskomponente von $G'$, dann
+hat $G$ die gleichen Zusammenhangskomponenten wie $G'$
+
+a) $u$ und $v$ liegen un zwei verschiedenen Zusammenhangskomponenten von $G'$,
+dann hat $G$ eine Zusammenhangskomponente weniger, als $G'$
+
+$$
+\tag*{$\Box$}
+$$
+
+
+**Folgerung**: Für jeden zusammenhängenden Graph $G=(V,E)$ gilt $|E| \leq
+|V|-1$
diff --git a/school/di-ma/20181106_2-baeume.md b/school/di-ma/20181106_2-baeume.md
new file mode 100644
index 0000000..a0afebc
--- /dev/null
+++ b/school/di-ma/20181106_2-baeume.md
@@ -0,0 +1,95 @@
+---
+title: Bäume
+date: 2018-11-06
+---
+
+Bäume sollen zusammenhängende Graphen sein. Mit minimaler Anzahl von Kanten bei
+gegebener Knotenmenge, d.h. $|E| = |V| - 1$. Solche Graphen können keine Kreise
+enthalten.
+
+# Definition (Baum, Wald, Blatt)
+
+a) Ein **Baum** ist ein kreisfreier, zusammenhängender Graph
+a) Ein **Wald** ist ein Grpah mit Zusammenhangskomponenten, die Bäume sind.
+a) ein **Blatt** ist ein Knoten $u$ in einem Baum $T=(V,E)$ mit $deg(u) = 1$.
+Knoten, die keine Blätter sind, heißen innere Knoten
+
+$$
+\tag*{$\Box$}
+$$
+
+
+**Beispiel**
+
+![Baum](20181106_2-tree.png)
+
+Ist ein Baum. Blätter $2,5,6$
+
+![Wald](20181106_2-forest.png)
+
+
+# Lemma
+
+a) Ein Baum mit mindestens 2 Knoten hat mindestens 2 Blätter.
+
+a) In einem Baum gibt es zwischen je 2 Knoten genau einen Pfad.
+
+a) Sei $T=(V,E)$ ein Baum, dann hat $T\setminus \{v\}$ für $v\in V$ genau
+$deg(v)$ Zusammenhangskomponenten.
+
+
+# Beweis (Lemma)
+
+a) Da es mindestens 2 Konten $u,v$ gibt, gibt es auch mindestens 1 Kante
+${u,v}$ mit $u,v \in V$. Gehe in jeder Richtung den Baum entlang, bis wir in
+einer Sackgasse enden. diese beiden Endpunkte sind Blätter. Da es keine Kreise
+gibt, muss die Sackgasse erreicht werden.
+
+a) Gäbe es 2 Pfade, dann auch einen Kreis. Widerspruch zu "kreisfrei"
+
+a) jetzt nicht
+
+
+# Satz
+
+Für jeden Baum $T = (V,E)$ gilt $|E| = |V| - 1$
+
+# Beweis
+
+Wir nehmen an, der Satz sei falsch. Sei $T_0 = (V_0, E_0)$ ein Gegenbeispiel
+mit minimaler Anzahl von Knoten, d.h. es gilt $|E_0| \neq |V_0|-1$ und für alle
+Bäume $T=(V,E)$ mit weniger als $|V_0|$ Knoten gilt $|E|=|V|-1$.
+
+Es gilt sicher $|V_0| \geq 2$, dann gibt es in $T_0$ nach Lemma a) mindestens 2
+Blätter $u, v$.
+
+Betrachte $T' = T_0 \setminus \{u\}$. Da $u$ Blatt gilt $deg(u) = 1$ und laut
+Lemma c) hat $T'$ $deg(u)=1$ viele Zusammenhangskomponenten, d.h. $T'$ ist
+zusammenhängend und kreisfrei.
+
+$\Rightarrow T'$ ist ein Baum mit $T' = (V',E')$ mit $V' = V\setminus \{u\}$,
+$E' = E \setminus \{u, u'\}$, wobei $u'$ der (eindeutige) mit $u$ benachbarte
+Knoten ist.
+
+Da $|V'| \leq |V_0|$ gilt $|E'| = |V'| - 1$, damit $|E_0| - 1 = (|V_0| - 1) -1$
+
+$\Rightarrow |E_0| = |V_0| - 1$. Widerspruch dazu, dass $T_0$ ein Gegenbeispiel
+ist.
+
+$$
+\tag*{$\Box$}
+$$
+
+
+# Definition (Spannbaum)
+
+Sei $G=(V,E)$ ein Graph. Ein Spannbaum $T=(V',E')$ ist ein Teilgraph von $G$
+mit
+
+i) $T$ ist Baum
+i) $V' = V$
+
+
+# Satz (Existenz Spannbaum)
+
+Ein Graph hat genau dann einen Spannbaum, falls $G$ zusammenhängend ist.
diff --git a/school/di-ma/20181106_2-forest.dot b/school/di-ma/20181106_2-forest.dot
new file mode 100644
index 0000000..0723302
--- /dev/null
+++ b/school/di-ma/20181106_2-forest.dot
@@ -0,0 +1,20 @@
+graph g {
+    node [ shape="circle" ];
+    {
+        rank="same";
+        1;
+        5;
+        7;
+    }
+    {
+        rank="same";
+        2;
+        3;
+        6;
+    }
+
+    1 -- 2;
+    1 -- 3;
+    3 -- 4;
+    5 -- 6;
+}
diff --git a/school/di-ma/20181106_2-tree.dot b/school/di-ma/20181106_2-tree.dot
new file mode 100644
index 0000000..162cf07
--- /dev/null
+++ b/school/di-ma/20181106_2-tree.dot
@@ -0,0 +1,19 @@
+graph g {
+    node [ shape="circle" ];
+    {
+        rank="same";
+        2;
+        3;
+    }
+    {
+        rank="same";
+        5;
+        6;
+    }
+
+    1 -- 2;
+    1 -- 3;
+    3 -- 4;
+    4 -- 5;
+    4 -- 6;
+}
diff --git a/school/di-ma/20181107_1-dg.dot b/school/di-ma/20181107_1-dg.dot
new file mode 100644
index 0000000..3214990
--- /dev/null
+++ b/school/di-ma/20181107_1-dg.dot
@@ -0,0 +1,19 @@
+digraph g {
+    node [ shape="circle" ];
+    {
+        rank="same";
+        1;
+        2;
+    }
+
+    {
+        rank="same";
+        4;
+        3;
+    }
+
+    1 -> 2;
+    2 -> 3;
+    3 -> 1;
+    4 -> 1;
+}
diff --git a/school/di-ma/20181107_1-directed_graphs.md b/school/di-ma/20181107_1-directed_graphs.md
new file mode 100644
index 0000000..638bb0e
--- /dev/null
+++ b/school/di-ma/20181107_1-directed_graphs.md
@@ -0,0 +1,76 @@
+---
+title: Gerichtete Graphen
+date: 2018-11-07
+---
+
+**Beispiel**: ![Digraph](20181107_1-dg.png)
+
+$G = (V,E)$
+
+* $V$ endliche Menge
+* $E \subseteq V \times V$
+
+Kanten in $G$ bestehen aus $(u,v)$ mit $u,v \in V, u \neq v$. $u$ heißt
+Startknoten, $v$ heißt Endknoten der Kante $(u,v)$. Vorstellung: Laufen im
+Graph nur in der richtigen Richtung. Kanten sind "Einbahnstraßen".
+
+Für gerichtete Graphen definieren wir: $G=(V,E), u\in V$
+
+* $outdeg(u) = |\{v \in V | (u,v) \in E\}|$
+* $indeg(u) = |\{v \in V | (v,u) \in E\}|$
+
+
+Beispiel von oben:
+
+* $outdeg(1) = 1$, $indeg(1) = 2$
+* $outdeg(4) = 1$, $indeg(4) = 0$
+
+
+# Pfade, Wege, Kreise (gerichtet)
+
+Definiert man analog zum ungerichteten Fall mit der Einschränkung, das Knoten
+eines Pfades/Weges/Kreises in der richtigen Richtung verbunden sind.
+
+
+**Beispiel**: Pfad
+
+*Gegeben*: $G=(V,E)$ gerichteter Graph.
+
+Ein Pfad $p$ ist ein Tupel $(v_0,...,v_{l-1})$ mit $v_i \in V$ und $(v_i,
+v_{i+1}) \in E, \forall i \in \{0,...,l-2\}, v_i \neq v_j, \forall i \neq j$.
+$p$ heißt $v_0v_{l-1}$-Pfad. Existenz eines Pfades von $u$ nach $v$ ($u,v \in
+V$) bezeichnen wir mit $u \rightsquigarrow v$.
+
+
+**Beispiel**: (wie oben)
+
+* $(1,2,3,1,2)$ ist Weg
+* $(4,1,2)$ ist Pfad
+* $(2,3,1)$ ist Kreis
+
+
+# Definition (Zusammenhang)
+
+Sei $G=(V,E)$ gerichteter Graph und $u,v \in V$ Knoten. $u$ und $v$ heißen
+stark zusammenhängend, falls es einen gerichteten $uv$-Pfad und einen
+gerichteten $vu$-Pfad gibt, d.h. falls $u \rightsquigarrow v$ und $v
+\rightsquigarrow u$
+
+$$
+\tag*{$\Box$}
+$$
+
+
+**Beispiel**: (von oben)
+
+* 1 und 3 sind stark zusammenhängend
+* 1 und 4 sind nicht stark zusammenhängend (kein Pfad von 1 nach 4)
+
+
+**Bemerkung**: stark zusammenhängend ist Äquivalenzrelation. Die Untergraphen,
+die den Äquivalenzklassen entsprechen, heißen **(starke)
+Zusammenhangskomponenten**.
+
+
+Ein gerichteter Graph $G$ heißt stark zusammenhängend, falls $G$ nur eine
+Zusammenhangskomponente hat.
diff --git a/school/di-ma/20181107_2-trans_closure.dot b/school/di-ma/20181107_2-trans_closure.dot
new file mode 100644
index 0000000..1de4976
--- /dev/null
+++ b/school/di-ma/20181107_2-trans_closure.dot
@@ -0,0 +1,26 @@
+digraph g {
+    node [ shape="circle" ];
+    {
+        rank="same";
+        1;
+        2;
+    }
+
+    {
+        rank="same";
+        4;
+        3;
+    }
+
+    1 -> 2;
+    2 -> 3;
+    3 -> 1;
+    4 -> 1;
+
+    edge [ style="dotted" ];
+    1 -> 3;
+    2 -> 1;
+    3 -> 2;
+    4 -> 2;
+    4 -> 3;
+}
diff --git a/school/di-ma/20181107_2-transitive-closure.md b/school/di-ma/20181107_2-transitive-closure.md
new file mode 100644
index 0000000..b2fc3fe
--- /dev/null
+++ b/school/di-ma/20181107_2-transitive-closure.md
@@ -0,0 +1,102 @@
+---
+title: Transitive Hülle
+date: 2018-11-07
+---
+
+Gegeben eine endliche Menge $V$ und eine Relation $R$ auf $V$, d.h. $R
+\subseteq V \times V$.
+
+Zwei Elemente $u,v \in V$ stehen in Relation, falls $(u, v) \in R$.
+
+
+**Frage**: Wie findet man die kleinste transitive Hülle von $R^+$ mit $R
+\subseteq R^+$?
+
+$R^+$ heißt transitive Hülle von $R$.
+
+Als Graphenproblem:
+
+Wir modellieren "in relation stehen" durch Kanten
+
+
+# Definition (Transitive Hülle)
+
+Sei $G=(V,E)$ ein gerichteter Graph. Der Graph $G^+ = (V,E^+)$ mit $E^+ = \{
+(v,b) | u,v \in V, (u \rightsquigarrow v) \in G \}$ heißt **transitive Hülle**
+von $G$.
+
+
+**Beispiel**: ![Graph](20181107_1-dg.png)
+
+![Transitive Hülle](20181107_2-trans_closure.png) ist die transitive Hülle von
+obigem Graph.
+
+
+# Algorithmus (Berechnen der Transitiven Hülle; Warshall)
+
+Für einen gerichteten Graphen $G=(V,E)$ mit $V=\{1,...,n\}$ betrachte die
+Adjazenzmatrix von $G$ definiert als $A[i,j] = \begin{cases}
+1 & (i,j) \in E \\
+0 & (i,j) \notin E
+\end{cases}$
+
+**Bemerkung**: $A$ ist im allgemeinen nicht mehr symmetrisch (anders als bei
+ungerichteten Graphen).
+
+**Idee**: Ausgehend von $A$ schrittweise die Adjazenzmatrix der transitiven
+Hülle zu berechnen.
+
+Für $k \in \{0, ..., n\}$ definieren wir Matrizen $T_k$ rekursiv als
+$T_k[i,j] = \begin{cases}
+1 & \text{falls es einen $i$-$j$-Pfad mit Zwischenknoten aus } \{1, ...,
+k\} \text{ gibt} \\
+0 & \text{sonst}
+\end{cases}$.
+
+Dann gilt $T_0 = A$ (Adjazenzmatrix) und $T_n$ ist die Adjazenzmatrix der
+transitiven Hülle
+
+Wir wollen $T_k$ rekursiv aus $T_{k-1}$ berechnen (für $k \geq 1$). Es gilt
+$T_k[i,j] = max \{ T_{k-1}[i,j], T_{k-1}[i,k] \cdot T_{k-1}[k,j] \}$, d.h.
+$T_k[i,j] = 1$ genau dann, wenn $T_{k-1}[i,j] = 1$ oder $T_{k-1}[i,k] = 1$ und
+$T_{k-1}[k,j] = 1$.
+
+Die $i$-$j$-Pfade mit Zwischenknoten aus $\{1,...,k\}$ zerfallen in 2 Fälle:
+
+i) $i$-$j$-Pfade mit Zwischenknoten aus $\{1,...,k-1\}$
+i) $i$-$j$-Pfade, die den Knoten $k$ als Zwischenknoten enthalten
+
+
+Pfade im Fall
+
+i) gibt es, falls $T_{k-1}[i,j] = 1$
+i) gibt es, falls $T_{k-1}[i,k] = 1$ und $T_{k-1}[k,j] = 1$
+
+
+## Algorithmus im Pseudocode
+
+**Eingabe**: Adjazenzmatrix $A$ von $G=(V,E)$ (gerichteter Graph)
+
+**Ausgabe**: Adjazenzmatrix der transitiven Hülle
+
+i) $W = A$
+i) `for` $k$ `in` $\{1,...,n\}$ `do`
+
+    `for` $i$ `in` $\{1,...,n\}$ `do`
+
+    `for` $j$ `in` $\{1,...,n\}$ `do`
+
+    $W[i,j] = max \{ W[i,j], W[i,k] \cdot W[k,j] \}$
+    
+i) Ausgabe $W$
+
+
+**Laufzeit**: $O(n^3)$
+
+**Korrektheit**: Basiert auf Rekusionsformel von oben und der Bemerkung
+$T_{k-1}[i,k] = T_k[i,k]$ und $T_{k-1}[k,j] = T_k[k,j]$.
+
+Dies gilt, da Pfade mit Startknoten $i$ und Endknoten $k$ und Zwischenknoten
+aus $\{1, ..., k-1\}$ sind (in Pfaden gibt es keine Kotenwiederholungen).
+
+Algorithmus ist Beispiel für dynamische Programmierung, dazu später mehr.
diff --git a/school/di-ma/20181114_1-zusammenhangskomponenten.md b/school/di-ma/20181114_1-zusammenhangskomponenten.md
new file mode 100644
index 0000000..edd2d50
--- /dev/null
+++ b/school/di-ma/20181114_1-zusammenhangskomponenten.md
@@ -0,0 +1,33 @@
+---
+title: Zusammenhangskomponenten
+date: 2018-11-14
+---
+
+Breitensuche kann genutzt werden, um die Zusammenhangskomponenten eines Graphen
+zu berechnen.
+
+# Algorithmus (vollständige Breitensuche)
+
+**Eingabe**: $G=(V,E)$ als Adjazenzliste
+
+i) setze $i = 1$
+
+i) `while(V `$\neq \emptyset$`)` do
+
+    a) wähle $s \leftarrow V$ beliebig
+    a) $d,p \leftarrow BREITENSUCHE(G,s)$
+    a) $v_i = \{ v \in V | d[v] \neq \infty \}$
+    a) $V' = V \setminus \{v_i\}$
+    a) $G = G[V']$
+    a) $i \leftarrow i + 1$
+
+
+**Ausgabe**: (Zusammenhangskomponenten von $G$) $G[V_1], ... G[V_{i-1}]$
+
+
+# Satz (Laufzeit vollständige Breitensuche)
+
+Vollständige Breitensuche berechnet in Zeit $O(|V| + |E|)$ die
+Zusammenhangskomponenten von $G$.
+
+Beweis: klar
diff --git a/school/di-ma/20181114_2-stack.md b/school/di-ma/20181114_2-stack.md
new file mode 100644
index 0000000..ca93053
--- /dev/null
+++ b/school/di-ma/20181114_2-stack.md
@@ -0,0 +1,33 @@
+---
+title: Datenstruktur Stack
+date: 2018-11-14
+---
+
+**Beispiel**:
+
+* Postkörbchen
+* Programstack
+
+
+**Idee**: Man kann Sachen oben auf den Stack legen und Sachen (wieder von oben)
+vom Stack entfernen (LIFO).
+
+# Definition (Stack)
+
+Stack ist eine Datenstruktur für eine Menge $U$ mit folgenden Operationen:
+
+i) Erzeugen eines leeren Stacks
+
+    $S \leftarrow new Stack()$
+
+i) Einfügen eines Elements $u \in U$
+
+    $S.push(u)$
+
+i) Entfernen der **zuletzt** eingefügten Elements vom Stack
+
+    $u \leftarrow S.pop()$
+
+i) Testen, ob Stack leer ist
+
+    $S.isEmpty()$
diff --git a/school/di-ma/20181114_3-dfs.dot b/school/di-ma/20181114_3-dfs.dot
new file mode 100644
index 0000000..0e4ae7c
--- /dev/null
+++ b/school/di-ma/20181114_3-dfs.dot
@@ -0,0 +1,29 @@
+graph g {
+    node [ shape="circle" ];
+
+    {
+        rank="same";
+        A;
+        C;
+        E;
+    }
+
+    {
+        rank="same";
+        B;
+        D;
+        F;
+    }
+
+    A -- B;
+    A -- C;
+    B -- C;
+    B -- D;
+    C -- D;
+    C -- E;
+    D -- E;
+    E -- F;
+
+    edge [ style="dotted" ];
+    A -- C -- B -- D -- E -- F;
+}
diff --git a/school/di-ma/20181114_3-tiefensuche.md b/school/di-ma/20181114_3-tiefensuche.md
new file mode 100644
index 0000000..3c28329
--- /dev/null
+++ b/school/di-ma/20181114_3-tiefensuche.md
@@ -0,0 +1,72 @@
+---
+title: Tiefensuche
+date: 2018-11-14
+---
+
+Andere Art einen Spannbaum zu finden.
+
+**Idee**: Starte bei einem Startknoten und laufe im Graphen soweit wie möglich
+(ohne Knotenwiederholung).
+
+Zwei Änderungen gegenüber Breitensuche:
+
+i) Stack statt Queue
+i) Wir bearbeiten zuerst nur einen Nachbarn
+
+
+# Algorithmus (Tiefensuche)
+
+**Eingabe**: $G=(V,E)$ und $s \in V$
+
+i) $pred[v] = NIL, \forall v \in V$
+i) $S \leftarrow new Stack()$
+i) $S.push(s)$
+i) `while (!`$S.isEmpty()$`)`
+
+    a) $v \leftarrow S.pop()$
+    a) falls $\exists u \in \Gamma(v) \setminus \{s\}, pred[u] == NIL$
+
+        * $pred[u] = v$
+        * $S.push(v)$
+        * $S.push(u)$
+
+
+**Ausgabe**: $pred[v], \forall v \in V$
+
+
+**Beispiel**: Tiefensuche (Startknoten $A$)
+
+![Graph](20181114_3-dfs.png)
+
+
+| $v$       | A           | B   | C   | D   | E   | F   |
+| ---       | ---         | --- | --- | --- | --- | --- |
+| $pred[v]$ | $\emptyset$ | C   | A   | B   | D   | E   |
+
+| Stack |
+| ---   |
+| ~~F~~ |
+| ~~E~~ |
+| ~~E~~ |
+| ~~D~~ |
+| ~~D~~ |
+| ~~B~~ |
+| ~~B~~ |
+| ~~C~~ |
+| ~~C~~ |
+| ~~A~~ |
+| ~~A~~ |
+| S     |
+
+
+# Satz (Spannbaum Erzeugung)
+
+Bei Eingabe eines zusammenhängenden Graphen $G=(V,E)$ liefert Algorithmus
+Tiefensuche einen Spannbaum $T=(V,E)$ mit $E' = \{ \{u,pred[u]\} | u \in V
+\setminus \{s\} \}$ von $G$ in Laufzeit $O(|V| + |E|)$
+
+# Beweis
+
+Analog zur Breitensuche
+
+
diff --git a/school/di-ma/20181114_4-bb.dot b/school/di-ma/20181114_4-bb.dot
new file mode 100644
index 0000000..8f617e3
--- /dev/null
+++ b/school/di-ma/20181114_4-bb.dot
@@ -0,0 +1,23 @@
+graph g {
+    node [ shape="circle" ];
+    {
+        rank="same";
+        2;
+        3;
+    }
+
+    {
+        rank="same";
+        4;
+        5;
+        6;
+        7;
+    }
+
+    1 -- 2;
+    1 -- 3;
+    2 -- 4;
+    2 -- 5;
+    3 -- 6;
+    3 -- 7;
+}
diff --git a/school/di-ma/20181114_4-bsb.dot b/school/di-ma/20181114_4-bsb.dot
new file mode 100644
index 0000000..64e05f4
--- /dev/null
+++ b/school/di-ma/20181114_4-bsb.dot
@@ -0,0 +1,15 @@
+graph g {
+    node [ shape="circle" ];
+    10 -- -10;
+    10 -- 100;
+    -10 -- -20;
+    -10 -- -3;
+    -20 -- -25;
+    -3 -- -4;
+    -3 -- -2;
+
+    100 -- 20;
+    100 -- 300;
+    300 -- 200;
+    300 -- 301;
+}
diff --git a/school/di-ma/20181114_4-wb.dot b/school/di-ma/20181114_4-wb.dot
new file mode 100644
index 0000000..e94fb3d
--- /dev/null
+++ b/school/di-ma/20181114_4-wb.dot
@@ -0,0 +1,11 @@
+graph g {
+    node [ shape="circle" ];
+    5 -- 4 -- 1;
+    {
+        rank="same";
+        2;
+        3;
+    }
+    1 -- 2;
+    1 -- 3;
+}
diff --git a/school/di-ma/20181114_4-wurzelbaeume.md b/school/di-ma/20181114_4-wurzelbaeume.md
new file mode 100644
index 0000000..1d57346
--- /dev/null
+++ b/school/di-ma/20181114_4-wurzelbaeume.md
@@ -0,0 +1,90 @@
+---
+title: Wurzelbäume
+date: 2018-11-14
+---
+
+**Idee**: wir zeichnen einen Knoten $v \in V$ für einen Baum $T=(V,E)$ aus,
+nennen ihn Wurzel.
+
+![Wurzelbaum](20181114_4-wb.png)
+
+* $5$: Wurzel
+* $4$: Kindknoten
+* $2$, $3$: Geschwister
+* $4, 1, 2, 3$: Teilbaum
+* $H(T) = 3$
+
+Wurzelbäume "wachsen" nach unten.
+
+
+# Definition (Wurzelbaum)
+
+Sei $T=(V,E)$ ein Baum. Wir definieren für $v \in V$ den in $v$ gewurzelten
+Baum $T_v$ mit
+
+i) $v$ heißt Wurzel
+i) Alle $u \in \Gamma(v)$ heißen Kindknoten von $v$, $v$ heißt Elternknoten von
+$u$
+i) Kindknoten mit gleichen Elternknoten heißen Geschwister
+i) Sei $u$ Kindknoten von $v$. Dann ist $u$ die Wurzel eines Teilbaums mit
+Kindknoten $\Gamma(u) \setminus \{v\}$
+i) Für $u \in V$ mit einem $u$-$v$-Pfad der Länge $k$ sie die $Tiefe(u) = k$
+i) Die Höhe eines Wurzelbaums ist definiert als $H(T_v) = \max\limits_{u \in V}
+\{ Tiefe(u) \}$
+
+$$
+\tag*{$\Box$}
+$$
+
+
+# Definition (Binärbaum)
+
+Sei $T_v=(V,E)$ ein in $v$ gewurzelter Baum.
+
+i) $T_v$ heißt Binärbaum, falls jeder Knoten maximal 2 Kindknoten hat.
+i) $T_v$ heißt **vollständiger** Binärbaum, falls jeder Knoten, der kein Blatt
+ist, genau 2 Kindknoten hat und alle Blätter gleiche Tiefe haben.
+
+
+**Beispiel**:
+
+i) oben ist Binärbaum, aber nicht vollständig
+
+i) ![Binärbaum](20181114_4-bb.png) Vollständiger Binärbaum der Höhe 2
+
+
+**Bemerkung**: Ein vollständiger Binärbaum der Höhe $n$ hat $t$ Knoten mit $t =
+2^{n+1} - 1 = \sum\limits_{i=0}^n 2^i$
+
+
+Binärbäume können beim Suchen von Elementen in einer endlichen Menge genutzt
+werden.
+
+
+# Definition (Binärer Suchbaum)
+
+Sei $T_v=(V,E)$ mit $V \subseteq \mathbb{Z}$ ein binärer Wurzelbaum mit Wurzel
+$v$. $T_v$ heißt binärer Suchbaum, falls für alle $u \in V$ gilt
+
+i) $u_l \leq u, \forall u_l \in V$ im linken Teilbaum
+i) $u_r \geq u, \forall u_r \in V$ im rechten Teilbaum
+
+$$
+\tag*{$\Box$}
+$$
+
+
+**Beispiel**: ![Binärer Suchbaum](20181114_4-bsb.png)
+
+
+# Algorithmus (Binäre Suche)
+
+**Eingabe**: Suchbaum $T_v=(V,E)$ und Element $u \in \mathbb{Z}$
+
+i) setze $w = v$
+i) `while (w `$\neq$`u)` und $w$ kein Blatt
+    a) falls $u < w$: setze $w \leftarrow$ linker Kindknoten von $w$
+    a) falls $u > w$: setze $w \leftarrow$ rechter Kindknoten von $w$
+
+
+**Ausgabe**: falls $w = u$ dann "u gefunden", sonst "u nicht gefunden"
diff --git a/school/di-ma/index.md b/school/di-ma/index.md
index 1044389..c3c5d00 100644
--- a/school/di-ma/index.md
+++ b/school/di-ma/index.md
@@ -11,6 +11,15 @@ subtitle: >
 - [2018-10-17 Wichtige Kombinatorische Probleme](20181017_1-wichtige_kombinatorische_probleme)
 - [2018-10-23 Zahlpartitionen](20181023_1-zahlpartitionen)
 - [2018-10-23 Bälle und Urnen](20181023_2-baelle_und_urnen)
-- [2018-10-30 Catalanzahlen](20181030_1-catalanzahlen.md)
+- [2018-10-30 Catalanzahlen](20181030_1-catalanzahlen)
+- [2018-10-31 Graphentheorie](20181031_1-graphentheorie)
+- [2018-11-06 Zusammenhangskomponenten](20181106_1-zusammenhangskomponenten)
+- [2018-11-06 Bäume](20181106_2-baeume)
+- [2018-11-07 Gerichtete Graphen](20181107_1-directed_graphs)
+- [2018-11-07 Transitive Hülle](20181107_2-transitive-closure)
 - [2018-11-13 Directed Acyclic Graph](20181113_1-dag)
 - [2018-11-13 Breitensuche](20181113_2-breitensuche)
+- [2018-11-14 Zusammenhangskomponenten](20181114_1-zusammenhangskomponenten)
+- [2018-11-14 Datenstruktur Stack](20181114_2-stack)
+- [2018-11-14 Tiefensuche](20181114_3-tiefensuche)
+- [2018-11-14 Wurzelbäume](20181114_4-wurzelbaeume)