diff --git a/Advanced/Graph Algorithms/main.tex b/Advanced/Graph Algorithms/main.tex
new file mode 100755
index 0000000..a76d686
--- /dev/null
+++ b/Advanced/Graph Algorithms/main.tex	
@@ -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}
\ No newline at end of file
diff --git a/Advanced/Graph Algorithms/parts/00 review.tex b/Advanced/Graph Algorithms/parts/00 review.tex
new file mode 100755
index 0000000..9a489b2
--- /dev/null
+++ b/Advanced/Graph Algorithms/parts/00 review.tex	
@@ -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}
\ No newline at end of file
diff --git a/Advanced/Graph Algorithms/parts/01 flow.tex b/Advanced/Graph Algorithms/parts/01 flow.tex
new file mode 100755
index 0000000..f15cc61
--- /dev/null
+++ b/Advanced/Graph Algorithms/parts/01 flow.tex	
@@ -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}
\ No newline at end of file
diff --git a/Advanced/Graph Algorithms/parts/02 residual.tex b/Advanced/Graph Algorithms/parts/02 residual.tex
new file mode 100755
index 0000000..a937f0c
--- /dev/null
+++ b/Advanced/Graph Algorithms/parts/02 residual.tex	
@@ -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}
\ No newline at end of file
diff --git a/Advanced/Graph Algorithms/parts/03 fulkerson.tex b/Advanced/Graph Algorithms/parts/03 fulkerson.tex
new file mode 100755
index 0000000..260448a
--- /dev/null
+++ b/Advanced/Graph Algorithms/parts/03 fulkerson.tex	
@@ -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}
\ No newline at end of file