From b62a7e60e460c095531ee82a658d12c4f7f74af0 Mon Sep 17 00:00:00 2001 From: Valentin Brandl Date: Mon, 28 Jan 2019 20:58:59 +0100 Subject: [PATCH] Add dima notes --- school/di-ma/20181031_1-adj_ex.dot | 17 ++ school/di-ma/20181031_1-c4.dot | 18 ++ school/di-ma/20181031_1-c5.dot | 21 ++ school/di-ma/20181031_1-dag.dot | 19 ++ school/di-ma/20181031_1-double_undirected.dot | 7 + school/di-ma/20181031_1-ex_digraph.dot | 11 + school/di-ma/20181031_1-ex_graph.dot | 7 + school/di-ma/20181031_1-ex_tg.dot | 20 ++ school/di-ma/20181031_1-ex_tg_ug.dot | 20 ++ school/di-ma/20181031_1-ex_ug.dot | 20 ++ school/di-ma/20181031_1-graphentheorie.md | 277 ++++++++++++++++++ school/di-ma/20181031_1-inzidenz_ex.dot | 5 + school/di-ma/20181031_1-k4.dot | 11 + school/di-ma/20181031_1-k5.dot | 17 ++ school/di-ma/20181031_1-kante.dot | 6 + school/di-ma/20181031_1-knoten.dot | 3 + school/di-ma/20181031_1-loop.dot | 4 + school/di-ma/20181031_1-path.dot | 8 + school/di-ma/20181106_1-weg_pfad_kreis.dot | 19 ++ school/di-ma/20181106_1-zhk.dot | 23 ++ .../20181106_1-zusammenhangskomponenten.md | 111 +++++++ school/di-ma/20181106_2-baeume.md | 95 ++++++ school/di-ma/20181106_2-forest.dot | 20 ++ school/di-ma/20181106_2-tree.dot | 19 ++ school/di-ma/20181107_1-dg.dot | 19 ++ school/di-ma/20181107_1-directed_graphs.md | 76 +++++ school/di-ma/20181107_2-trans_closure.dot | 26 ++ school/di-ma/20181107_2-transitive-closure.md | 102 +++++++ .../20181114_1-zusammenhangskomponenten.md | 33 +++ school/di-ma/20181114_2-stack.md | 33 +++ school/di-ma/20181114_3-dfs.dot | 29 ++ school/di-ma/20181114_3-tiefensuche.md | 72 +++++ school/di-ma/20181114_4-bb.dot | 23 ++ school/di-ma/20181114_4-bsb.dot | 15 + school/di-ma/20181114_4-wb.dot | 11 + school/di-ma/20181114_4-wurzelbaeume.md | 90 ++++++ school/di-ma/index.md | 11 +- 37 files changed, 1317 insertions(+), 1 deletion(-) create mode 100644 school/di-ma/20181031_1-adj_ex.dot create mode 100644 school/di-ma/20181031_1-c4.dot create mode 100644 school/di-ma/20181031_1-c5.dot create mode 100644 school/di-ma/20181031_1-dag.dot create mode 100644 school/di-ma/20181031_1-double_undirected.dot create mode 100644 school/di-ma/20181031_1-ex_digraph.dot create mode 100644 school/di-ma/20181031_1-ex_graph.dot create mode 100644 school/di-ma/20181031_1-ex_tg.dot create mode 100644 school/di-ma/20181031_1-ex_tg_ug.dot create mode 100644 school/di-ma/20181031_1-ex_ug.dot create mode 100644 school/di-ma/20181031_1-graphentheorie.md create mode 100644 school/di-ma/20181031_1-inzidenz_ex.dot create mode 100644 school/di-ma/20181031_1-k4.dot create mode 100644 school/di-ma/20181031_1-k5.dot create mode 100644 school/di-ma/20181031_1-kante.dot create mode 100644 school/di-ma/20181031_1-knoten.dot create mode 100644 school/di-ma/20181031_1-loop.dot create mode 100644 school/di-ma/20181031_1-path.dot create mode 100644 school/di-ma/20181106_1-weg_pfad_kreis.dot create mode 100644 school/di-ma/20181106_1-zhk.dot create mode 100644 school/di-ma/20181106_1-zusammenhangskomponenten.md create mode 100644 school/di-ma/20181106_2-baeume.md create mode 100644 school/di-ma/20181106_2-forest.dot create mode 100644 school/di-ma/20181106_2-tree.dot create mode 100644 school/di-ma/20181107_1-dg.dot create mode 100644 school/di-ma/20181107_1-directed_graphs.md create mode 100644 school/di-ma/20181107_2-trans_closure.dot create mode 100644 school/di-ma/20181107_2-transitive-closure.md create mode 100644 school/di-ma/20181114_1-zusammenhangskomponenten.md create mode 100644 school/di-ma/20181114_2-stack.md create mode 100644 school/di-ma/20181114_3-dfs.dot create mode 100644 school/di-ma/20181114_3-tiefensuche.md create mode 100644 school/di-ma/20181114_4-bb.dot create mode 100644 school/di-ma/20181114_4-bsb.dot create mode 100644 school/di-ma/20181114_4-wb.dot create mode 100644 school/di-ma/20181114_4-wurzelbaeume.md 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)