Mark/handouts
1
0
Fork 0
Code Pull Requests 2 Actions Packages Releases Activity

Added Graph Algorithms handout

Browse Source
This commit is contained in:
Mark
2022-11-13 13:03:14 -08:00
parent 12c677f2da
commit b93b574c3f
5 changed files with 981 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

180
Advanced/Graph Algorithms/main.tex Executable file
View File

@ -0,0 +1,180 @@
% https://git.betalupi.com/Mark/latex-packages
% use [nosolutions] flag to hide solutions.
% use [solutions] flag to show solutions.
% Last built with version 1.1.0
\documentclass[
solutions
]{ormc_handout}
\usepackage{subfiles}
\usetikzlibrary{arrows.meta}
\usetikzlibrary{shapes.geometric}
% We put nodes in a separate layer, so we can
% slightly overlap with paths for a perfect fit
\pgfdeclarelayer{nodes}
\pgfdeclarelayer{path}
\pgfsetlayers{main,nodes}
% Layer settings
\tikzset{
% Layer hack, lets us write
% later = * in scopes.
layer/.style = {
execute at begin scope={\pgfonlayer{#1}},
execute at end scope={\endpgfonlayer}
},
%
% Arrowhead tweaks
>={Latex[ width=2mm, length=2mm ]},
label/.style = {
circle,
% For automatic red background in solutions
fill = \ORMCbgcolor,
draw = none
},
%
% Nodes
main/.style = {
draw,
circle,
fill = white
},
%
% Flow annotations
flow/.style = {
opacity = 1,
thin,
inner xsep = 2.5mm,
inner ysep = 2.5mm
},
%
% Paths
path/.style = {
line width = 4mm,
draw = black,
% Lengthen paths so they're
% completely under nodes.
line cap = rect,
opacity = 0.3
}
}
\begin{document}
\maketitle
<Advanced 2>
<Fall 2022>
{Algorithms on Graphs: Flow}
<Part 1: Flow>
{
Prepared by Mark on \today
}
\subfile{parts/00 review}
\subfile{parts/01 flow}
\subfile{parts/02 residual}
\subfile{parts/03 fulkerson}
\problem{Maximum Cardinality Matching}
A \textit{matching} is a subset of edges in a bipartite graph. Nodes in a matching must not have more than one edge connected to them. \\
A matching is \textit{maximal} if it has more edges than any other matching.
\vspace{5mm}
\begin{minipage}[t]{0.48\textwidth}
\begin{center}
Initial Graph \\
\vspace{2mm}
\begin{tikzpicture}
% Nodes
\begin{scope}[layer = nodes]
\node[main] (A1) at (0mm, 24mm) {};
\node[main] (A2) at (0mm, 18mm) {};
\node[main] (A3) at (0mm, 12mm) {};
\node[main] (A4) at (0mm, 6mm) {};
\node[main] (A5) at (0mm, 0mm) {};
\node[main] (B1) at (20mm, 24mm) {};
\node[main] (B2) at (20mm, 18mm) {};
\node[main] (B3) at (20mm, 12mm) {};
\node[main] (B4) at (20mm, 6mm) {};
\node[main] (B5) at (20mm, 0mm) {};
\end{scope}
% Edges
\draw
(A1) edge (B2)
(A1) edge (B3)
(A2) edge (B1)
(A2) edge (B4)
(A4) edge (B3)
(A2) edge (B3)
(A5) edge (B3)
(A5) edge (B4)
;
\end{tikzpicture}
\end{center}
\end{minipage}
\hfill
\begin{minipage}[t]{0.48\textwidth}
\begin{center}
Maximal Matching \\
\vspace{2mm}
\begin{tikzpicture}
% Nodes
\begin{scope}[layer = nodes]
\node[main] (A1) at (0mm, 24mm) {};
\node[main] (A2) at (0mm, 18mm) {};
\node[main] (A3) at (0mm, 12mm) {};
\node[main] (A4) at (0mm, 6mm) {};
\node[main] (A5) at (0mm, 0mm) {};
\node[main] (B1) at (20mm, 24mm) {};
\node[main] (B2) at (20mm, 18mm) {};
\node[main] (B3) at (20mm, 12mm) {};
\node[main] (B4) at (20mm, 6mm) {};
\node[main] (B5) at (20mm, 0mm) {};
\end{scope}
% Edges
\draw[opacity = 0.4]
(A1) edge (B2)
(A1) edge (B3)
(A2) edge (B1)
(A2) edge (B4)
(A4) edge (B3)
(A4) edge (B3)
(A5) edge (B3)
(A5) edge (B4)
;
\draw
(A1) edge (B2)
(A2) edge (B1)
(A4) edge (B3)
(A5) edge (B4)
;
\end{tikzpicture}
\end{center}
\end{minipage}
\vspace{5mm}
Devise an algorithm to find a maximal matching in any bipartite graph. \\
Find an upper bound for its runtime.
\begin{solution}
Turn this into a maximum flow problem and use FF. \\
Connect a node $S$ to all nodes in the left group and a node $T$ to all nodes in the right group. All edges have capacity 1.
\vspace{2ex}
Just like FF, this algorithm will take at most $\min(\# \text{ left nodes}, \# \text{ right nodes})$ iterations.
\end{solution}
\end{document}

91
Advanced/Graph Algorithms/parts/00 review.tex Executable file
View File

@ -0,0 +1,91 @@
\documentclass[../main.tex]{subfiles}
\begin{document}
\section{Review}
\definition{}
A \textit{graph} consists of a set of \textit{nodes} $\{A, B, ...\}$ and a set of edges $\{ (A,B), (A,C), ...\}$ connecting them.
A \textit{directed graph} is a graph where edges have direction. In such a graph, $(A, B)$ and $(B, A)$ are distinct edges.
A \textit{weighted graph} is a graph that features weights on its edges. \\
A weighted directed graph is shown below.
\begin{center}
\begin{tikzpicture}[node distance = 20mm]
% Nodes
\begin{scope}
\node[main] (A) {$A$};
\node[main] (B) [below right of = A] {$B$};
\node[main] (C) [below left of = A] {$C$};
\end{scope}
% Edges
\draw[->]
(A) edge[bend right] node[label] {$4$} (B)
(B) edge node[label] {$2$} (C)
(C) edge node[label] {$2$} (A)
(B) edge[bend right] node[label] {$1$} (A)
;
\end{tikzpicture}
\end{center}
\vfill
\definition{}
We say a graph is \textit{bipartite} if its nodes can be split into two groups $L$ and $R$ so that no two nodes in the same group are connected by an edge. \\
The following graph is bipartite:
\begin{center}
\begin{tikzpicture}
% Nodes
\begin{scope}
\node[main] (A) at (0mm, 0mm) {$A$};
\node[main] (B) at (0mm, -10mm) {$B$};
\node[main] (C) at (0mm, -20mm) {$C$};
\node[main] (D) at (20mm, 0mm) {$D$};
\node[main] (E) at (20mm, -10mm) {$E$};
\node[main] (F) at (20mm, -20mm) {$F$};
\end{scope}
% Edges
\draw
(A) edge (D)
(A) edge (E)
(B) edge (F)
(C) edge (E)
(C) edge (D)
;
\end{tikzpicture}
\end{center}
\vfill
\definition{}
We say two nodes $A$ ane $B$ are \textit{connected} if we can reach $A$ from $B$ and $B$ from $A$ by walking along (possibly directed) edges. We say a graph is connected if all its nodes are connected to each other.\\
The bipartite graph above and the directed graph below are not connected.
\begin{center}
\begin{tikzpicture}[node distance = 20mm]
% Nodes
\begin{scope}
\node[main] (A) {$A$};
\node[main] (B) [below right of = A] {$B$};
\node[main] (C) [below left of = A] {$C$};
\end{scope}
% Edges
\draw[->]
(A) edge[bend right] (B)
(B) edge[bend right] (A)
(B) edge (C)
;
\end{tikzpicture}
\end{center}
\vfill
\pagebreak
\end{document}

363
Advanced/Graph Algorithms/parts/01 flow.tex Executable file
View File

@ -0,0 +1,363 @@
\documentclass[../main.tex]{subfiles}
\begin{document}
\section{Network Flow}
\generic{Networks}
Say have a network: a sequence of pipes, a set of cities and highways, an electrical circuit, server infrastructure, etc.
\vspace{1ex}
We'll represent our network with a connected directed weighted graph. If we take a city, edges will be highways and cities will be nodes. There are a few conditions for a valid network graph:
\begin{itemize}
\item The weight of each edge represents its capacity, the number of lanes in the highway.
\item Edge capacities are always positive integers.\hspace{-0.5ex}\footnotemark{}
\item Node $S$ is a \textit{source}: it produces flow.
\item Node $T$ is a \textit{sink}: it consumes flow.
\item All other nodes \textit{conserve} flow. In other words, the sum of flow coming in must equal the sum of flow going out.
\end{itemize}
\footnotetext{An edge with capacity zero is equivalent to an edge that does not exist; An edge with negative capacity is equivalent to an edge in the opposite direction.}
Here is an example of a such a graph:
\begin{center}
\begin{tikzpicture}
% Nodes
\begin{scope}[layer = nodes]
\node[main] (S) at (+00mm, +00mm) {$S$};
\node[main] (A) at (+15mm, +15mm) {$A$};
\node[main] (B) at (+15mm, -15mm) {$B$};
\node[main] (T) at (+30mm, +00mm) {$T$};
\end{scope}
% Edges
\draw[->]
(S) edge node[label] {$1$} (A)
(A) edge node[label] {$4$} (T)
(B) edge node[label] {$2$} (A)
(S) edge node[label] {$2$} (B)
(B) edge node[label] {$1$} (T)
;
\end{tikzpicture}
\end{center}
\hrule{}
\generic{Flow}
In our city example, cars represent \textit{flow}. Let's send one unit of cars along the topmost highway:
\vspace{2ex}
\begin{minipage}{0.33\textwidth}
\begin{center}
\begin{tikzpicture}
% Nodes
\begin{scope}[layer = nodes]
\node[main] (S) at (+00mm, +00mm) {$S$};
\node[main] (A) at (+15mm, +15mm) {$A$};
\node[main] (B) at (+15mm, -15mm) {$B$};
\node[main] (T) at (+30mm, +00mm) {$T$};
\end{scope}
% Edges
\draw[->]
(S) edge node[label] {$1$} (A)
(A) edge node[label] {$4$} (T)
(B) edge node[label] {$2$} (A)
(S) edge node[label] {$2$} (B)
(B) edge node[label] {$1$} (T)
;
% Flow
\draw[path]
(S) -- node[above left, flow] {$(1)$} (A)
-- node[above right, flow] {$(1)$} (T)
;
\end{tikzpicture}
\end{center}
\end{minipage}
\begin{minipage}{0.65\textwidth}
There are a few things to notice here:
\begin{itemize}
\item Highlighted edges carry flow.
\item Numbers in parentheses tell us how much flow each edge carries.
\item The flow along an edge is always positive or zero.
\item Flow comes from $S$ and goes towards $T$.
\item Flow is conserved: all flow produced by $S$ enters $T$.
\end{itemize}
\end{minipage}
\vspace{1ex}
The \textit{magnitude} of a flow\footnotemark{} is the number of \say{flow-units} that go from $S$ to $T$. \\
We are interested in the \textit{maximum flow} through this network: what is the greatest amount of flow we can push from $S$ to $T$?
\footnotetext{you could also think of \say{flow} as a directed weighted graph on top of our network.}
\problem{}
What is the magnitude of the flow above?
\vfill
\pagebreak
\problem{}
Find a flow with magnitude 2 on the graph below.
\begin{center}
\begin{tikzpicture}
% Nodes
\begin{scope}[layer = nodes]
\node[main] (S) at (+00mm, +00mm) {$S$};
\node[main] (A) at (+15mm, +15mm) {$A$};
\node[main] (B) at (+15mm, -15mm) {$B$};
\node[main] (T) at (+30mm, +00mm) {$T$};
\end{scope}
% Edges
\draw[->]
(S) edge node[label] {$1$} (A)
(A) edge node[label] {$4$} (T)
(B) edge node[label] {$2$} (A)
(S) edge node[label] {$2$} (B)
(B) edge node[label] {$1$} (T)
;
\end{tikzpicture}
\end{center}
\vfill
\problem{}
Find a maximal flow on the graph below. \\
\hint{The total capacity coming out of $S$ is 3, so any flow must have magnitude $\leq 3$.}
\begin{center}
\begin{tikzpicture}
% Nodes
\begin{scope}[layer = nodes]
\node[main] (S) at (+00mm, +00mm) {$S$};
\node[main] (A) at (+15mm, +15mm) {$A$};
\node[main] (B) at (+15mm, -15mm) {$B$};
\node[main] (T) at (+30mm, +00mm) {$T$};
\end{scope}
% Edges
\draw[->]
(S) edge node[label] {$1$} (A)
(A) edge node[label] {$4$} (T)
(B) edge node[label] {$2$} (A)
(S) edge node[label] {$2$} (B)
(B) edge node[label] {$1$} (T)
;
\end{tikzpicture}
\end{center}
\vfill
\pagebreak
\section{Combining Flows}
It is fairly easy to combine two flows on a graph. All we need to do is add the flows along each edge. For example, consider the following flows:
\vspace{2ex}
\begin{minipage}[t]{0.48\textwidth}
\begin{center}
\begin{tikzpicture}
% Nodes
\begin{scope}[layer = nodes]
\node[main] (S) at (+00mm, +00mm) {$S$};
\node[main] (A) at (+15mm, +15mm) {$A$};
\node[main] (B) at (+15mm, -15mm) {$B$};
\node[main] (T) at (+30mm, +00mm) {$T$};
\end{scope}
% Edges
\draw[->]
(S) edge node[label] {$1$} (A)
(A) edge node[label] {$2$} (T)
(B) edge node[label] {$2$} (A)
(S) edge node[label] {$2$} (B)
(B) edge node[label] {$1$} (T)
;
% Flow
\draw[path]
(S) -- node[above left, flow] {$(1)$} (A)
-- node[above right, flow] {$(1)$} (T)
;
\end{tikzpicture}
\end{center}
\end{minipage}
\hfill
\begin{minipage}[t]{0.48\textwidth}
\begin{center}
\begin{tikzpicture}
% Nodes
\begin{scope}[layer = nodes]
\node[main] (S) at (+00mm, +00mm) {$S$};
\node[main] (A) at (+15mm, +15mm) {$A$};
\node[main] (B) at (+15mm, -15mm) {$B$};
\node[main] (T) at (+30mm, +00mm) {$T$};
\end{scope}
% Edges
\draw[->]
(S) edge node[label] {$1$} (A)
(A) edge node[label] {$2$} (T)
(B) edge node[label] {$2$} (A)
(S) edge node[label] {$2$} (B)
(B) edge node[label] {$1$} (T)
;
% Flow
\draw[path]
(S)
-- node[below left, flow] {$(1)$} (B)
-- node[left, flow] {$(1)$} (A)
-- node[above right, flow] {$(1)$} (T)
;
\end{tikzpicture}
\end{center}
\end{minipage}
\vspace{1cm}
\begin{minipage}[t]{0.48\textwidth}
\begin{center}
Combining these, we get the following:
\vspace{2ex}
\begin{tikzpicture}
% Nodes
\begin{scope}[layer = nodes]
\node[main] (S) at (+00mm, +00mm) {$S$};
\node[main] (A) at (+15mm, +15mm) {$A$};
\node[main] (B) at (+15mm, -15mm) {$B$};
\node[main] (T) at (+30mm, +00mm) {$T$};
\end{scope}
% Edges
\draw[->]
(S) edge node[label] {$1$} (A)
(A) edge node[label] {$2$} (T)
(B) edge node[label] {$2$} (A)
(S) edge node[label] {$2$} (B)
(B) edge node[label] {$1$} (T)
;
% Flow
\draw[path]
(S)
-- node[below left, flow] {$(1)$} (B)
-- node[left, flow] {$(1)$} (A)
-- node[above right, flow] {$(2) = (1) + (1)$} (T)
(S)
-- node[above left, flow] {$(1)$} (A)
;
\end{tikzpicture}
\end{center}
\end{minipage}
\hfill
\begin{minipage}[t]{0.48\textwidth}
\raggedright
When adding flows, we must respect edge capacities.
\vspace{1ex}
For example, we could not add these graphs if the magnitude of flow in the right graph above was 2.
\vspace{1ex}
This is because the capacity of the top-right edge is 2, and $2 + 1 > 2$.
\end{minipage}
\vspace{2ex}
\hrule
\vspace{2ex}
\problem{}
Combine the following flows and ensure that the flow along all edges remains within capacity.
\vspace{2ex}
\begin{minipage}[t]{0.48\textwidth}
\begin{center}
\begin{tikzpicture}[node distance = 20mm]
% Nodes
\begin{scope}[layer = nodes]
\node[main] (S) {$S$};
\node[main] (A) [above right of = S] {$A$};
\node[main] (B) [below right of = S] {$B$};
\node[main] (C) [right of = A] {$C$};
\node[main] (D) [right of = B] {$D$};
\node[main] (T) [above right of = D] {$T$};
\end{scope}
% Edges
\draw[->]
(S) edge node[label] {$5$} (A)
(A) edge node[label] {$3$} (C)
(C) edge node[label] {$2$} (T)
(A) edge node[label] {$4$} (D)
(S) edge node[label] {$4$} (B)
(B) edge node[label] {$1$} (D)
(D) edge node[label] {$2$} (T)
;
% Flow
\draw[path]
(S)
-- node[above left, flow] {$(2)$} (A)
-- node[above, flow] {$(2)$} (C)
-- node[above right, flow] {$(2)$} (T)
;
\end{tikzpicture}
\end{center}
\end{minipage}
\hfill
\begin{minipage}[t]{0.48\textwidth}
\begin{center}
\begin{tikzpicture}[node distance = 20mm]
% Nodes
\begin{scope}[layer = nodes]
\node[main] (S) {$S$};
\node[main] (A) [above right of = S] {$A$};
\node[main] (B) [below right of = S] {$B$};
\node[main] (C) [right of = A] {$C$};
\node[main] (D) [right of = B] {$D$};
\node[main] (T) [above right of = D] {$T$};
\end{scope}
% Edges
\draw[->]
(S) edge node[label] {$5$} (A)
(A) edge node[label] {$3$} (C)
(C) edge node[label] {$2$} (T)
(A) edge node[label] {$4$} (D)
(S) edge node[label] {$4$} (B)
(B) edge node[label] {$1$} (D)
(D) edge node[label] {$2$} (T)
;
% Flow
\draw[path]
(S)
-- node[above left, flow] {$(2)$} (A)
-- node[above right, flow] {$(2)$} (D)
-- node[below right, flow] {$(2)$} (T)
;
\end{tikzpicture}
\end{center}
\end{minipage}
\vfill
\pagebreak
\end{document}

219
Advanced/Graph Algorithms/parts/02 residual.tex Executable file
View File

@ -0,0 +1,219 @@
\documentclass[../main.tex]{subfiles}
\begin{document}
\section{Residual Graphs}
As our network gets bigger, finding a maximum flow by hand becomes much more difficult. It will be convenient to have an algorithm that finds a maximal flow in any network.
\vspace{1ex}
The first thing we'll need to construct such an algorithm is a \textit{residual graph}.
\vspace{2ex}
\hrule
\begin{center}
\begin{minipage}[t]{0.48\textwidth}
We'll start with the following network and flow:
\begin{center}
\begin{tikzpicture}[node distance = 20mm]
% Nodes
\begin{scope}[layer = nodes]
\node[main] (S) {$S$};
\node[main] (A) [above right of = S] {$A$};
\node[main] (B) [below right of = S] {$B$};
\node[main] (T) [above right of = B] {$T$};
\end{scope}
% Edges
\draw[->]
(S) edge node[label] {$1$} (A)
(A) edge node[label] {$3$} (T)
(B) edge node[label] {$2$} (A)
(S) edge node[label] {$2$} (B)
(B) edge node[label] {$1$} (T)
;
% Flow
\draw[path]
(S) -- node[above left, flow] {$(1)$} (A)
-- node[above right, flow] {$(1)$} (T)
;
\end{tikzpicture}
\end{center}
\end{minipage}
\hfill
\begin{minipage}[t]{0.48\textwidth}
First, we'll copy all nodes and \say{unused} edges:
\begin{center}
\begin{tikzpicture}[node distance = 20mm]
% Nodes
\begin{scope}[layer = nodes]
\node[main] (S) {$S$};
\node[main] (A) [above right of = S] {$A$};
\node[main] (B) [below right of = S] {$B$};
\node[main] (T) [above right of = B] {$T$};
\end{scope}
% Edges
\draw[->]
(B) edge node[label] {$2$} (A)
(S) edge node[label] {$2$} (B)
(B) edge node[label] {$1$} (T)
;
\end{tikzpicture}
\end{center}
\end{minipage}
\end{center}
\hrule
\begin{center}
\begin{minipage}[t]{0.48\textwidth}
Then, we'll add the unused capacity of \say{used} edges: (Note that $3 - 1 = 2$)
\begin{center}
\begin{tikzpicture}[node distance = 20mm]
% Nodes
\begin{scope}[layer = nodes]
\node[main] (S) {$S$};
\node[main] (A) [above right of = S] {$A$};
\node[main] (B) [below right of = S] {$B$};
\node[main] (T) [above right of = B] {$T$};
\end{scope}
% Edges
\draw[->]
(A) edge node[label] {$2$} (T)
(B) edge node[label] {$2$} (A)
(S) edge node[label] {$2$} (B)
(B) edge node[label] {$1$} (T)
;
\end{tikzpicture}
\end{center}
\end{minipage}
\hfill
\begin{minipage}[t]{0.48\textwidth}
Finally, we'll add \say{used} capacity as edges in the opposite direction:
\begin{center}
\begin{tikzpicture}[node distance = 20mm]
% Nodes
\begin{scope}[layer = nodes]
\node[main] (S) {$S$};
\node[main] (A) [above right of = S] {$A$};
\node[main] (B) [below right of = S] {$B$};
\node[main] (T) [above right of = B] {$T$};
\end{scope}
% Edges
\draw[->]
(A) edge node[label] {$1$} (S)
(T) edge [bend right] node[label] {$1$} (A)
(A) edge [bend right] node[label] {$2$} (T)
(B) edge node[label] {$2$} (A)
(S) edge node[label] {$2$} (B)
(B) edge node[label] {$1$} (T)
;
\end{tikzpicture}
\end{center}
This graph is the residual of the original flow.
\end{minipage}
\end{center}
\hrule
\vspace{3ex}
You can think of the residual graph as a \say{list of possible changes} to the original flow. \\
There are two ways we can change a flow:
\begin{itemize}
\item We can add flow along a path
\item We can remove flow along another path
\end{itemize}
\vspace{1ex}
A residual graph captures both of these actions, showing us where we can add flow (forward edges) and where we can remove it (reverse edges). Note that \say{removing} flow along an edge is equivalent to adding flow in the opposite direction.
\vfill
\pagebreak
\problem{}<FindResidual>
Construct the residual of this flow.
\begin{center}
\begin{tikzpicture}[node distance = 25mm]
% Nodes
\begin{scope}[layer = nodes]
\node[main] (S) {$S$};
\node[main] (A) [above right of = S] {$A$};
\node[main] (B) [below right of = S] {$B$};
\node[main] (T) [above right of = B] {$T$};
\end{scope}
% Edges
\draw[->]
(S) edge node[label] {$2$} (A)
(A) edge node[label] {$1$} (T)
(A) edge node[label] {$3$} (B)
(S) edge node[label] {$1$} (B)
(B) edge node[label] {$2$} (T)
;
% Flow
\draw[path]
(S)
-- node[above left, flow] {$(2)$} (A)
-- node[left, flow] {$(2)$} (B)
-- node[below right, flow] {$(2)$} (T)
;
\end{tikzpicture}
\end{center}
\begin{solution}
\begin{center}
\begin{tikzpicture}[node distance = 25mm]
% Nodes
\begin{scope}[layer = nodes]
\node[main] (S) {$S$};
\node[main] (A) [above right of = S] {$A$};
\node[main] (B) [below right of = S] {$B$};
\node[main] (T) [above right of = B] {$T$};
\end{scope}
% Edges
\draw[->]
(A) edge node[label] {$2$} (S)
(A) edge node[label] {$1$} (T)
(A) edge[out=295,in=65] node[label] {$1$} (B)
(B) edge[out=115,in=245] node[label] {$2$} (A)
(S) edge node[label] {$1$} (B)
(T) edge node[label] {$2$} (B)
;
\end{tikzpicture}
\end{center}
\end{solution}
\vfill
\problem{}
Is the flow in \ref{FindResidual} maximal? \\
If it isn't, find a maximal flow. \\
\hint{Look at the residual graph. Can we add flow along another path?}
\vfill
\pagebreak
\problem{}
Show that...
\begin{enumerate}
\item A maximal flow exists in every network with integral\footnotemark{} edge weights.
\item Every edge in this flow carries an integral amount of flow
\end{enumerate}
\footnotetext{Integral = \say{integer} as an adjective.}
\vfill
\end{document}

128
Advanced/Graph Algorithms/parts/03 fulkerson.tex Executable file
View File

@ -0,0 +1,128 @@
\documentclass[../main.tex]{subfiles}
\begin{document}
\section{The Ford-Fulkerson Algorithm}
We now have all the tools we need to construct an algorithm that finds a maximal flow. \\
It works as follows:
\begin{enumerate}
\item[\texttt{00}] Take a weighted directed graph $G$.
\item[\texttt{01}] Find any flow $F$ in $G$
\item[\texttt{02}] Calculate $R$, the residual of $F$.
\item[\texttt{03}] ~~~~If $S$ and $T$ are not connected in $R$, $F$ is a maximal flow. \texttt{HALT}.
\item[\texttt{04}] Otherwise, find another flow $F_0$ in $R$.
\item[\texttt{05}] Add $F_0$ to $F$
\item[\texttt{06}] \texttt{GOTO 02}
\end{enumerate}
\problem{}
Run the Ford-Fulkerson algorithm on the following graph. \\
There is extra space on the next page.
\begin{center}
\begin{tikzpicture}
% Nodes
\begin{scope}[layer = nodes]
\node[main] (S) at (-5mm, 0mm) {$S$};
\node[main] (A) at (20mm, 20mm) {$A$};
\node[main] (B) at (20mm, 0mm) {$B$};
\node[main] (C) at (20mm, -20mm) {$C$};
\node[main] (D) at (50mm, 20mm) {$D$};
\node[main] (E) at (50mm, 0mm) {$E$};
\node[main] (F) at (50mm, -20mm) {$F$};
\node[main] (T) at (75mm, 0mm) {$T$};
\end{scope}
% Edges
\draw[->]
(S) edge node[label] {$8$} (A)
(S) edge node[label] {$7$} (B)
(S) edge node[label] {$4$} (C)
(A) edge node[label] {$2$} (B)
(B) edge node[label] {$5$} (C)
(A) edge node[label] {$3$} (D)
(A) edge node[label] {$9$} (E)
(B) edge node[label] {$6$} (E)
(C) edge node[label] {$7$} (E)
(C) edge node[label] {$2$} (F)
(E) edge node[label] {$3$} (D)
(E) edge node[label] {$4$} (F)
(D) edge node[label] {$9$} (T)
(E) edge node[label] {$5$} (T)
(F) edge node[label] {$8$} (T)
;
\end{tikzpicture}
\end{center}
\begin{solution}
The maximum flow is $17$.
\end{solution}
\vspace{5mm}
\pagebreak
\begin{center}
\begin{tikzpicture}
% Nodes
\begin{scope}[layer = nodes]
\node[main] (S) at (-5mm, 0mm) {$S$};
\node[main] (A) at (20mm, 20mm) {$A$};
\node[main] (B) at (20mm, 0mm) {$B$};
\node[main] (C) at (20mm, -20mm) {$C$};
\node[main] (D) at (50mm, 20mm) {$D$};
\node[main] (E) at (50mm, 0mm) {$E$};
\node[main] (F) at (50mm, -20mm) {$F$};
\node[main] (T) at (75mm, 0mm) {$T$};
\end{scope}
% Edges
\draw[->]
(S) edge node[label] {$8$} (A)
(S) edge node[label] {$7$} (B)
(S) edge node[label] {$4$} (C)
(A) edge node[label] {$2$} (B)
(B) edge node[label] {$5$} (C)
(A) edge node[label] {$3$} (D)
(A) edge node[label] {$9$} (E)
(B) edge node[label] {$6$} (E)
(C) edge node[label] {$7$} (E)
(C) edge node[label] {$2$} (F)
(E) edge node[label] {$3$} (D)
(E) edge node[label] {$4$} (F)
(D) edge node[label] {$9$} (T)
(E) edge node[label] {$5$} (T)
(F) edge node[label] {$8$} (T)
;
\end{tikzpicture}
\end{center}
\vfill
\pagebreak
\problem{}
You are given a large network. How would you quickly find an upper bound for the number of iterations the Ford-Fulkerson algorithm will need to find a maximum flow?
\begin{solution}
Each iteration adds at least one unit of flow. So, we will find a maximum flow in at most $\min(\text{flow out of } S,~\text{flow into } T)$ iterations.
\vspace{2ex}
A simpler answer could only count the flow on $S$.
\end{solution}
\vfill
\pagebreak
\end{document}