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

Advanced handouts

Browse Source 
Add missing file
Co-authored-by: Mark <mark@betalupi.com>
Co-committed-by: Mark <mark@betalupi.com>
This commit is contained in:
Mark
2025-01-22 12:28:44 -08:00
parent 13b65a6c64
commit dd4abdbab0
177 changed files with 20658 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
src/Advanced/Graph Algorithms/main.tex Executable file
View File

@ -0,0 +1,28 @@
% use [nosolutions] flag to hide solutions.
% use [solutions] flag to show solutions.
\documentclass[
solutions
]{../../../lib/tex/ormc_handout}
\usepackage{../../../lib/tex/macros}
\input{tikxset}
\uptitlel{Advanced 2}
\uptitler{\smallurl{}}
\title{Algorithms on Graphs: Flow}
\subtitle{Prepared by Mark on \today}
\begin{document}
\maketitle
\input{parts/00 review}
\input{parts/01 flow}
\input{parts/02 residual}
\input{parts/03 fulkerson}
\input{parts/04 applications}
\input{parts/05 reductions}
\input{parts/06 bonus}
\end{document}

6
src/Advanced/Graph Algorithms/meta.toml Normal file
View File

@ -0,0 +1,6 @@
[metadata]
title = "Graph Algorithms"
[publish]
handout = true
solutions = true

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

@ -0,0 +1,58 @@
\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, edges $(A, B)$ and $(B, A)$ are distinct.
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$, where no two nodes in the same group are connected by an edge: \\
\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, hatch] (D) at (20mm, 0mm) {$D$};
\node[main, hatch] (E) at (20mm, -10mm) {$E$};
\node[main, hatch] (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
\pagebreak

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

@ -0,0 +1,351 @@
\section{Network Flow}
\generic{Networks}
Say have a network: a sequence of pipes, a set of cities and highways, an electrical circuit, etc.
\vspace{1ex}
We can draw this network as a directed weighted graph. If we take a transportation network, for example, edges will represent highways and nodes will be cities. There are a few conditions for a valid network graph:
\begin{itemize}
\item The weight of each edge represents its capacity, e.g, 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. 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 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, traffic represents \textit{flow}. Let's send one unit of traffic 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 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 get from $S$ to $T$?
\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. \\
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, since the capacity of the top-right edge is 2, and $2 + 1 > 2$.
\end{minipage}
\vspace{2ex}
\hrule
\vspace{2ex}
\problem{}
Combine the flows below, ensuring that the flow along each edge 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

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

@ -0,0 +1,211 @@
\section{Residual Graphs}
It is hard to find a maximum flow for a large network by hand. \\
We need to create an algorithm to accomplish this task.
\vspace{1ex}
The first thing we'll need is the notion of 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 edge weights.
\item Every edge in this flow carries an integral amount of flow
\end{enumerate}
\vfill
\pagebreak

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

@ -0,0 +1,123 @@
\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 can 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

188
src/Advanced/Graph Algorithms/parts/04 applications.tex Executable file
View File

@ -0,0 +1,188 @@
\section{Applications}
\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}
Create an algorithm that finds a maximal matching in any bipartite graph. \\
Find an upper bound for its runtime. \\
\hint{Can you modify an algorithm we already know?}
\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}
\vfill
\pagebreak
\problem{Supply and Demand}
Say we have a network of cities and power stations. Stations produce power; cities consume it.
Each station produces a limited amount of power, and each city has limited demand.
\vspace{2ex}
We can represent this power grid as a graph, with cities and stations as nodes and transmission lines as edges.
\vspace{2ex}
A simple example is below. There are two cities ($2$ and $4$) and two stations (both $-3$).
We'll represent station capacity with a negative number, since they \textit{consume} a negative amount of energy.
\begin{center}
\begin{tikzpicture}[
node distance = 25mm,
main/.style = {
draw,
circle,
fill = white,
minimum size = 8mm
},
]
% Nodes
\begin{scope}[layer = nodes]
\node[main] (S1) {$-3$};
\node[main] (S2) [below left of = S1] {$-3$};
\node[main] (C1) [below right of = S1] {$2$};
\node[main] (C2) [below right of = S2] {$4$};
\end{scope}
% Edges
\draw[->]
(S1) edge node[label] {$3$} (S2)
(S1) edge node[label] {$3$} (C1)
(S2) edge node[label] {$2$} (C1)
(S2) edge node[label] {$2$} (C2)
(C1) edge node[label] {$2$} (C2)
;
\end{tikzpicture}
\end{center}
We'd like to know if there exists a \textit{feasible circulation} in this network---that is, can we supply our cities with the energy they need without exceeding the capacity of our power plants and transmission lines?
\vspace{2ex}
\textbf{Your job:} Devise an algorithm that solve this problem.
\vspace{2ex}
\note{\textbf{Bonus:} Say certain edges have a lower bound on their capacity, meaning that we must send \textit{at least} that much flow down the edge. Modify your algorithm to account for these additional constraints.}
\begin{solution}
Create a source node $S$, and connect it to each station with an edge. Set the capacity of that edge to the capacity of the station. \\
Create a sink node $T$ and do the same for cities.
\vspace{2ex}
This is now a maximum-flow problem with one source and one sink. Apply FF.
\linehack{}
To solve the bonus problem, we'll modify the network before running the algorithm above.
\vspace{2ex}
Say an edge from $A$ to $B$ has minimum capacity $l$ and maximum capacity $u \geq l$. Apply the following transformations:
\begin{itemize}
\item Add $l$ to the capacity of $A$
\item Subtract $l$ from the capacity of $B$
\item Subtract $l$ from the total capacity of the edge.
\end{itemize}
Do this for every edge that has a lower bound then apply the algorithm above.
\end{solution}
\vfill
\pagebreak

123
src/Advanced/Graph Algorithms/parts/05 reductions.tex Executable file
View File

@ -0,0 +1,123 @@
\section{Reductions}
\definition{Independent Sets}
An \textit{independent set} is a set of vertices\footnotemark{} in which no two are connected. $\{B, C, D, E\}$ form an independent set in the following graph:
\footnotetext{\say{Node} and \say{Vertex} are synonyms in graph theory.}
\begin{center}
\begin{tikzpicture}[
node distance = 12mm
]
% Nodes
\begin{scope}[layer = nodes]
\node[main] (A) {$A$};
% Patterns are transparent.
% Fill nodes first so paths don't show through
\node[main, draw = white] (B1) [above left of = A] {$\phantom{B}$};
\node[main, draw = white] (C1) [below left of = A] {$\phantom{C}$};
\node[main, draw = white] (D1) [below right of = A] {$\phantom{D}$};
\node[main, draw = white] (E1) [above right of = A] {$\phantom{E}$};
\node[main, hatch] (B) [above left of = A] {$B$};
\node[main, hatch] (C) [below left of = A] {$C$};
\node[main, hatch] (D) [below right of = A] {$D$};
\node[main, hatch] (E) [above right of = A] {$E$};
\end{scope}
% Edges
\draw
(A) edge (B)
(A) edge (C)
(A) edge (D)
(A) edge (E)
;
\end{tikzpicture}
\end{center}
\definition{Vertex Covers}
A \textit{vertex cover} is a set of vertices that includes at least one endpoint of each edge. $B$ and $D$ form a vertex cover of the following graph:
\begin{center}
\begin{tikzpicture}[
node distance = 12mm
]
% Nodes
\begin{scope}[layer = nodes]
\node[main] (A) {$A$};
% Patterns are transparent.
% Fill nodes first so paths don't show through
\node[main, draw = white] (B1) [right of = A] {$\phantom{B}$};
\node[main, hatch] (B) [right of = A] {$B$};
\node[main, draw = white] (D1) [below of = B] {$\phantom{D}$};
\node[main, hatch] (D) [below of = B] {$D$};
\node[main] (C) [right of = B] {$C$};
\node[main] (E) [right of = D] {$E$};
\end{scope}
% Edges
\draw
(A) edge (B)
(B) edge (C)
(B) edge (D)
(D) edge (E)
;
% Flow
\draw[path]
(B) -- (A)
(B) -- (C)
(B) -- (D)
(D) -- (E)
;
\end{tikzpicture}
\end{center}
\vfill
\pagebreak
\problem{}<IndepCover>
Let $G$ be a graph with a set of vertices $V$. \\
Show that $S \subset V$ is an independent set iff $(V - S)$ is a vertex cover. \\
\hint{$(V - S)$ is the set of elements in $V$ that are not in $S$.}
\begin{solution}
Suppose $S$ is an independent set.
\begin{itemize}
\item [$\implies$] All edges are in $(V - S)$ or connect $(V - S)$ and $S$.
\item [$\implies$] $(V - S)$ is a vertex cover.
\end{itemize}
\linehack{}
Suppose $S$ is a vertex cover.
\begin{itemize}
\item [$\implies$] There are no edges with both endpoints in $(V - S)$.
\item [$\implies$] $(V - S)$ is an independent set.
\end{itemize}
\end{solution}
\vfill
\problem{}
Consider the following two problems:
\begin{itemize}
\item Given a graph $G$, determine if it has an independent set of size $\geq k$.
\item Given a graph $G$, determine if it has a vertex cover of size $\leq k$.
\end{itemize}
Show that these are equivalent. In other words, show that an algorithm that solves one can be used to solve the other.
\begin{solution}
This is a direct consequence of \ref{IndepCover}. You'll need to show that the size constraints are satisfied, but that's fairly easy to do.
\end{solution}
\vfill
\pagebreak

131
src/Advanced/Graph Algorithms/parts/06 bonus.tex Normal file
View File

@ -0,0 +1,131 @@
\section{Crosses}
You are given an $n \times n$ grid. Some of its squares are white, some are gray. Your goal is to place $n$ crosses on white cells so that each row and each column contains exactly one cross.
\vspace{2ex}
Here is an example of such a grid, including a possible solution.
\newcommand{\bx}[2]{
\draw[
line width = 1.5mm
]
(#1 + 0.3, #2 + 0.3) -- (#1 + 0.7, #2 + 0.7)
(#1 + 0.7, #2 + 0.3) -- (#1 + 0.3, #2 + 0.7);
}
\newcommand{\dk}[2]{
\draw[
line width = 0mm,
fill = gray
]
(#1, #2) --
(#1 + 1, #2) --
(#1 + 1, #2 + 1) --
(#1, #2 + 1);
}
\begin{center}
\begin{tikzpicture}[
scale = 0.8
]
% Dark squares
\dk{0}{2}
\dk{1}{0}
\dk{1}{1}
\dk{1}{2}
\dk{1}{4}
\dk{2}{2}
\dk{2}{4}
\dk{3}{0}
\dk{3}{1}
\dk{3}{3}
\dk{3}{4}
\dk{4}{3}
\dk{4}{1}
% Base grid
\foreach \x in {0,...,5} {
\draw[line width = 0.4mm]
(0, \x) -- (5, \x)
(\x, 0) -- (\x, 5);
}
% X marks
\bx{0}{4}
\bx{1}{3}
\bx{2}{1}
\bx{3}{2}
\bx{4}{0}
\end{tikzpicture}
\end{center}
\problem{}
Find a solution for the following grid.
\begin{center}
\begin{tikzpicture}[
scale = 1
]
% Dark squares
\dk{0}{2}
\dk{0}{3}
\dk{0}{6}
\dk{0}{7}
\dk{1}{0}
\dk{1}{1}
\dk{1}{4}
\dk{1}{5}
\dk{1}{6}
\dk{1}{7}
\dk{2}{0}
\dk{2}{1}
\dk{2}{3}
\dk{2}{4}
\dk{2}{5}
\dk{2}{6}
\dk{2}{7}
\dk{3}{1}
\dk{3}{2}
\dk{3}{3}
\dk{3}{4}
\dk{3}{5}
\dk{3}{6}
\dk{4}{0}
\dk{4}{1}
\dk{4}{2}
\dk{4}{3}
\dk{4}{6}
\dk{5}{1}
\dk{5}{4}
\dk{5}{5}
\dk{5}{6}
\dk{6}{0}
\dk{6}{1}
\dk{6}{2}
\dk{6}{3}
\dk{6}{4}
\dk{6}{5}
\dk{7}{0}
\dk{7}{4}
\dk{7}{6}
\dk{7}{7}
% Base grid
\foreach \x in {0,...,8} {
\draw[line width = 0.4mm]
(0, \x) -- (8, \x)
(\x, 0) -- (\x, 8);
}
\end{tikzpicture}
\end{center}
\pagebreak
\problem{}
Turn this into a network flow problem that can be solved with the Ford-Fulkerson algorithm.
\vfill
\pagebreak

57
src/Advanced/Graph Algorithms/tikxset.tex Normal file
View File

@ -0,0 +1,57 @@
\usetikzlibrary{arrows.meta}
\usetikzlibrary{shapes.geometric}
\usetikzlibrary{patterns}
% 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
},
hatch/.style = {
pattern=north west lines,
pattern color=gray
}
}