Practice problems from CH7

Author: AustinTSchaffer

OMSCS/Courses/GA/Office Hours/2026-03-15 - TA Office Hours - Exam 2.md

@@ -7,7 +7,7 @@ tags:
 This OH covers the following strategies, outlined below. It also covers the following practice problems:
 - [[4.3 - Squares]]
 - [[5.9 - Properties of Weighted Undirected Graphs]]
-- [[7.22 - Fast Max-Flow Recomputation (TODO)]]
+- [[7.22 - Fast Max-Flow Recomputation]]
 - [[7.24 - Direct Bipartite Matching (TODO)]]
 
 ## Graph Strategies

OMSCS/Courses/GA/Practice Problems/7.21 - Critical Edges (TODO).md

@@ -0,0 +1,90 @@
+---
+tags:
+  - OMSCS
+  - Algorithms
+  - Practice
+---
+# 7.21 - Critical Edges
+> An edge of a flow network is called critical if decreasing the capacity of this edge results in a decrease in the maximum flow. Give an efficient algorithm that finds a critical edge in a network.
+
+## Exploration
+To find a critical edge, we need to check through the flow network to see if there are any flows that fully utilize the capacity of a given edge. If that is the case, then reducing the capacity of that edge will reduce the overall flow through the network. There is no alternate path that this unit of flow can take. If such a path exists, then the max possible flow through the flow network has not yet been achieved.
+
+Actually this is not true. Just because an edge is fully saturated does not mean that it's critical. See the flow network below.
+
+```mermaid
+graph LR
+S --[2]--> A
+S --[2]--> B
+A --[2]--> C
+B --[2]--> C
+C --[2]--> T
+```
+
+One valid max flow through this network is this:
+
+```mermaid
+graph LR
+S --[2]--> A
+S --[0]--> B
+A --[2]--> C
+B --[0]--> C
+C --[2]--> T
+```
+
+$SA$ is fully utilized, but it's not a critical edge. If the capacity of $SA$ is reduced, the flow can reroute through $SB$, which is underutilized. $CT$ is fully utilized, and is in fact a critical edge, since it forms a bottleneck through $G$.
+
+Let's look at the residual network for this flow. The edges are labelled `[remaining capacity / reverse capacity]`.
+
+```mermaid
+graph LR
+
+S --[0/2]--> A
+S --[2/0]--> B
+A --[0/2]--> C
+B --[2/0]--> C
+C --[0/2]--> T
+```
+
+In the residual graph, the edges which are "at capacity" have a forward flow of 0. That's a good first indicator that the edge is critical. In this flow, those edges are $SA$, $AC$, and $CT$.
+
+How is criticality visible in the residual graph? The TA mentioned that we can run DFS from a given $u$ for an at-capacity edge $(u,v)$, and seeing if $v$ is reachable. If $v$ is reachable, then $(u,v)$ is not critical. How does that make sense? I believe the rationale here is:
+
+If we have a max flow through a flow network, all st-paths are at capacity. If we subsequently reduce the flow across a given edge $(u,v)$ by some minimum amount $\epsilon$, that introduces both an oversupply of flow at $u$ and a deficit of flow at $v$. These 2 issues can be symbolized by the inequalities $f_{out}(u) < f_{in}(u)$ and $f_{in}(v) < f_{out}(v)$. In the special cases where $u=s$ and/or $v=t$, the appropriate in/out-flow is $C$. For all other vertices $w$ in $G$, $f_{out}(w) = f_{in}(w)$. In order to correct this issues at $u$ and $v$, (i.e. convert those inequalities to equalities), we need to find some alternate route for the $\epsilon$ units of flow through the network from $u$ to $v$. This can be accomplished by running DFS in the residual network from $u$, and checking to see if there exists a path to $v$.
+
+Let's look at $SA$. We can reduce $c_{SA}$ by 1 or 2, and the flow can bypass the edge. With $SA$'s capacity being maximized, $S$ can reach $A$ in the residual network through $(SB,BC,\overline{AC})$.
+
+In practicality, we aren't saying that the $\epsilon$ units of flow needs to be strictly rerouted from $u$ to $v$ through some other pathway in the network. In the given case where $A$ is replaced by by hundreds of vertices lined up in series, we're not going to reroute the flow from $S$ to $A_1$, then back through $[A_2, A_3, ..., A_x, C]$. Instead, the process of updating the residual with the results of DFS will simply reduce the flow through the edges $[SA_1, A_1A_2,A_2A_3,...,A_xC]$, increasing the flow by the same amount through edges $[SB, BC]$. We don't actually need to perform this update on the residual network. We just need to demonstrate that it's possible.
+
+For completeness, when looking at $SA$, $S$ can't reach $T$. We already know this is the case because the flow is maximized, so there's no point in checking for it. However, that doesn't matter, because that's not the question. When evaluating $CT$ for criticality, we'll find that $C$ can't reach $T$ in the residual network, therefore demonstrating that $C$ is a critical edge. This is a special case, and not a general formulation of the process. In the event that $CT$ were bisected by another vertex $D$, we'd note that $C$ cannot reach $D$ in the residual network, thereby making both $CD$ and $DT$ critical.
+
+Note that this problem doesn't specify that the graph weights are integers. Therefore, we must use Edmonds-Karp, and cannot use Ford-Fulkerson.
+
+## Algorithm
+- Run Edmonds-Karp on $G$ to produce a maximum flow through $G$.
+- Reconstruct the residual network $G^f$.
+	- Initialize an empty graph $G^f$
+	- Add all the vertices of $G$ to $G^f$
+	- For each edge $vw \in E$
+		- Add $vw$ to $G^f$
+		- Add $wv$ to $G^f$
+		- Set $c^f_{vw}=c_{vw}-f_{vw}$ (for the forward flow)
+		- Set $c^f_{wv}=f_{vw}$ (for the reverse flow)
+- For each edge $uv \in E$ where $c_{uv}=f_{uv}$ (alternate check: $c^f_{uv}=0$
+	- Run DFS from $u$ in $G^f$
+	- Check whether $v$ is reachable ($post[v]<post[u]$)
+	- Return $uv$ if $v$ is not reachable.
+
+## Justification
+See above.
+
+## Runtime
+- EK: $O(nm^2)$
+- Reconstruct residual flow network: $O(n+m)$
+- Iterate over edges: $O(m)$
+	- Run DFS: $O(n+m)$
+
+Overall:
+- $O(nm^2+n+m+m(n+m))$
+- $O(nm^2+n+m+mn+m^2)$
+- $O(nm^2)$

OMSCS/Courses/GA/Practice Problems/7.21 - Critical Edges.md

@@ -0,0 +1,53 @@
+---
+tags:
+  - OMSCS
+  - Algorithms
+  - Practice
+---
+# 7.22 - Fast Max-Flow Recomputation
+> In a particular network $G=(V,E)$ whose edges have integer capacities $c_e$, we have already found the maximum flow $f$ from node $s$ to node $t$. However, we now find out that one of the capacity values we used was wrong: for edge $(u,v)$ we used $c_{uv}$ whereas it should have been $c_{uv}−1$. This is unfortunate because the flow $f$ uses that particular edge at full capacity: $f_{uv} = c_{uv}$.
+> 
+> We could redo the flow computation from scratch, but there’s a faster way. Show how a new optimal flow can be computed in $O(|V|+ |E|)$ time.
+
+
+## Exploration
+This is an extension of [[7.21 - Critical Edges]] which actually requires that we update the flows. We first need to check to see if that edge was critical. This can be done by reconstructing the residual network $G^f$ and then running DFS from $u$ in $G^f$ to see if $v$ is reachable.
+
+If $v$ is reachable from $u$ in $G^f$, we can use the results of DFS to update the flow. Starting from $v$, we can use $prev[]$ to retrace the steps back to $u$. This forms a uv-path in $G^f$. For each pair of vertices $a,b \in V$ encountered along the uv-path, we have an edge $e=(a,b)$ in the flow network. If the uv-path in $G^f$ traveled in the same direction of $e$ in $G$, we add 1 to $f_{ab}$. If the uv-path in $G^f$ traveled in the opposite direction of $e$ in $G$, we subtract 1 from $f_{ab}$.
+
+If $v$ is **not** reachable from $v$ in $G^f$, then edge $uv$ was a critical edge. This means that the overall flow through $G$ must be reduced by 1. In order to do this, we must find a us-path in $G^f$ via DFS (generating $prev_{us}$), and a tv-path in $G^f$ via DFS (generating $prev_{tv}$). For each of these paths, we must apply a similar procedure to the one above.
+
+- Starting from $s$, we can use $prev_{us}[]$ to retrace the steps "back" to $u$. Considering these vertices in reverse DFS order forms an su-path in $G^f$. For each pair of vertices $a,b \in V$ encountered along the su-path, we have an edge $e=(a,b)$ in the flow network. For each of these edges, we subtract 1 from $f_{ab}$.
+- Starting from $v$, we can use $prev_{tv}[]$ to retrace the steps "back" to $t$. Considering these vertices in reverse DFS order forms an vt-path in $G^f$. For each pair of vertices $a,b \in V$ encountered along the vt-path, we have an edge $e=(a,b)$ in the flow network. For each of these edges, we subtract 1 from $f_{ab}$.
+
+We finish off by making sure the original mistake was accounted for in $f$, by subtracting 1 from $f_{uv}$.
+
+## My Solution
+- Reconstruct the residual network $G^f$ from $f$, $G$, and $c$.
+- Run DFS from $u$ in $G^f$. We use $post[v]<post[u]$ to determine whether $v$ is reachable from $u$.
+- If $v$ is reachable from $u$ in $G^f$, then $uv$ is not a critical edge in $G$. This means the overall flow through flow network $G$ does not need to decrease, and can remain at $C$. We just need to find an alternate route for that unit of flow. We can retrace our steps from $v$ back to $u$ in $G$. For each edge encountered along the way, we increase or decrease the flow along that edge accordingly. If an edge in the uv-path in $G^f$ traveled in the same direction as the corresponding edge in $G$, we add 1 to that edge's flow in $f$. If an edge in the uv-path in $G^f$ traveled in the **opposite** direction as the corresponding edge in $G$, we subtract 1 from that edge's flow in $f$.
+- If $v$ is **not** reachable from $u$ in $G^f$, then $uv$ is a critical edge in $G$. This means the overall flow through flow network $G$ needs to be decreased by 1. Using the same $prev[]$ array, we can trace our steps from $s$ to $u$ in $G$. For each edge encountered along that path, we decrease its corresponding flow in $f$ by 1. We then run a new DFS from $t$ in $G^f$, to produce a path from $v$ to $t$. For each edge encountered along that path, we decrease the flow by 1.
+- We conclude by subtracting 1 from $f_e$ to account for the earlier mistake.
+
+Runtime $O(n+m)$
+
+## TA Solution
+The TA solution eliminates the conditional check as to whether $uv$ was a critical edge, and cleverly leverages the time complexity of Ford-Fulkerson.
+
+- Create $G^f$ from $f$.
+- Run $BFS(G^f,u)$, and backtrack using $prev[s]$ to find a path that produced at least one unit of flow from $s$ to $u$. We subtract 1 from the flow for each of those edges.
+- Run $BFS(G^f,t)$, and backtrack using $prev[v]$ to find a path that produced at least one unit of flow from $v$ to $t$. We subtract 1 from the flow for each of those edges.
+- Create a new capacity table for all edges in $G$, setting $c_e'=c_e-f_e$.
+- We then run Ford-Fulkerson on $G$ using $c_e'$, producing $f'$.
+	- We know that the overall flow through this new flow network ($C'$) is either 0 or 1.
+	- If $e$ was a critical edge, the overall flow through $G$ was decreased from $C$ to $C-1$. If this is the case, $C'=0$
+	- If $e$ was not a critical edge, the overall flow through $G$ remains at $C$. If this is the case, $C'=1$
+- The resulting flow is $f+f'$, with max flow $C-1+C'$
+
+Runtime:
+- 2 rounds of BFS: $O(n+m)$
+- Creating the new capacity table: $O(n)$
+- Ford-Fulkerson: $O(mC):C=1 \therefore O(m)$
+
+Since we don't know if the flow network is connected: Overall: $O(n+m)$
+

OMSCS/Courses/GA/Practice Problems/7.22 - Fast Max-Flow Recomputation (TODO).md

@@ -7,3 +7,176 @@ tags:
 # 7.24 - Direct Bipartite Matching (TODO)
 ![[Pasted image 20260317232024.png]]
 ![[Pasted image 20260317232036.png]]
+
+Covered vertices are shown with double circles. Non-covered vertices are shown as single circles. Edges that are in $M$ are shown in bold.
+
+```mermaid
+graph TD
+
+A(((A)))
+B(((B)))
+C(((C)))
+D((D))
+E(((E)))
+F(((F)))
+G((G))
+H(((H)))
+I((I))
+
+A <==> E
+A <--> H
+B <--> E
+B <==> F
+B <--> G
+C <--> G
+C <==> H
+C <--> I
+D <--> F
+```
+
+## Notes from Office Hours
+
+
+## 7.24a - Alternating Path
+All must start on $D$ and end on $G$ or $I$. These are the only non-covered vertices. None of these vertices can appear on the middle of the path since they're not covered, and therefore you can't arrive on an edge in $M$ and leave on an edge in $E-M$.
+
+Here's all distinct alternating paths.
+
+- $[D, F, B, E, A, H, C, I]$
+- $[D, F, B, E, A, H, C, G]$
+- $[D,F,B,G]$
+
+## 7.24b - Maximal Matching
+If a bipartite graph has a matching $M$ such there exists no alternating path AP, this could mean a couple of things.
+
+First, there may exist no uncovered vertices in $G$. If this is the case, there's no starting nor ending point for the AP.
+
+There may exist only one vertex $v$ in $G$ which is not covered. If this were the case, then there does not exist a 2nd uncovered vertex that $v$ could connect to via an AP. Further, APs cannot be a cycle. If you have an odd-length cycle in a graph, then the graph is not bipartite. This breaks the requirement that APs be odd in length.
+
+If there are any non-covered vertices which are connected, then $M$ is not maximal, because we can add the edge which connects those vertices to $M$.
+
+If there does exist an alternating path in $G,M$, then we can remove it.  For each edge $e$ along this path
+- if $e \in M$, then $M=M-\{e\}$
+- otherwise $M=M \cup \{e\}$
+
+Take AP $[D,F,B,G]$ from 7.24a. If we apply this procedure, we take the graph from this:
+
+```mermaid
+graph TD
+
+A(((A)))
+B(((B)))
+C(((C)))
+D((D))
+E(((E)))
+F(((F)))
+G((G))
+H(((H)))
+I((I))
+
+A <==> E
+A <--> H
+B <--> E
+B <==> F
+B <--> G
+C <--> G
+C <==> H
+C <--> I
+D <--> F
+```
+
+to this
+
+```mermaid
+graph TD
+
+A(((A)))
+B(((B)))
+C(((C)))
+D(((D)))
+E(((E)))
+F(((F)))
+G(((G)))
+H(((H)))
+I((I))
+
+A <==> E
+A <--> H
+B <--> E
+B <--> F
+B <==> G
+C <--> G
+C <==> H
+C <--> I
+D <==> F
+```
+
+Each time we apply this procedure, the number of edges in $M$ increases by 1. This is because an AP must be an odd length, and must start and end with an uncovered vertex. Therefore the number of edges in an AP which are in $M$ must be one less than the number of edges in AP which are in $E-M$. 
+
+$$|\{e : e \in M\}|-1=|\{e : e \in (E-M)\}|:e \in AP$$
+
+When we apply this procedure, the edges from AP which are not yet in M become part of M, and the edges from AP which are already in M are removed from M.
+
+We know that we can always apply this procedure to an AP. Given an AP, the first and last vertices are apart of none of the edges in $M$. Each vertex in the interior of the AP is apart of only one edge in $M$. Swapping the edges from one side of each interior vertex to another will not cause any of the vertices to appear in $M$ more than once.
+
+We also know that after applying this procedure to an AP, the number of uncovered vertices in the graph goes down by 2.
+
+Based on all of this, suppose that we have an $M$ which is not optimal in $G$. We can always find an AP in $G,M$, and apply this procedure to increase $|M|$ by one, and decrease the number of uncovered nodes by 2. We can continue applying this procedure until 1 or 0 uncovered vertices remain. At this point, $G,M$ will have no AP, making $M$ a maximal matching of $G$.
+
+## 7.24c - Finding a Matching Path
+Something we can do is convert $G$ to a directed graph. We can rebuild $G$ such that
+
+- edges which are in $M$ only connect from a vertex in $V_2$ to a vertex in $V_1$.
+- edges which are **not in** $M$ only connect from a vertex in $V_1$ to a vertex in $V_2$.
+
+If we apply this procedure to our example graph, we get this graph, which happens to be a DAG. Finding APs in this graph is now trivial. You can just run BFS from an uncovered node, and traceback from any reachable uncovered vertex.
+
+```mermaid
+graph TD
+
+A(((A)))
+B(((B)))
+C(((C)))
+D((D))
+E(((E)))
+F(((F)))
+G((G))
+H(((H)))
+I((I))
+
+E ==> A
+A --> H
+B --> E
+F ==> B
+B --> G
+C --> G
+H ==> C
+C --> I
+D --> F
+```
+
+If we apply this procedure to the variant of G which has no APs, you get this graph. This graph has no AP. You may notice this graph also has a cycle. Curious.
+
+```mermaid
+graph TD
+
+A(((A)))
+B(((B)))
+C(((C)))
+D(((D)))
+E(((E)))
+F(((F)))
+G(((G)))
+H(((H)))
+I((I))
+
+E ==> A
+A --> H
+B --> E
+B --> F
+G ==> B
+C --> G
+H ==> C
+C --> I
+F ==> D
+```

OMSCS/Courses/GA/Practice Problems/7.22 - Fast Max-Flow Recomputation.md

@@ -30,8 +30,8 @@ tags:
 - **7.19** – Suppose someone presents you with a solution to a max-flow problem on some network.
 	- [[7.19 - Max Flow Validation]]
 - **7.21** – critical edge
-	- [[7.21 - Critical Edges (TODO)]]
+	- [[7.21 - Critical Edges]]
 - **7.22** – In a particular network $G=(V,E)$ whose edges have integer capacities cece​...
-	- [[7.22 - Fast Max-Flow Recomputation (TODO)]]
+	- [[7.22 - Fast Max-Flow Recomputation]]
 - **7.24** – _Direct bipartite matching._
 	- [[7.24 - Direct Bipartite Matching (TODO)]]