3. Algorithmen-Highlights

Intro: Hase-Igel Algorithmus

Tortoise and Hare algorithm https://leetcode.com/problems/find-the-duplicate-number

Let a be an array of length $n+1$, containing numbers $\in \{1,\dots ,n\}$.
Then, by the pigeonhole principle, at least one number must be duplicate. We want to find this number.

We visualise our array as a graph, where each $a[i]=j$ means there is a directed edge from $i\to j$.

We want to do this with linear $O(n)$ runtime and constant extra memory. Thus we cannot use hashmaps (extra space) nor sorting (extra time).

Phase 1 Prove that $\exists t\le n$ s.t. $X_t=X_{2t}$.

• let $r=\lceil \frac{k}{l}\rceil \cdot l-k\ge 0$ (as $\lceil \frac{k}{l}\rceil \cdot l\ge k$)
• then $X_{k+r}$ is on the cycle $C$.
• $k+r$ is a multiple of $l$
• thus $X_{k+r}=X_{2(k+r)}$
  • as $X_{k+r}$ means we are already on the cycle, then advancing another $p\cdot l$ steps (i.e. a multiple) of $l$ means we end up at the same place
    We can also prove that $t\le n$ now:
• $t:=k+r=\lceil \frac{k}{l}\rceil \cdot l<(\frac{k}{l}+1)\cdot l=k+l$
• and $k+l\le n$ as there are only $k+l$ nodes on the graph (and there can be at most n nodes)

Phase 2 Prove that for $t\le n$ with $X_t=X_{2t}$ $⟹$ $X_{t+k}=X_k$.

• $X_t=X_{2t}⟹2t=t+p\cdot l$
• thus $t=p\cdot l$
• thus $X_{k+t}=X_k$ as we move $p$ times around the cycle when starting from $k$ (the beginning of the cycle).

# First phase
hase = a[n]; igel = a[a[n]]
t = 1
while (igel != hase)
	igel = a[igel]
	hase = a[a[hase]]
	t++
 
# Second phase
hase = n # reset to start
while (hase != igel)
	i = hase; j = igel;
	igel = a[igel]
	hase = a[hase]
return i, j

Runtime $O(n)$, as $t\le n$ and $k\le n$. The total runtime is $O(t+k)=O(n)$.

3.1 Graphenalgorithmen

3.1.1. Lange Pfade

Wir wollen für einen Graphen $G$ und $B\in {\mathbb{N}}_0$ feststellen, ob es einen Pfad der Länge $B$ in $G$ gibt. Wir nennen dies das LONG-PATH Problem.

NP-Reduction The problem is probably not solvable in polynomial time, as we can show that for $B=|V|$ it’s equivalent to the Hamilton-path problem (which is NP-complete).
We transform $G$ in the following way:

• we choose any $v^{\ast }\in G$.

• For each $\{v^{\ast },w_i\}\in E$, we create a new node ${\hat{w}}_i$ and insert the edge $\{{\hat{w}}_i,w_i\}$.
  This results in $G^{\prime }$ with at most $(n-1)+\mathrm{deg}(v)\le 2n-2$ nodes (as $\mathrm{deg}(v)\le n-1$).

• (1) $G$ has Hamilton-path $⟹$ $G^{\prime }$ has path of length $n$

  • Let $⟨v_1,v_2,v_3,\dots ,v_n,v_1⟩$ be a Hamiltonpath in $G$
  • Wlog let $v_1=v^{\ast }$.
  • Then $⟨{\hat{v}}_2,v_2,\dots ,v_n,{\hat{v}}_n⟩$ is a path of length $n$ in $G^{\prime }$

• (2) $G^{\prime }$ has path of length $n$ $⟹$ $G$ has Hamilton-path

  • Let $⟨u_0,u_1,\dots ,u_n⟩$ be a path of length $n$ in $G^{\prime }$
  • Note that $u_1,\dots ,u_{n-1}$ have to have $\mathrm{deg}\ge 2$
    • thus they have to be exactly the $n-1$ surviving nodes after changing $v^{\ast }$
  • Thus $u_0=\widehat{w_i}$ and $u_n={\hat{w}}_j$ have exactly $\mathrm{deg}=1$. Thus $u_1=w_i$ and $u_{n-1}=w_j$
  • Then $⟨v^{\ast },u_1,\dots ,u_{n-1},v^{\ast }⟩$ is a Hamiltonpath in $G$

We can thus transform $G\to G^{\prime }$ in $O(n^2)$ at most.

3.1 LONG-PATH reduction

If we can solve LONG-PATH for a graph with $n$ nodes in $t(n)$, then we can solve the Hamiltonpath problem in $t(2n-2)+O(n^2)$.

What about long-paths with $B\le \log n$? we have indeed found a polynomial time algorithm for this: Color Coding

Bunte Pfade

Sei $G=(V,E)$ ein Graph mit einer Abbildung $\gamma :V\to [k]$. Ein Pfad ist bunt, wenn alle Knoten verschiedene Farben $\gamma (v)$ haben.

On the basis of this definition, we now define the following set for $v\in V$ and $i\in {\mathbb{N}}_0$:

$$P_i(v):=\left\{S\in \left(\genfrac{}{}{0ex}{}{[k]}{i+1}\right)\mid \exists \text{in }v\text{ endender genau mit }S\text{ gefa¨rbter bunter Pfad}\right\}$$

The following is an example of $P_2(v)$:

$P_i(v)$ contains a set $S$ of $i+1$ colours iff. there is a colourful path ending in $v$, whose colours are exactly $S$.

• Such a path must always have length $i$.
• Every such path contains $\gamma (v)$.

DP-Algorithm If we can calculate the set $P_{k-1}(v)$ for all $v$, our problem is solved as

$$\exists \text{bunter Pfad der La¨nge }k-1⟺\bigcup _{v\in V}{P}_{k-1}(v)\ne \varnothing$$

Base Case:

• $P_0(v)=\{\{\gamma (v)\}\}$
• $P_1(v)=\{\{\gamma (x),\gamma (v)\}\mid x\in N(v)\text{ und }\gamma (x)\ne \gamma (v)\}$
  Thus we can write our recursion step as

$$P_i(v)=\bigcup _{x\in N(v)}\left\{R\cup \{\gamma (v)\}\mid R\in P_{i-1}(x)\text{ und }\gamma (v)\notin R\right\}$$

Runtime

Solving LONG-PATH We now can check if a path of length $B$ exists in a coloured graph. How do we colour it to get polynomial runtime?

• we randomly assign a colouring with $[k]$ colours, $k:=B+1$.
• if there is a colourful path of length $k-1$, there is definitely a path of length $B$
• if not, we might have had bad luck

Probability of finding a path if it exists Assume that $G$ contains a path of length $k-1$.

• there are $k^k$ possible colourings
• in $k!$ of these cases the path is colourful.

$$\begin{array}{rl}{p}_{success}& :=\mathrm{Pr}[\exists \text{colourful path of length }k-1]\\ & \ge \mathrm{Pr}[P\text{ist bunt}]=\frac{k!}{k^k}\ge e^{-k}\end{array}$$

3.2

Let $G$ be a graph with a path of length $k-1$

1. A random colouring with $k$ colours creates a path of length $k-1$ with $p_{\text{success}}\ge e^{-k}$
2. If we repeatedly randomly colour the graph and check, the expected number of times is $\frac{1}{p_{\text{successs}}}\le e^k$

Proof (2) holds as $X\sim \text{Geo}(p)$ and thus $\mathbb{E}[X]=1/p=p$ .

We can now easily construct a Monte-Carlo algorithm (as the runtime is constant - as we choose it, but the output is not always right), which solves the problem in polynomial runtime.

• We choose $\lambda \in \mathbb{R}$, $\lambda >1$ and repeat our test $\lceil \lambda e^k\rceil$ times, until we get a YES. If we never get one, we return NO (but we are unsure, maybe we should have tried more).

3.3

1. The algorithm runs in $O(\lambda (2e{)}^{k}km)$
2. If the graph has a path of length $k-1$, the probability that the algorithms outputs NO is at most $e^{-\lambda }$.

Proof (3)

• we know $\forall x\in \mathbb{R}$ $1+x\le e^x$.
• The probability our algorithm says no it at most

$$(1-e^{-k}{)}^{\lceil \lambda e^k\rceil }\le {\left(e^{-e^{-k}}\right)}^{\lceil \lambda e^k\rceil }\le e^{-\lambda }$$

Note: We can make this deterministic (i.e. non-random)

• there is a family $\mathcal{F}$ of colourings $\gamma :V\to [k]$
• For every subset $A\subseteq V$ of size $k$, some colouring in $\mathcal{F}$ gives all elements in $A$ different colours
  These are called $k$-perfect hash families.
  — Aside → these are related to the universal hashing schemes used for hashmaps. (they are the existential, worst-case sibling)

Note: In acyclic graphs this problem becomes easy → we simply assign weight $-1$ to each edge and search for shortest path. Then run over it with Bellman-Ford.

3.1.2 Flüsse in Netzwerken

Network

A network is a tuple $N=(V,A,c,s,t)$ where:

• $(V,A)$ is a directed Graph
• $s\in V$ is the source
• $t\in V$ is the sink
• $c:A\to {\mathbb{R}}_0^{+}$ de capacity function

The capacity of an edge limits the amount of “water” or anything really that flows through it.

There is another constraint: the network is closed, similar to Kirchhoff’s law for electronics. The sum of inputs / outputs at each node is 0 (except source and sink).

3.5 Zulässigkeit & Erhaltung

Let $N=(V,A,c,s,t)$ be a network. A flow (Fluss) in $N$ is a function $f:A\to \mathbb{R}$ with the constraints:

• $0\le f(e)\le c(e)$ for each $a\in A$ (except $s,t$)
• For all $v\in V\setminus \{s,t\}$:

$$\sum _{u\in V:(u,v)\in A}f(u,v)=\sum _{u\in V:(v,u)\in A}f(v,u)$$

(incoming = outgoing of a node)

3.5b Value of a flow

The value (Wert) of a flow is defined as

$$\text{val}(f):=\text{netoutflow}(s):=\sum _{u\in V:(s,u)\in A}f(s,u)-\sum _{u\in V:(u,s)\in A}f(u,s)$$

Note: ${\sum }_{u\in V:(u,s)\in A}f(u,s)$ is not $0$. → This means that a source can have incoming edges of non-zero capacity as well!

• the source/sink here are not the strict definitions from before (no incoming / outgoing edges)
  Note: a flow can have a negative value (more incoming than outcoming - ex: one edge $(t,s)$ with $c((t,s))>0$ the flow could then have that edge with positive $f(e)$ and we have negative value).

A flow is of integral (ganzzahlig) if $f(e)\in \mathbb{Z}$, $\forall e\in A$.

In our model, the value of a flow measures how much “water” is actually moved. Thus all that is going in also comes out → inflow = outflow.

3.6 Nettozufluss

The net-inflow of a sink is equal to the value of the flow:

$$\text{netinflow}(t):=\sum _{u\in V:(u,t)\in A}f(u,t)-\sum _{u\in V:(t,u)\in A}f(t,u)=\text{netoutflow}(s)$$

Proof

The problem we are interested in now is how to determine the “maximum flow”.
Note: it’s not clear such a flow always exists. For real $\mathbb{R}$ capacities, it might be like $(0,1)$ having no largest number in it.

→ The way to solve this problem is to switch perspective and look at cuts (specifically minimum cuts)

3.7 $s$-$t$-Cut

An $s$-$t$-cut for a network $N=(V,A,c,s,t)$ is a partition $(S,T)$ of $V$ with $s\in S$ and $t\in T$.
The capacity of a cut is given by

$$\text{cap}(S,T):=\sum _{(u,w)\in (S\times T)\cap A}c(u,w)$$

i.e. the sum of all edges crossing the cut from $S\to T$ (note: those in the reverse direction are not subtracted).

3.8 Cut $\le$ Flow

Is $f$ a flow and $(S,T)$ a cut then

$$\text{val}(f)\le \text{cap}(S,T)$$

Proof: For a partition $(U,W)$ of $V$ $f(U,W):={\sum }_{(u,w)\in (W\times W)\cap A}f(u,w)$
We want to prove

$$\text{val}(f)\stackrel{(i)}{=}f(S,T)-f(T,S)\stackrel{(ii)}{\le }f(S,T)\stackrel{(iii)}{\le }\text{cap}(S,T)$$

note, for (ii) we are basically only using that $f(T,S)\ge 0$. For (iii) we are just using $0\le f(e)\le c(e)$.

All cuts have same flow (CLRS p.721)

Shown in (i): For a flow $f$, no matter which $(S,T)$ cut we choose, the net flow crossing that cut is the same and equal to the value of the flow.
i.e. $\text{val}(f)=f(S,T)-f(T,S)$ for all $S,T$ cuts.

• (i) → similar structure to before

$$\begin{array}{rl}\text{val}(f)& =\sum _{u\in V:(s,u)\in A}f(s,u)-\sum _{u\in V:(u,s)\in A}f(u,s)\\ & =\sum _{v\in S}\left(\sum _{u\in V:(v,u)\in A}f(v,u)-\sum _{u\in V:(u,v)\in A}f(u,v)\right)\\ & =\sum _{(u,w)\in (S\times T)\cap A}f(u,w)-\sum _{(u,w)\in (T\times S)\cap A}f(u,w)\\ & =f(S,T)-f(T,S)\end{array}\text{\hspace{1em}(1)(2)(3)(4)}$$

- (1): is just the definition
- (1) $\to$ (2): since by Flusserhaltung, for $v \neq s$ $\sum f(v, u) - \sum f(u, v) = 0$, we can rewrite the sum over all nodes in $S$
	- note this is not true for $t$, but $t \not \in S$ by definition of the cut
	- all terms except the $f(s, u)$ and $f(u, s)$ sums cancel out.
- (2) $\to$ (3): 
  we take the double sum and regroup it by if the edge crosses or does not cross the cut.	  ![[cut<=flow.png]]
   - (3) $\to$ (4): just definition as stated before

Details on (2) → (3): We can split the sum in the following way due to the observation that edges that cross the cut are not cancelled

As every network has only a finite amount of cuts ($2^{|V|-2}$ of them to be exact) there is in all cases a minimum cut. With the next theorem, we show that finding the minimum-cut is the dual of finding the maximum flow.

3.9 Maxflow-Mincut Theorem

Every network $N=(V,A,c,s,t)$ satisfies

$$\underset{f\text{ flow in }N}{\max }\text{val}(f)=\underset{(S,T)\text{ cut in N}}{\min }\text{cap}(S,T)$$

Note: the asymmetry of subtracting edges crossing the cut $T\times S$ from the flow but not their capacity from the min-cut is important: otherwise you could have $\text{cap}(S,T)<\text{val}(f)$.

we already know $\le$ from the lemma 3.8
→ we will prove the equality now, by construction using the Ford-Fulkerson algorithm. (i.e. we show such a maxflow exists)

We can find a maximum flow iteratively, by repeatedly increasing it along augmenting paths.

Note: we can increase the overall value of the flow by decreasing the flow along “backwards” edges (this allows us to push more through the forward ones).

Note: this only works in networks with rational capacities. If they were real we could not guarantee to reach the max-flow in a finite time.

Restnetzwerk (Residual network)

Let $N=(V,A,c,s,t)$ be a network without multi-edges. Let $f$ be a flow in $N$.
The residual network $N_f$ is defined as follows:

1. if $e\in A$ with $f(e)\le c(e)$, then there is also an edge $e$ in $A_f$, with $r_f(e):=c(e)-f(e)$
2. If $e\in A$ with $f(e)>0$ then there is $e^{opp}$ in $A_f$, with $r_f(e^{opp})=f(e)$.
3. Only edges like in (1) and (2) are in $A_f$.

$r_f(e)$ is called the rest-capacity of an edge in $N$.

Note: $r_f(e)>0$ for all $e\in A_f$ and $|A_f|\le 2|A|$ (since each edge becomes at most 2 new edges).

Some examples of edge-cases:

3.11 Maximal Flow in residual network

A flow $f$ in a network $N$ is a maximal flow iff. there is no directed path in the residual network $N_f$ from $s$ to $t$.
For every such flow there is an $s$-$t$-cut with $\text{val}(f)=\text{cap}(S,T)$.

WARNING! Exam Relevant: when executing the algorithm by hand, the $S$ will be all nodes reachable in the residual network, not $A$!

Proof:

• assume there is an $s$-$t$-path in $N_f$. Let $ϵ$ be the smallest residual capacity on this path (then $ϵ>0$, otherwise no path).
• then we can turn $f$ into $f^{\prime }$ by

$$f^{\prime }(e):=\{\begin{array}{ll}f(e)+ϵ& e\text{ auf }P\\ f(e)-ϵ& e^{opp}\text{ auf }P\\ f(e)& \text{ otherwise }\end{array}$$

 - by doing this $f'$ can not turn negative and always stays within capacity limits. We also respect flusserhaltung by adding / subtracting the same $\epsilon$ from each node.
 - Thus $\text{val}(f') = \text{val}(f) + \epsilon$ and $f$ could not have been maximal.

• Assume $N_f$ has no path from $s$ to $t$.
  • Let $S$ be the set of all edges reachable from directed edges $s$ in $A_f$ (note: in the residual network!).
    • We know $s\in S$, $t\notin S$ (otherwise we’d have an augmenting path). Thus $(S,T)$ is an $s$-$t$-cut.
  • For $e=(u,v)\in A$ with $u\in S$ and $v\notin S$, then there is no edge $(u,v)$ in $A_f$
    • thus $f(e)=c(e)$ otherwise there would be a residual edge and $v\in S$
  • For $e=(v,u)\in A$ with $u\in S$ and $v\notin S$, then there is no edge $(v,u)$ in $A_f$
    • thus $f(e)=0$ otherwise there would be a residual edge $(u,v)\in A_f$ and $v\in S$/.
  • thus $f(T,S)=0$
  • and by Lemma 3.8 $\text{val}(f)=f(S,T)-f(T,S)=\text{cap}(S,T)-0=\text{cap}(S,T)$.
  • Thus $f$ is maximal (as it’s bounded by the capacity of all cuts).

The following algorithm now allows us to incrementally augment the flow and find the max-flow.

\begin{algorithm} \caption{FORD-FULKERSON($V, A, c, s, t$)} \begin{algorithmic} \State f $\leftarrow$ 0 \While{$\exists s\text{-}t\text{-Pfad in } (V, A_f)$} \State Erhöhe den Fluss entlang $P$ \EndWhile \State return $f$ \end{algorithmic} \end{algorithm}

Note: Ford-Fulkerson as shows does not specify which $s$-$t$-augmenting-path to choose. In the worst-case, we could be increasing only by $1$ each time. Edmonds-Karp solves this issue by using BFS to find the shortest (by edges) augmenting-path!

• Edmonds-Karp runs ins $O(n{m}^2)$ at most.

Example of a worst case for Ford-Fulkerson:

• DFS tricked to choose s → u → v → t, then s → v → u → t (if v, u before t in the ordering)
• BFS always finds the shortest paths → i.e. directly s → v → t or s → u → t.

Runtime of Ford-Fulkerson

If the capacities in a network without opposing edges are integral and at most $U$ then there is an integral maxflow that can be found in $O(mnU)$.

It’s clear that the smaller $U$ the better the algorithm (often we can get away with $U=1$ for special cases - matching, etc…).

As long as the capacities are integral, we can augment by $ϵ=1$ at least if the flow is not maximal → this guarantees it terminates.
We have now proven maxflow-mincut.

Analysis

• $\text{val}(f)\le \text{cap}(\{s\},V\setminus \{s\}\})\le (n-1)U$ worst case. Thus there are at most $(n-1)U$ augmentations
• Each augmenting path can be found in $O(m)$ time.

Extra:

• using capacity-scaling we can show that there is an algorithm finding the maxflow in time $O(mn(1+\log U))$.
• using dynamic trees we can show the flow can be found in $O(mn\log n)$ time at most.

3.1.2.2 Bipartite Matching as a Flow Problem

(CLRS p. 732)

We can reduce the maximum bipartite matching problem onto a max-flow problem and use Ford-Fulkerson to find it.

Each node in $L$ has only $1$ incoming edge of capacity $1$, so only one outgoing edge with $f(e)=1$ can leave at most. Every node in $R$ has only one outgoing, so only $1$ incoming edge with $f(e)=1$ can exist. Thus every flow is a valid matching.

Since Ford-Fulkerson has only integral-capacity flows, an edge can either have $f(e)=1/0$. Thus a max-flow produced by FF is always a valid maximal matching.

3.15 Matching as max-flow

The size of a maximal matching in a bipartite Graph $G$ is equal to the value of a maximal flow in $N$.

Note: we can use this to prove 1.6.2 Der Satz von Hall for example.

3.1.2.3 Knoten- und kantendisjunkte Pfade

We can also model finding edge-disjoint paths in a graph as a maxflow problem.

First, we transform out graph $G$ into a network. Each undirected edge is modelled as two directed edges with capacity $1$. The source and sink both have capacity $|V|$ and have only one edge into $u$ and $v$ respectively.

The max-flow in this graph is then equal to the number of edge-disjoint paths between $u$ and $v$. This can be used to prove Menger’s Theorem.

How can we be sure every edge is only used once? Because if $f(a,b)=1$ and $f(b,a)=1$, we can simply set both to $0$, as they cancel out. This results in a flow $f^{\prime }$ with equivalent value (since no edge out of or into source/sink has been affected).

We can also do the same for internally node-disjoint paths: we split each node into $x_{\text{in}}$ and $x_{\text{out}}$ where there is only a single edge between $x_{in}\to x_{out}$. Thus we can easily see each node can only be used once.

In general to make sure a node is used only once we can split it in two with a capacity 1 edge between them. Then all incoming edges go into the first and all outgoing leave the second.

3.1.2.4 Bildsegmentierung

We can also use flows to find a min-cut, corresponding to the best fitting “image segmentation” by some criteria → foreground / background separation.

We model the problem as $s\to u$ for all $u$ pixel and $u\to t$ for all of them as well. Each pixel is then connected to their cardinal neighbours via bi-directional edges as well.

We obtain some $\alpha ,\beta ,\gamma$ for each pixel.

• Alpha is the “foreground-ness”
• beta the “background-ness”
• $\gamma$ is defined for each direction as the “probability the neighbour is also foreground/background” → influence factor.

We then define the quality $q(A,B)$ of our segmentation as follows:

$$q(A,B)=\sum _{u\in A}{\alpha }_u+\sum _{u\in B}{\beta }_u-\sum _{e\in E,|e\cap A|=1}{\gamma }_e$$

it’s the sum of all terms that tell us how “correct” each pixel’s classification is. We subtract $\gamma$ for each $e\in A\times B$ (i.e. “wrong edges”).

But we don’t know how to maximise this value → so we redefine and get a cut-minimisation problem: let $S={\sum }_{u\in V}{\alpha }_u+{\beta }_u$

$$q(A,B)=S-\sum _{u\in A}{\beta }_u-\sum _{u\in B}{\alpha }_u-\sum _{e\in E,|e\cap A|=1}{\gamma }_e$$

and minimising $q^{\prime }(A,B)={\sum }_{u\in A}{\beta }_u+{\sum }_{u\in B}{\alpha }_u+{\sum }_{e\in E,|e\cap A|=1}{\gamma }_e$ is the same as maximising $q(A,B)$.

We can see that the minimum cut minimises the quality function as well. We thus can apply a max-flow algorithm to our network and get the best segmentation.

3.1.2.5 Konvexe Mengen

Go to 3.2.2 Konvexe Hülle to read the definitions.

We can represent any network $N$ as $(e_1,e_2,\dots ,e_m)$, $m:=|A|$ for any enumeration of all edges. Then each flow $f:A\to \mathbb{R}$ can be represented as a vector $v_f:=(f(e_1),f(e_2),\dots ,f(e_m))$ in ${\mathbb{R}}^m$.
The set of all flows can be seen as a subset of ${\mathbb{R}}^m$.

3.19

The set of all flows of network with $m$ edges is a convex subset of ${\mathbb{R}}^m$.
The set of all maximal flows is also a convex subset of ${\mathbb{R}}^m$.

Note: every problem modellable as having something to do with convexity is usually solvable fast (finding global minima is easy) → same as for training neural nets.
On the other hand, finding global maxima on convex plane is NP-hard.

3.1.4 Minimale Schnitte

The MIN-CUT Problem asks for the smallest cut that makes a connected graph disconnected. We denote $\mu (G)$ the size of the min-cut on this graph.

Note that the graph is a multigraph → to use existing flow modelling, we turn any parallel edges into an edge with $c(e)=$ # of parallel edges.

We can use the maxflow-mincut theorem to find a min-cut between $u$ and $v$ in $O(mn\log n)$. If we want to find the min-cut over an entire graph, we can simply repeat the algorithm $\left(\genfrac{}{}{0ex}{}{n}{2}\right)$ times for any pair of vertices $u,v$ and get the min-cut.
As $m\le n^2$ this gives a total of $O(n^2\cdot n^3\log n)$ runtime.
We can do better by observing that we only need to fix a source $s$ and check all $t$ for $O(n^4\log n)$ total runtime.

• we only need to fix the source as there is no partition of $V$ such that all $s,t$ are on one side (i.e. a cut we haven’t checked) without $A=\varnothing$.

We can do better however, by using a probabilistic method that utilises edge contraction.

Now notice that this reduces the number of cuts that exist in the graph, i.e. it removes the cuts that contain the contracted edge $e$.

Let $C$ be a min-cut, i.e. $|C|=\mu (G)$. This bijection means that if we contract $e\notin C$, $\mu (G)=\mu (G\setminus e)$.

3.20 Contraction preserves cuts

Let $G$ be a graph and $e$ an edge. Then

$$\mu (G\setminus E)\ge \mu (G)$$

holds for all $e$.
If there is a min-cut $C$ s.t. $e\notin C$, then $\mu (G\setminus e)=\mu (G)$.

Note that this holds since any cuts $C$ with $e\notin C$ are preserved (subset). And $G\setminus e$ doesn’t get new cuts (as it has less edges). Thus $\text{cuts in }G\setminus e\subseteq \text{cuts in }G$ and thus the min can only be bigger in $G\setminus e$.

Just choose any $e$: A priori there is no fast way of choosing an $e\notin C$ without knowing $C$, so we’ll just choose a random edge.

\begin{algorithm} \caption{$\text{Cut}(G)$ - $G$ zusammenhängender Multigraph} \begin{algorithmic} \State{$G' \leftarrow G$} \WHILE{$|V(G)| > 2$} \STATE $e \gets$ gleichverteilt zufällige Kante in $G$ \STATE $G \gets G/e$ \ENDWHILE \RETURN Grösse des eindeutigen Schnitts in $G$ \end{algorithmic} \end{algorithm}

We suppose we can contract and choose a random edge both in $O(n)$. Then CUT(G) can be implemented in $O(n^2)$.
The output will never be smaller as $\mu (G)$. As long as we’re lucky, we get $\mu (G)$. But how lucky?

3.21 Probability of success

Let $G=(V,E)$, $n:=|V|$. For $e$ chosen randomly we have

$$\mathrm{Pr}[\mu (G)=\mu (G\setminus e)]\ge 1-\frac{2}{n}$$

Proof:

Note that $\mathrm{Pr}[\mu (G)=\mu (G\setminus e)]\ge \mathrm{Pr}[e\notin C]$ as $C$ is fixed. There might be another min-cut which does not contain $e$ and $\mu (G\setminus e)$ does not in fact increase. Thus bigger equals.

Now probability over entire execution:
Let $\hat{p}(G):=$ probability that CUT(G) outputs $\mu (G)$. And let $\hat{p}(n)={\inf }_{G=(V,E):|V|=n}\hat{p}(G)$ (infimum instead of minimum because there is an infinite amount of multigraphs of size $n$).

3.22

$$\hat{p}(n)\ge \left(1-\frac{2}{n}\right)\cdot \hat{p}(n-1)$$

Proof:

If we recursively insert the definition, this gives us a telescoping sum:

$$\hat{p}(n)\ge \frac{n-2}{n}\cdot \frac{n-3}{n-1}\cdot \frac{n-4}{n-3}\dots \frac{3}{5}\cdot \frac{2}{4}\cdot \frac{1}{3}\cdot \hat{p}(2)\ge \frac{2}{n(n-1)}$$

3.23

Es gilt $\hat{p}(n)\ge \frac{2}{n(n-1)}=\frac{1}{\left(\genfrac{}{}{0ex}{}{n}{2}\right)}$

Thus CUT(G) is a Monte-Carlo algorithm with probability of success $\mathrm{Pr}[A(I)=\mu (G)]\ge 1/\left(\genfrac{}{}{0ex}{}{n}{2}\right)=ϵ$.

3.24 Repeat

We repeat the algorithm $\lambda \left(\genfrac{}{}{0ex}{}{n}{2}\right)$ times.

1. runtime $O(\lambda (\genfrac{}{}{0ex}{}{n}{2})n^2)$
2. probability of success $1-e^{-\lambda }$.

We choose $N=\lambda {ϵ}^{-1}$. Then

$$\mathrm{Pr}[A_N(I)=\mu (G)]\ge (1-ϵ{)}^N=(e^{-ϵ}{)}^N=e^{-ϵ\cdot {ϵ}^{-1}\lambda }=e^{-\lambda }$$

using familiar rules. And because ${ϵ}^{-1}=\left(\genfrac{}{}{0ex}{}{n}{2}\right)$ we get the above value.

Now for $\lambda =\log n$ we get probability of success $1/n$ and runtime $O(n^4\log n)$. We already had this before, even without failure, so what did we gain???

Bootstrapping: Because for small values of $n$ our algorithm is so bad (for $n=3$ we have $1/3$ chance picking the right edge), we can consider cutting off early at $|V|<t$ and continue using our deterministic algorithm.
Or we choose to put our own probabilistic algo into itself, and reuse it internally with $\lambda =1$ repetitions.

• how is this different than just continuing? instead of picking an edge at random, we run CUT(G') $\lambda =1$, so $N=\left(\genfrac{}{}{0ex}{}{n}{2}\right)$ for all possible pairs of contractions left.
• and $\mathbb{E}[A(I)=\mu (G)]=\left(\genfrac{}{}{0ex}{}{n}{2}\right)$ so we expect to get the actual min-cut for the graph of size $n=t$ back.

Then we get $O(n^3)$ runtime for the same expected error probability:

Now we can generalise this result. For an algorithm with runtime $O(n^c)$ we already have, we can insert it and get one with runtime $O(n^{4-4/c})$:

Finally, using this $c\leftarrow 4-4/c^{\prime }$ reduction process, we can derive an explicit formula for $k$ insertions: $O(n^{2+2/k})$.

3.2 Geometrische Algorithmen

3.2.1 Kleinster umschließender Kreis

We want to find the smallest circle $C(P)$ such that all points $P$ are inside it. (We will assume the proof of existence for such a circle.)

3.25 Uniqueness

For every finite set of points $P$ in ${\mathbb{R}}^2$ there is a unique (eindeutig) smallest enclosing circle $C(P)$.

Assume there are two WLOG such that $P\subseteq C_1^{\bullet }$ and $P\subseteq C_2^{\bullet }$. Thus $P\subseteq C_1^{\bullet }\cap C_2^{\bullet }$. We can then create a new smaller circle from the midpoint of both centers.

3.26 3 Points suffice

For every finite set of points $P$ with $|P|\ge 3$ there is a subset $Q\subseteq P$ s.t. $|Q|=3$ and $C(Q)=C(P)$.

This follows from the fact that there is no arc through the middle for which all points are on one side only.

If there was, we could create a new smaller enclosing circle → contradiction:

Let $B$ be the set of points on the circle. If there’s two points exactly opposed, we can just take any random third. If there’s more than $3$, take $p,q$ and then any except the points in the smaller of the two arcs (as illustrated above).

Algorithm 1: From this we can immediately derive an $O(n^4)$ algorithm.

\begin{algorithm} \caption{CompleteEnumeration} \begin{algorithmic} \PROCEDURE{CompleteEnumeration}{$P$} \FORALL{$Q \in \binom{P}{3}$} \STATE bestimme $C(Q)$ \IF{$P \subseteq C^{\bullet}(Q)$} \RETURN $C(Q)$ \ENDIF \ENDFOR \ENDPROCEDURE \end{algorithmic} \end{algorithm}

We iterate through all subsets of size $3$ in $O(n^3)$ and check for enclosing in $O(n)$. Note that this works since $C(Q) \le C(P)$ since $Q \subseteq P$!

Note: We can make this $O(n^3)$ by instead iterating over all and taking the largest. This works because there $|Q|=3$ s.t. $C(Q)=C(P)$ always exists.

Algorithm 2 (randomised) We can also randomise this.

\begin{algorithm} \caption{RandomisedPrimitiveVersion} \begin{algorithmic} \PROCEDURE{RandomisedPrimitiveVersion}{$P$} \WHILE{\TRUE} \STATE wähle $Q \subseteq P$ mit $|Q| = 3$ zufällig und gleichverteilt \STATE bestimme $C(Q)$ \IF{$P \subseteq C^{\bullet}(Q)$} \RETURN $C(Q)$ \ENDIF \ENDWHILE \ENDPROCEDURE \end{algorithmic} \end{algorithm}

This is still $O(n^4)$ since worst case there is exactly one unique $|Q| = 3$. Then we need to iterate over *all* subsets of size $3$ of $P$. The $\E[\text{draw } Q] = \binom{n}{3}$ as it's geometrically distributed with $p = 1/\binom{n}{3}$.

First idea: maybe we could draw more than only $3$ points? This does not change the runtime of the algorithm in the worst-case however.

Algorithm 3 (randomised) Instead, we increase the chance of points outside $C(Q)$ being drawn.

• Las Vegas
  • runtime is ZV as we have to be lucky to draw the right set of points
  • but we can easily verify if correct (check all points) → always right answer

\begin{algorithm} \caption{RandomisedCleverVersion} \begin{algorithmic} \PROCEDURE{RandomisedCleverVersion}{$P$} \STATE $P' \gets P$ \WHILE{\TRUE} \STATE wähle $Q \subseteq P'$ mit $|Q| = 11$ zufällig und gleichverteilt \STATE bestimme $C(Q)$ \IF{$P \subseteq C^{\bullet}(Q)$} \RETURN $C(Q)$ \ELSE \STATE verdopple alle Punkte von $P'$ ausserhalb von $C(Q)$ \ENDIF \ENDWHILE \ENDPROCEDURE \end{algorithmic} \end{algorithm}

*Verdoppeln* here means that we double the probability of those points being chosen. We can implement this with a `nums[i]` array which stores the "weights" of each point. Using a prefix-sum array and binary search we can then find a point in $O(n)$.

3.28

Let $P$ be a set of $n$ (not necessarily different) points and for $r\in \mathbb{N}$ uniformly chosen from $\left(\genfrac{}{}{0ex}{}{P}{r}\right)$. Then the expected number of points in $P$ that are outside of $C(R)$ is at most $3\frac{n-r}{r+1}\le 3\frac{n}{r+1}$

Proof: We define two helper functions

• $\text{out}(p,R)$ which is $1$ if $p\notin C^{\bullet }(R)$
• $\text{essential}(p,Q)$ which is $1$ if $C(Q\setminus \{p\})\ne C(Q)$.
  We can easily see that $\text{out}(p,R)=1⟺\text{ess}(p,R\cup \{p\})=1$ (if it’s outside, it makes the circle bigger).
  

We also have (let $P^{\prime }$ be the set of points, including duplicates)

$$\sum _{s\in P^{\prime }\setminus R}\text{out}(s,R)=|P^{\prime }\setminus C^{\bullet }(R)|$$

and

$$\sum _{s\in Q}\text{ess}(s,Q)\le 3$$

(as we have seen we only need $3$ points to define a circle at most).

Then let $X$ be a ZV counting the number of points outside the circle

$$\begin{array}{rl}\mathbb{E}[X]& =\frac{1}{\left(\genfrac{}{}{0ex}{}{n}{r}\right)}\sum _{R\in \left(\genfrac{}{}{0ex}{}{P}{r}\right)}\sum _{s\in P\setminus R}\text{out}(s,R)\\ & =\frac{1}{\left(\genfrac{}{}{0ex}{}{n}{r}\right)}\sum _{R\in \left(\genfrac{}{}{0ex}{}{P}{r}\right)}\sum _{s\in P\setminus R}\text{essential}(s,R)\\ & =\frac{1}{\left(\genfrac{}{}{0ex}{}{n}{r}\right)}\sum _{Q\in \left(\genfrac{}{}{0ex}{}{P}{r+1}\right)}\sum _{p\in Q}\text{essential}(p,Q)(\ast )\\ & =\frac{1}{\left(\genfrac{}{}{0ex}{}{n}{r}\right)}\sum _{Q\in \left(\genfrac{}{}{0ex}{}{P}{r+1}\right)}3=3\cdot \frac{\left(\genfrac{}{}{0ex}{}{n}{r+1}\right)}{\left(\genfrac{}{}{0ex}{}{n}{r}\right)}=3\frac{n-r}{r+1}(\ast \ast )\end{array}$$

(*) follows from the fact that trying all points outside $R$ is the same as including one more in $R$ and then picking one inside.
(**) follows from our Lemma that there are at most $3$ essential points.

Why do we need this? We can now calculate the number of points that are expected to be doubled each iteration.

3.29

This algorithm calculates the smallest enclosing circle in expected time $O(n\log n)$.

Proof Each round takes $O(n)$. How many rounds? (This is the sampling Lemma)

Note $T\ge k$ means that there are still rounds left to do. Thus $X_k\ge 2^{k/3}$, as at least one of the points in $Q$ must have been doubled.

Note: we ignore the second term in $\mathbb{E}[X_k]$ and simply put lower bound $\ge 0$ in there.

Now we can estimate the number of repetitions:

(Aside) Sampling Lemma

We can make the observations from the previous algorithm more abstract.
For any problem statement with a set $S$ and a function $\varphi :2^S\to \text{anything}$ (where $2^S$ is subsets of $S$), we can define:

$$\begin{array}{rl}V(R)& =\{s\in S\mid \varphi (R\cup \{s\})\ne \varphi (R)\}\\ X(R)& =\{s\in R\mid \varphi (R\setminus \{s\})\ne \varphi (R)\}\end{array}$$

which are the abstract equivalents of “out” and “essential” from before.

3.31 Sampling Lemma

Let $k\in \mathbb{N}$, $0\le k\le n$. Let $x_k:=\mathbb{E}[|X(R)|]$ and $v_k:=\mathbb{E}[|V(R)|]$ with $R$ a $k$-element subset of $S$, uniformly chosen.
Then for $0\le r<n$

$$\frac{v_r}{n-r}=\frac{x_{r+1}}{r+1}$$

From which we can derive the conclusion we came to for the smallest enclosing circle (chose $r=11$, $x_r\le 3$).

Proof: this can be proven using a bipartite graph $\left(\genfrac{}{}{0ex}{}{S}{r}\right)\cup \left(\genfrac{}{}{0ex}{}{S}{r+1}\right)$ with edges $\{R,R\cup \{s\}\}$ for $R\in \left(\genfrac{}{}{0ex}{}{S}{r}\right)$ if $s\in V(R)$ (i.e. $s$ verletzt $R$).

• thus the degree of node $R$ is $|V(R)|$ and there are exactly $\left(\genfrac{}{}{0ex}{}{n}{r}\right)v_r$ edges in the graph
• using the equivalence “out” ⇐> “ess” we proved before, we can switch to seeing the edges as $\{Q\setminus \{s\},Q\}$ and $s$ extreme in $Q$, i.e. $s\in X(Q)$
  • then the degree of each node $Q\in \left(\genfrac{}{}{0ex}{}{S}{r+1}\right)$ is exactly $|X(R)|$.
  • the number of edges is $\left(\genfrac{}{}{0ex}{}{n}{r+1}\right)x_k$.
    Therefore $|E|=\left(\genfrac{}{}{0ex}{}{n}{r+1}\right)x_k=\left(\genfrac{}{}{0ex}{}{n}{r}\right)v_r$ → we can derive the lemma equality from this.

3.2.2 Konvexe Hülle

The convex hull problem is similar to the problem of the smallest enclosing circle, but only with a polygon instead of a circle.

3.33 Convex Hull

Let $S\subseteq {\mathbb{R}}^d$, $d\in \mathbb{N}$. The convex hull $\text{conv}(S)$ of $S$ is the intersection of all convex sets containing $S$:

$$\text{conv}(S):=\bigcap _{\begin{array}{c}S\subseteq C\subseteq {\mathbb{R}}^d\\ C\text{ convex}\end{array}}C$$

Note: we can alternatively define it as:

• the cut of all “half-planes” (halbebene), die $S$ enthalten
• the smallest convex set that contains $S$

A few definitions from the flow section again:

Line segment

For $v_0,v_1\in {\mathbb{R}}^d$ let

$$\overline{v_0{v}_1}:=\{(1-\lambda )v_0+\lambda v_1\mid \lambda \in \mathbb{R},0\le \lambda \le 1\}$$

be the connecting line segment.

Convex set

A set $C\subseteq {\mathbb{R}}^d$ is called convex if

$$\forall v_0,v_1\in C:\overline{v_0{v}_1}\subseteq C$$

The ConvexHull problem asks to find the smallest enclosing polygon conv(P) for a finite set of points $P\in {\mathbb{R}}^2$. The output will be a set of points $(q_0,q_1,\dots ,q_n)$ in counterclockwise order.

For our problem, we’ll assume a few simplifications for easier proofs:

• finite set of points $P,|P|\ge 3$.
• $P$ is in “allgemeiner Lage” so no 3 points aligned and no 2 points share an $x$ coordinate.
  we’ll discuss how to get rid of them later.

A key notion is the Randkante (boundary edge):

• an ordered pair $qr$ with $q,r\in P$, $q\ne r$, is a boundary edge of $P$ if all points of $P\setminus \{q,r\}$ lie left of $qr$
  • i.e. on the left side of the directed line through $q$ and $r$, oriented from $q$ to $r$.

3.34 Boundary-Edge Characterization

$(q_0,q_1,\dots ,q_{h-1})$ is the counterclockwise corner sequence of the polygon enclosing $\text{conv}(P)$ if and only if all pairs $(q_{i-1},q_i)$, $i=1,\dots ,h$, are boundary edges of $P$.

The geometric primitive “is $p$ left or right of $qr$?” is answered by a determinant.

3.35 Orientation Test

Let $p=(p_x,p_y)$, $q=(q_x,q_y)$, $r=(r_x,r_y)$ in ${\mathbb{R}}^2$. Then $q\ne r$ and $p$ lies left of $qr$ if and only if

$$\det (p,q,r):=\left|\begin{array}{ccc}{p}_x& p_y& 1\\ q_x& q_y& 1\\ r_x& r_y& 1\end{array}\right|=\left|\begin{array}{cc}{q}_x-p_x& q_y-p_y\\ r_x-p_x& r_y-p_y\end{array}\right|>0$$ $$⟺(q_x-p_x)(r_y-p_y)>(q_y-p_y)(r_x-p_x).$$

More precisely, $\frac{1}{2}|\det (p,q,r)|$ is the area of the triangle $pqr$:

• $\det (p,q,r)>0$ this happens counterclockwise (the positive, “normal” orientation in mathematics) and $p$ is left of $qr$.
  • if $<0$, it’s flipped.
• $\det (p,q,r)=0$ the three points are collinear — which includes the degenerate cases where two of them, or all three, coincide.

First naive Algorithm $O(n^3)$.
Iterate through all $(p,q)\in \left(\genfrac{}{}{0ex}{}{P}{2}\right)$ and check if it’s a Randkante by checking for all other points if they’re on the left.
This takes $O(n^2)$ for finding all pairs and $O(n)$ to check if all points are on the left.

3.2.2.1 Jarvis’ Wrap

Second Approach (Jarvis’ Wrap): $O(nh)$, $h$ number of Randkanten of the hull.

We can improve the brute-force approach by instead “wrapping” around the hull. We start with the lowest point (for sure a corner point) and find the next on the corner iteratively, until we’ve gone around.

$q_0:=$ point with smallest x-coord in $P$ (for sure part of the hull)
we start with $q_0$:

\begin{algorithm} \caption{FindNext} \begin{algorithmic} \REQUIRE $q \in P$ is a corner of $\text{conv}(P)$ \STATE choose $p_0 \in P \setminus \{q\}$ arbitrary \STATE $q_{\text{next}} \gets p_0$ \FORALL{$p \in P \setminus \{q, p_0\}$} \IF{$p$ lies right of $q\,q_{\text{next}}$} \STATE $q_{\text{next}} \gets p$ \ENDIF \ENDFOR \RETURN $q_{\text{next}}$ \end{algorithmic} \end{algorithm}

Why does this work? The procedure mirrors finding the minimum of a set of numbers. Given $q\in P$, define a relation ${\prec }_q$ on $P\setminus \{q\}$ by

$$p_1{\prec }_q{p}_2:⟺p_1\text{ lies right of }q{p}_2.$$

3.36 FindNext Correctness

If $q$ is a corner of the convex hull of $P$, then ${\prec }_q$ is a total order on $P\setminus \{q\}$. For the minimum $p_{\min }$ of this order, $q{p}_{\min }$ is a boundary edge.

The essential property coming from ”$q$ is a corner of $\text{conv}(P)$” is that there exists a line separating $q$ from $P\setminus \{q\}$.

• If no such line exists, ${\prec }_q$ is cyclic → definitely not a total order

This gives us the following algorithm. Since we’re sure to start on a corner and only advance if we found another corner, we never get a degenerate case:

\begin{algorithm} \caption{JarvisWrap} \begin{algorithmic} \STATE $h \gets 0$ \STATE $p_{\text{now}} \gets$ point in $P$ with smallest $x$-coordinate \REPEAT \STATE $q_h \gets p_{\text{now}}$ \STATE $p_{\text{now}} \gets \text{FindNext}(q_h)$ \STATE $h \gets h + 1$ \UNTIL{$p_{\text{now}} = q_0$} \RETURN $(q_0, q_1, \ldots, q_{h-1})$ \end{algorithmic} \end{algorithm}

When running, this looks as follows:

Each call to $\text{FindNext}$ takes $O(n)$ time, and we call it exactly $h$ times, once for each corner.

Jarvis' Wrap Running Time

Given a set $P$ of $n$ points in general position in ${\mathbb{R}}^2$, the algorithm $\text{JarvisWrap}$ computes the convex hull in time $O(nh)$, where $h$ is the number of corners of the convex hull of $P$.

This is very fast when $h$ is small (e.g. if the hull is a triangle the algorithm is linear), and in the worst case $h=n$ it still improves the first $O(n^3)$ bound to $O(n^2)$.

What about without the initial simplifying assumptions?

1. if there can be multiple points with same $x$-coord, choose the one with smallest $y$ from them (lexicographic) to start on
2. The test ”$p$ right of $q,q_{\text{next}}$” must be replaced by
   1. ”$p$ right of $q,q_{\text{next}}$” OR ”$p$ on the line through $q,q_{\text{next}}$ and $|qp|>|q{q}_{\text{next}}|$.
3. if we get $P$ as an array with duplicates, we need to make sure to not check the same point against itself.

If we implement this on a computer using floating point, we might run into some issues:

• accidentally make a slightly smaller hull, because of imprecisions
• we might run around the “starting point” because of imprecisions or because the starting point exists multiple times and never terminate
  

3.2.2.2 Local Improvements

Begin with a polygon $(r_0,r_1,\dots ,r_{k-1})$ with corners from $P$ and successively “correct” it whenever we spot a “concavity”.

• If sequence bounds a convex set counterclockwise:
  • $r_i$ must lie right of $r_{i-1}{r}_{i+1}$ for all $i=0,1,\dots ,k-1$
  • Whenever $r_i$ lies left of $r_{i-1}{r}_{i+1}$, we remove $r_i$ from the sequence, repeating until no such defect remains “Verbesserungsschritt”

Note: the absence of a defect does not guarantee we have found the correct polygon → see this example of a locally convex polygon that is not a hull.

• do not even know if the polygon encloses $P$
• even if every point of $P$ appears in the sequence → might have a closed, locally convex polygonal chain that self-intersects (see above)

Improvement Step ( Verbesserungsschritt)

An improvement step is the operation in which, for three consecutive points $p,p^{\prime },p^{\prime \prime }$, we find that $p^{\prime }$ lies left of $p{p}^{\prime \prime }$ and therefore remove $p^{\prime }$ from the sequence.

In practice, this looks like the following:

Algorithm Idea:

First sort $P$ ascending by $x$-coordinate; let $(p_1,p_2,\dots ,p_n)$ be the resulting order. Consider the polygon $(p_1, p_2, \ldots, p_{n-1}, p_n, p_{n-1}, \ldots, p_2):

We walk through $P$ once left to right and then back right to left.

• polygon has $2(n-1)$ directed edges.
• Local repair never removes $p_1$ or $p_n$
• at every moment the sequence splits into
  • an $x$-monotone part running from $p_1$ to $p_n$ (x increasing)
  • second part running from $p_n$ back to $p_1$

Note: If we keep the old edges in the drawing, we obtain at the end a Triangulierung (triangulation) of the point set $P$.

\begin{algorithm} \caption{LocalRepair --- incremental convex hull} \begin{algorithmic} \REQUIRE $(p_1, p_2, \ldots, p_n)$, $n \geq 3$, sorted by $x$-coordinate \STATE $q_0 \gets p_1$ \STATE $h \gets 0$ \FOR{$i \gets 2$ \TO $n$} \COMMENT{lower hull, left to right} \WHILE{$h > 0$ \AND $q_h$ lies left of $q_{h-1}\,p_i$} \STATE $h \gets h - 1$ \ENDWHILE \STATE $h \gets h + 1$ \STATE $q_h \gets p_i$ \COMMENT{$(q_0, \ldots, q_h)$ = lower hull of $\{p_1, \ldots, p_i\}$} \ENDFOR \STATE $h' \gets h$ \FOR{$i \gets n-1$ \DOWNTO $1$} \COMMENT{upper hull, right to left} \WHILE{$h > h'$ \AND $q_h$ lies left of $q_{h-1}\,p_i$} \STATE $h \gets h - 1$ \ENDWHILE \STATE $h \gets h + 1$ \STATE $q_h \gets p_i$ \ENDFOR \RETURN $(q_0, q_1, \ldots, q_{h-1})$ \COMMENT{hull corners, counterclockwise} \end{algorithmic} \end{algorithm}

We start with a polygon with $2(n-1)$ corners → finish with $h$ corners.

• Each successful test ”$h>0$ and $q_h$ left of $q_{h-1}{p}_i$” creates new triangle
  • we know there are exactly $2n-2-h$ of these
• there is exactly one unsuccessful test per new $p_i$, $i=2,3,\dots ,n$ in the lower hull and per new $p_i$, $i=n-1,n-2,\dots ,1$ in the upper hull
  • giving an extra $2(n-1)$ tests.
    In total $4n-4-h$ tests → $O(n)$!

LocalRepair Running Time

Given a sequence $p_1,p_2,\dots ,p_n$ of points in general position in ${\mathbb{R}}^2$, sorted by $x$-coordinate, the algorithm $\text{LocalRepair}$ computes the convex hull of $\{p_1,p_2,\dots ,p_n\}$ in time $O(n)$.

Including sort → $O(n\log n)$ algorithm = asymptotically faster than $\text{JarvisWrap}$ unless $h=o(\log n)$.

It is also relatively easy to handle points of equal $x$-coordinate (sort lexicographically) and collinearities (repetitions can be removed after sorting)

• And Numerical inaccuracies cannot cause an infinite loop.

Can we do better? A sorting lower bound

We can reduce sorting onto the convex hull problem. Given a sequence $(x_1,x_2,\dots ,x_n)$ of reals, set $p_i=(x_i,x_i^2)$ for $i=1,2,\dots ,n$.

• embed the $x_i$ on the $x$-axis in ${\mathbb{R}}^2$ and project them vertically onto the unit parabola $y=x^2$.

Computing the convex hull of $P:=\{p_1,\dots ,p_n\}$ in our sense (sorted sequence of hull corners) yields (in linear time) the ascending order of the $x_i$.

Thus: if convex hull can be computed in $t(n)$, then sorting can be done in $t(n)+O(n)$ time → contradiction with known lower bound of $\Omega (n\log n)$ for sorting.

3.2.2.3 Triangulation (Extra)

3.38 Plane Graph

A graph $G=(P,E)$ on $P$ is called eben (plane) if the segments $pq:=\text{conv}(\{p,q\})$ of the edges $\{p,q\}\in E$ intersect at most in their common endpoints.

3.38 Gebiete

Removing the segments $pq$, $\{p,q\}\in E$, from ${\mathbb{R}}^2$ yields connected regions, the Gebiete (regions) of $G$. The bounded regions are the inner regions; the unbounded (infinite) region is the outer region.

3.38 Triangulation

A graph $T=(P,E)$ on $P$ is a triangulation of $P$ if $T$ is plane and maximal with this property,

Note: maximal means any edge from $\left(\genfrac{}{}{0ex}{}{P}{2}\right)\setminus E$ to $T$ violates planarity.

The regions of a plane graph $G$ on $P$ are all bounded except exactly one (the outer region).

• The inner regions of a triangulation are all triangles
  • This is because any other polygon could be subdivided further
• the single outer region is the complement of $\text{conv}(P)$ in ${\mathbb{R}}^2$ and borders precisely the boundary edges of $P$.

3.39 Triangulation Counts from Local Repair

Let $h$ be the number of corners of the convex hull of $P$. The local repair process makes exactly $2n-2-h$ improvement steps and produces a triangulation with $2n-2-h$ inner triangles and $3n-3-h$ edges.

Proof:

• (i) Number of steps:
  • We start with a polygon having $2n-2$ directed edges.
    • Each improvement step replaces two old directed edges by one new one, i.e. removes exactly one directed edge.
  • Since we end with $h$ directed edges, we run exactly $2n-2-h$ steps.
• (ii) Number of triangles:
  • We start with $0$ triangles, and each improvement step creates one new triangle. Over $2n-2-h$ steps we obtain exactly $2n-2-h$ triangles.
• (iii) Number of undirected edges:
  • We start with $n-1$ undirected edges (counting each edge once, not twice for its two directions)
  • add one edge per step, so we end with $(n-1)+(2n-2-h)$ $=3n-3-h$ edges.
• (iii${}^{\prime }$) Edge count, alternatively:
  • Each of the $2n-2-h$ triangles has three edges which each border two triangles (except for the $h$ boundary edges, so we add extra $+h$)
• Counting also the outer region ${\mathbb{R}}^2\setminus \text{conv}(P)$ with its $h$ edges, every edge is counted exactly twice. Hence the number of edges is

$$\frac{1}{2}(\underset{\text{triangles}}{\underbrace{3(2n-2-h)}}+\underset{\text{outer region}}{\underbrace{h}})=3n-3-h.$$

The Euler relation lets us extend these counts to all triangulations, not just those from local repair.

Euler Relation

Let $G=(P,E)$ be a plane graph on $P$ with $v:=|P|$ vertices, $e:=|E|$ edges, $f$ regions (including the outer region), and $c$ connected components. Then

$$v-e+f=1+c.\text{\hspace{1em}(3.4)}$$

Proof: we prove by “reverse induction”??

• The claim holds when $E=\varnothing$: then there are $v$ connected components and exactly one region, so $v-e+f=v-0+1$ and $1+c=1+v$, both equal to $v+1$.
• Assume $E\ne \varnothing$
  • remove an edge $g\in E$, giving $G^{\prime }:=(P,E\setminus \{g\})$, which is again plane.
  • Our goal is to show that the validity of (3.4) is unaffected by this operation:

Let $v^{\prime },e^{\prime },f^{\prime },c^{\prime }$ be the values corresponding to $v,e,f,c$ for $G^{\prime }$. We want to prove

$$v^{\prime }-e^{\prime }+f^{\prime }-(1+c^{\prime })=v-e+f-(1+c)$$

Certainly $v^{\prime }=v$ and $e^{\prime }=e-1$.

• What happens to $f^{\prime }$ and $c^{\prime }$?
• We do not choose $g$ arbitrarily:
  • if possible, let $g$ lie on a cycle in $G$;
  • if not, all connected components are trees and we choose $g$ incident to a degree-$1$ vertex (a leaf)
    • → possible since $E\ne \varnothing$, because every nonempty tree has at least two leaves.

Case 1: $g$ lies on a cycle in $G$.
The number of connected components is unchanged, $c^{\prime }=c$.
The cycle separates the two sides of $g$, so $g$ borders two different regions of $G$, which merge into one region in $G^{\prime }$
Thus $f^{\prime }=f-1$. Then (3.5) follows, since

$$v^{\prime }-e^{\prime }+f^{\prime }-(1+c^{\prime })=v-(e-1)+(f-1)-(1+c)$$

Case 2: $g$ is incident to a degree-$1$ vertex $p$ in $G$.
Then $c^{\prime }=c+1$. The two sides of $g$ border the same region of $G$, because we can travel from one side of the segment $g$ along $g$ and around $p$ to the other side without crossing any edge of $G$
Thus $f^{\prime }=f$. Then (3.5) follows easily.

By successively removing edges, (3.4) holds for $G$ if and only if it holds for the empty graph $(P,\varnothing )$ → which we already verified.

3.41 Edge and Region Counts for Plane Graphs

Let $P$ be a set of $n\ge 3$ points in general position in ${\mathbb{R}}^2$, and let $h$ be the number of edges of $\text{conv}(P)$.

1. Every triangulation $T$ of $P$ has exactly $3n-3-h$ edges and exactly $2n-2-h$ inner regions.
2. Every plane graph $G$ on $P$ has at most $3n-3-h\le 3n-6$ edges and at most $2n-2-h\le 2n-5$ inner regions.

Proof:

• (i) Let $f$ be the number of regions of $T$. Then $f-1$ of them are inner regions (triangles), and the outer region borders $h$ edges. So the number of edges is $\frac{1}{2}(3(f-1)+h)$. Since $T$ is connected, (3.4) gives

$$n-\frac{1}{2}(3(f-1)+h)+f=2⟺f=2n-1-h,$$

• so the number of inner regions is $f-1=2n-2-h$. The edge count then follows:

$$\frac{1}{2}(3(f-1)+h)=\frac{1}{2}(3(2n-1-h-1)+h)=3n-3-h.$$

Moreover, $n\ge 3$ and general position force $h\ge 3$.

• (ii) The bounds for $G$ follow because triangulations are maximal plane graphs
  • adding edges to a plane graph only increases the edge count
  • also never decreases the number of regions
    Thus triangulations are sparse, with $O(n)$ edges.

These definitions generalise in graph theory: a graph is planar if it can be drawn in the plane (edges realised as curves joining their endpoints) so that no two edges cross.