Max Flow notes

Author: AustinTSchaffer

OMSCS/Courses/GA/05.2 - Max Flow - MF MC.md

@@ -0,0 +1,131 @@
+---
+tags:
+  - OMSCS
+  - Algorithms
+  - Alg-Graph
+---
+# 05.2 - Max Flow - Max-Flow Min-Cut
+## Outline
+1. max-flow = min st-cut theorem
+	1. image segmentation
+2. Correctness of Ford-Fulkerson algorithm
+
+## Ford-Fulkerson Alg
+**input:** flow network
+- directed graph: $G=(V,E)$
+- start node and end node: $s,t \in V$
+- capacities: $c_e > 0$
+
+**output:**
+- flow $f^*$ of max size
+- $size(f)=f_{out}(s)=f_{in}(t)$
+
+When does Ford-Fulkerson stop? It stops when there is no augmenting path in residual $G^{f^*}$.
+
+**Lemma:** For a flow $f^*$, if no augmenting path in $G^{f^*}$ exists, then $f^*$ is a max-flow in $G$
+
+## Verifying Max Flow
+> **Q:** Given a flow network and a flow $f$, what is the time to check whether or not $f$ is a max flow?
+>
+> **A:** $O(n+m)$
+
+There is no augmenting path in $G^{f^*}$ if there is no path from $s$ to $t$. This can be accomplished with a DFS, which is $O(n+m)$.
+
+## Min-Cut Problem
+- A $cut$ is a partition of $V=L \cup R$
+- An "st-cut" is a cut where $s \in L$ and $t \in R$
+- Neither $L$ nor $R$ needs to be a connected set.
+
+![[Pasted image 20260311195056.png]]
+
+Below is the "capacity" of the cut. This is the sum of edges $vw$ where $v$ is in $L$ and $w$ is in $R$.
+
+$$capacity(L,R)=\sum_{vw \in E, \space v \in L, \space w \in R}c_{vw}$$
+
+## Problem Formulation
+**input:** flow network
+
+**output:**
+- st-cut$(L,R)$ with minimum capacity.
+
+On the flow network from [[05.1.1 - Max Flow - FF]], the screenshot below demonstrates the minimum cut. The minimum cut is 12, which equals the max flow on the same flow network. This proves the max-flow = min-cut theorem (/s).
+
+![[Pasted image 20260311195427.png]]
+
+
+## Theorem
+> For a given flow network, the size of the max flow equals the minimum capacity of an st-cut.
+
+### Proof 1 - max-flow $\le$ min st-cut
+For any flow $f$ and any st-cut$(L,R)$:
+
+$$size(f) \le capacity(L,R)$$
+$$
+\max_f \{size(f)\} \le \min_{(L,R)} \{capacity(L,R)\}$$
+
+**Claim:** $size(f) = f_{out}(L) - f_{in}(L)$
+
+$$f_{out}(L)-f_{in}(L)=$$
+$$\sum_{vw \in E, \space v \in L, \space w \in R} f_{vw} - \sum_{wv \in E, \space w \in R, \space v \in L }f_{wv}+\sum_{vw \in E, \space v \in L, \space w \in L } f_{vw}-\sum_{wv \in E, \space w \in L, \space v \in L}f_{wv}$$
+
+- First summation
+	- The sum of the flows for each edge (v,w) where v is in L and w is in R.
+	- This is the sum of the flows leaving L to R
+- Second term
+	- The sum of the flows for each edge (w,v) where w is in R and v is in L.
+	- This is the sum of flows leaving R to L
+- Third term
+	- The sum of the flows for each edge (v,w) where v is in L and w is in L
+	- This is the sum of flows which are internal to L
+- Fourth term
+	- The sum of flows for each edge (w,v) where w is in L and v is in L
+	- This is another sum of flows which are internal to L
+- The third term and fourth term appear to cancel out.
+
+The first and third terms give us $f_{out}(L)$.
+$$f_{out}(L)=\sum_{v \in L}f_{out}(v)$$
+ 
+ The second and fourth terms give us $f_{out}(v)$
+$$f_{out}(v)=\sum_{v \in L}f_{in}(v)$$
+
+The set $L$ contains the source vertex $s$. We know that the flow in to $s$ is $0$, and that the flow out of $s$ contains the flow out of $L$.
+
+$$f_{out}(L)-f_{in}(L)=\bigg(\sum_{v \in (L - s)}\big(f_{out}(v)-f_{in}(v)\big)\bigg) + f_{out}(s)$$
+
+What do we know about the summation? We know that the flow out of any vertex must equal the flow in to the vertex. That's one of the conditions for a valid flow. Therefore, we can drop the whole summation.
+
+$$\sum_{v \in (L - s)}\big(f_{out}(v)-f_{in}(v)\big)=0$$
+$$f_{out}(L)-f_{in}(L)=f_{out}(s)=size(f)$$
+
+$$size(f)=f_{out}(L)-f_{in}(L) \le f_{out}(L) \le cap(L,R)$$
+
+### Proof 2 - max-flow $\ge$ min st-cut
+
+$$\max_f  \{ size(f) \} \ge \min_{(L,R)}  cap(L,R)$$
+
+- Take flow $f^*$ from Ford-Fulkerson alg
+- $f^*$ has no st-path in residual $G^{f^*}$
+- we'll construct $(L,R)$ where:
+
+$$\max_f \{ size(f) \} \ge size(f^*) = cap(L,R) \ge \min_{(L,R)} cap(L,R)$$
+
+The operative bit in this proof is $size(f^*) = cap(L,R)$. Take flow $f^*$ with no st-path in residual $G^{f^*}$. Let $L=$ vertices reachable from $s$ in $G^{f^*}$.
+- We know $t \notin L$.
+- Let $R = V - L$
+
+What are the properties of the cut we just constructed?
+- Flow $f^*$ with no st-path in $G^{f^*}$
+- $L=$ vertices reachable from $s$ in $G^{f^*}$
+
+See below for an example graph with residuals labelled on the original graph. The graph on the right is the residual network where only some amount of capacity remains.
+
+The set $L$ is labelled on the graph. The remaining 3 vertices are set $R$. The edge capacities are no longer important. We can view the graph as an unweighted directed graph, and simply check for connectivity via DFS / BFS / SCC.
+
+![[Pasted image 20260311223624.png]]
+
+Notice how edges $sc$, $dc$, and $dt$ do not appear in the residual network. This means that in this residual graph, $f^*_{out}(L)=cap(L,R)$.
+
+Notice also how edge $ef$ DOESN'T appear in the residual network. That's because there is no flow running along edge $fe$. If there was flow running along that edge, then $f$ would be included in the residual network. From this, we can conclude that $f^*_{in}(L)=0$
+
+$$size(f^*)=cap(L,R)-0$$
+

OMSCS/Courses/GA/05.3 - Max Flow - EK.md

@@ -0,0 +1,54 @@
+---
+tags:
+  - OMSCS
+  - Algorithms
+  - Alg-Graph
+---
+# 05.3 - Max Flow - Edmonds-Karp (EK)
+## Ford-Fulkerson (FF) vs Edmonds-Karp (EK)
+
+FF
+- Find augmenting paths using DFS or BFS
+- $O(mC)$ where $C$ is the size of the max flow
+- assumes integer capacities
+
+EK
+- Finds augmenting paths using BFS
+- $O(m^2n)$ time
+- Does not have assumptions on capacities
+
+For a reminder of how FF works, see
+- [[05.1.1 - Max Flow - FF]]
+- [[05.1.2 - Max Flow - FF Supplement]]
+
+## FF Algorithm
+1. Set $f_e=0$ for all $e \in E$
+2. Build the residual network $G^f$ for current flow $f$
+3. Check for a st-path in $G^f$ using DFS or BFS. If no such path, then output $f$
+4. Given $P$, let $c(P)=$ min capacity along $P$ in $G^f$
+5. Augment $f$ by $c(P)$ units along $P$
+6. Repeat from step 2 until no such st-path
+
+## EK Algorithm
+Does not assume that capacities are integer values. Does require that capacities are positive.
+
+1. Set $f_e=0$ for all $e \in E$
+2. Build the residual network $G^f$ for current flow $f$
+3. Check for a st-path $P$ in $G^f$ **using BFS**. If no such path, then output $f$
+4. Given $P$, let $c(P)=$ min capacity along $P$ in $G^f$
+5. Augment $f$ by $c(P)$ units along $P$
+6. Repeat from step 2 until no such st-path
+
+The key property of EK is that at least one edge is removed from $G^f$ (or added back in to $G^f$) on each iteration.
+
+## Proof Outline
+**Running Time:** $O(m^2n)$
+
+- We need to prove that the number of rounds is $\le mn$
+- In every round, residual graph changes ($\ge 1$ edge deleted)
+- **Key Lemma:** For every edge $e$, $e$ is deleted and reinserted later $\le n/2$ times.
+- Since there are $m$ edges, there are $nm/2$ total rounds, which is $\le mn=O(mn)$
+
+## BFS Properties
+
+(Continue from here next time)

OMSCS/Courses/GA/Office Hours/2026-03-11 Office Hours with Dr Brito.md

@@ -0,0 +1,34 @@
+---
+tags:
+  - OMSCS
+  - Algorithms
+---
+# 2026-03-11 - Office Hours with Dr. Brito
+## Solution 1 to HW
+We can modify Dijkstra such that we track the size of the largest/smallest edge on the path so far, instead of the total 
+
+This runs in $O((n+m) \space log \space n)$.
+
+We can't modify the black-box algorithms in this course. Therefore, this solution is off-limits. The point was the force the actual solution, which involves Prim's and/or Kruskal's.
+
+[[04.0.1 - Graphs - Black Box Algorithms]]
+
+## Solution 2
+- $m=min\space\{w(e):e \in P\}$
+- $M=min \space\{w(e) : e \in P\}$
+
+We want the path from $s$ to $t$ with the largest "smallest edge".
+
+- Let $G_d=(V,E_d)$
+- $E_d = \{e \in E : w(e) \ge d\}$
+
+- For $d : M \rightarrow m:$
+	- Explore($G_d, s)$
+- Stop when we find the first time that $t$ is visited!
+
+This outputs the correct result. We iterate backwards through edges in order of weight. Once we add enough edges to $G_d$ such that there is a path from $s$ to $t$, then that path maximizes the minimum weight of all edges from $s$ to $t$. This algorithm is $O((n+m)(M-m))$.
+
+If we binary search over $(M, ..., m)$, then we can get this down to $O((n+m) \space log \space M)$
+
+## Solution 3
+"Maximum Spanning Tree"