Practice Problems from DPV CH3

Author: AustinTSchaffer

OMSCS/Courses/GA/04.0.1 - Graphs - Black Box Algorithms.md

@@ -177,7 +177,7 @@ For the graphs section of this course, you must use the algorithms presented in
 - `iter[][]`
 	- A 2D list containing the first indexed iteration's shortest path from the starting vertex to the second indexed vertex.
 	- For example, `iter[3][v]` contains the distance from the starting vertex to `v` at the end of the 3rd iteration.
-	- This stable contains iterations 0 through `n`
+	- This table contains iterations 0 through `n`
 
 **Runtime:** $O(nm)$
 

OMSCS/Courses/GA/04.1 - Graphs - SCCs.md

@@ -45,24 +45,24 @@ How do we get connectivity info for directed G?
 ## Types of Edges
 ![[Pasted image 20260227124812.png]]
 
-For a given DFS tree, with pre/postorder numbers, and  For a given edge $e=(z,w)$, the edge can have one of the following types.
+For a given DFS tree, with pre/postorder numbers, and  For a given edge $e=(a,b)$, the edge can have one of the following types.
 
 - tree-edge
 	- B->A, A->D
-	- pre(z) < pre(w)
-	- post(z) > post(w)
+	- pre(a) < pre(b)
+	- post(a) > post(b)
 - back edge
 	- E->A, F->B
-	- pre(z) > pre(w)
-	- post(z) < post(w)
+	- pre(a) > pre(b)
+	- post(a) < post(b)
 - forward
 	- D->G, B->E
-	- pre(z) < pre(w)
-	- post(z) > post(w)
+	- pre(a) < pre(b)
+	- post(a) > post(b)
 - cross
 	- F->H, H->G
-	- pre(z) > post(w)
-	- post(z) > post(w)
+	- pre(a) > post(a)
+	- post(a) > post(a)
 	- There's no situation where the back edge goes the other way. If there's a cross edge pointing the other direction, DFS should have explored that edge and it would actually be a tree-edge.
 
 For back-edges, the post order number goes up. For all other edge types, the post-order number goes down.

OMSCS/Courses/GA/Practice Problems/3.1 - DFS on Undirected G.md

@@ -0,0 +1,58 @@
+---
+tags:
+  - OMSCS
+  - Algorithms
+  - Practice
+  - Alg-Graph
+---
+# 3.1 - DFS on Undirected G
+![[Pasted image 20260313091135.png]]
+
+Graph rewritten in mermaid.
+
+```mermaid
+graph LR
+A --- B
+B --- C
+C --- F
+A --- E
+B --- E
+E --- F
+F --- I
+D --- G
+G --- H
+D --- H
+```
+
+Ignore the directed arrows. This graph is meant to be undirected.
+
+| V   | Pre | Post |
+| --- | --- | ---- |
+| A   | 1   | 12   |
+| B   | 2   | 11   |
+| C   | 3   | 10   |
+| D   | 13  | 18   |
+| E   | 5   | 6    |
+| F   | 4   | 9    |
+| G   | 14  | 17   |
+| H   | 15  | 16   |
+| I   | 7   | 8    |
+- **Tree Edges:**
+	- Tree 1: AB, BC, CF, FE, FI
+	- Tree 2: DG, GH
+- **Back-Edges:**
+	- Tree 1: EA, EB
+	- Tree 2: HD
+
+```mermaid
+graph TD
+
+A --- B --- C --- F --- I
+F --- E
+
+D --- G --- H
+
+E -.- A
+E -.- B
+H -.- D
+```

OMSCS/Courses/GA/Practice Problems/3.11 - Linear-Time Cycle Detection.md

@@ -0,0 +1,27 @@
+---
+tags:
+  - OMSCS
+  - Algorithms
+  - Practice
+  - Alg-Graph
+---
+# 3.11 - Linear-Time Cycle Detection
+> Design a linear-time algorithm which, given an undirected graph G and a particular edge e in it, determines whether G has a cycle containing e.
+
+## Exploration
+We know that since this is an undirected graph, given an edge $e=(u,v)$, there will be no $e'=(v,u)$. Therefore, any cycle involving $e$ must also include some vertex $w$ before returning to $v$ or $u$. If we 
+
+## Algorithm
+Given an edge $e=(u,v)$, remove $e$ from $G$. Run BFS from $u$. If $dist[v] \ne \infty$, then $G$ contains (contained?) a cycle containing edge $e$.
+
+## Justification
+If there exists a cycle $C$ in $G=(V,E)$, and $e=(u,v)\in C$, then there are at least 2 paths from $u$ to $v$ in $G$. One of those paths is simply $P=[e]$. Another possible path is $P=C-[e]$. If we remove $e$ from $E$, then the path $P=C-[e]$ may still exist in $G$. If we determine that a path still exists in $G$ from $u$ to $v$ after removing $e$, then adding $e$ back in to $G$ creates a cycle. If $e$ was the only edge connecting 2 disjoint subgraphs, each containing either $u$ or $v$, then there will be no route between the 2 vertices in $G'$.
+
+I used BFS for this because this course overly relies on DFS. You can check if $v$ was reachable from $u$ by checking the distance result. We also could have used DFS for this, using the ccnum result. The ccnum result is valid here, since G is undirected.
+
+## Runtime
+- Removing $e$: $O(n)$
+- Running BFS from $u$: $O(n+m)$
+- Checking `dist[v]`: O(1)
+
+Overall: $O(n+m)$

OMSCS/Courses/GA/Practice Problems/3.2 - DFS on Directed Graphs.md

@@ -0,0 +1,128 @@
+---
+tags:
+  - OMSCS
+  - Algorithms
+  - Practice
+---
+# 3.2 - DFS on Directed Graphs
+![[Pasted image 20260313091325.png]]
+
+## 3.2a
+
+```mermaid
+graph
+
+A --> B
+A --> F
+B --> C
+B --> E
+C --> D
+E --> D
+E --> G
+D --> B
+D --> H
+
+F --> E
+F --> G
+G --> F
+
+H --> G
+```
+
+There is a route directly through the graph which touches all vertices, and the vertices are labeled in such a way that the DFS takes this route every time. Therefore, the pre/post numbers are kind of obvious, especially when you arrange the table by preorder number.
+
+| V   | Pre | Post |
+| --- | --- | ---- |
+| A   | 1   | 16   |
+| B   | 2   | 15   |
+| C   | 3   | 14   |
+| D   | 4   | 13   |
+| H   | 5   | 12   |
+| G   | 6   | 11   |
+| F   | 7   | 10   |
+| E   | 8   | 9    |
+
+Here's the graph again but with Back (B) and Cross (X) edges labelled accordingly. The unlabeled edges are the tree edges.
+
+```mermaid
+graph
+
+A --> B
+B --> C
+
+C --> D
+D --> H
+
+F --> E
+G --> F
+
+H --> G
+
+A -.X-.-> F
+B -.X-.-> E
+
+D -.B-.-> B
+E -.B-.-> D
+F -.B-.-> G
+E -.B-.-> G
+
+```
+## 3.2b
+```mermaid
+graph
+
+A --> B
+A --> H
+
+B --> F
+
+C --> B
+
+D --> C
+D --> E
+
+F --> C
+F --> D
+F --> E
+
+G --> A
+G --> B
+G --> F
+H --> G
+```
+
+I did all of these on paper first. This was the first problem where I realized that incrementally building the Pre/Post table along with the Tree/Back/Cross edge lists, was the best way to stay organized. Staying organized means you can do this problem manually in linear time, just like the algorithms.
+
+| V   | Pre | Post |
+| --- | --- | ---- |
+| A   | 1   | 16   |
+| B   | 2   | 11   |
+| C   | 4   | 5    |
+| D   | 6   | 9    |
+| E   | 7   | 8    |
+| F   | 3   | 10   |
+| G   | 13  | 14   |
+| H   | 12  | 15   |
+- **Tree Edges:** AB, BF, FC, FD, DE, AH, HG
+- **Back Edges:** CB, GA
+- **Cross Edges:** DC, FE, GB, GF
+
+```mermaid
+graph
+
+A --> B
+B --> F
+F --> C
+F --> D
+D --> E
+A --> H
+H --> G
+
+C -.B-.-> B
+G -.B-.-> A
+
+D -.X-.-> C
+F -.X-.-> E
+G -.X-.-> B
+G -.X-.-> F
+```

OMSCS/Courses/GA/Practice Problems/3.7 - Bipartite Graphs.md

@@ -0,0 +1,113 @@
+---
+tags:
+  - OMSCS
+  - Algorithms
+  - Practice
+---
+# 3.7 - Bipartite Graphs
+![[Pasted image 20260313092928.png]]
+
+## 3.7a - Give a Linear-Time Algorithm...
+> Give a linear-time algorithm to determine whether an undirected graph is bipartite.
+
+The hint for the solution is the non-sequitur at the beginning of the 3.7b prompt.
+
+> There are many other ways to formulate this property. For instance, an undirected graph is bipartite iff it can be colored with just 2 colors.
+
+If you were to color the natural numbers with only 2 colors, you'd color the even numbers black, and the odd numbers white. We can apply this principle here.
+
+### Algorithm 1 (My Work)
+Given an undirected graph, first apply BFS to any arbitrary vertex v in G. Modify the output of BFS, setting the distance from v to v to 0. If there are any vertices which were not reached by the BFS, indicated by an infinite distance from v, continue applying this procedure to arbitrary unreached vertices, merging the distance arrays together at the end. Next, we iterate over all edges in G, and see if it connects a vertex with an even distance to a vertex with an even distance, or a vertex with an odd distance to a vertex with an odd distance. If this is the case, then G is not bipartite. If no such edge is found, then G is bipartite.
+
+This algorithm works because we're using ($dist[v] \mod 2$) as a coloring function. If 2 adjacent vertices have the same "color", then the graph cannot be bipartite.
+
+The issue with this algorithm is the possibility of disconnected graphs. If G consists of $n/5$ uniform bipartite subgraphs of 5 vertices each, then we will need to run BFS $O(n/5)=O(n)$ times. Each of the $n/5$ iterations of BFS needs to perform work linear in the size of $G$. This is because each iteration of BFS must initialize `dist[]` and `prev[]` of length $n$, regardless of the number of vertices which end up being reachable from $s$.
+
+Further, there is an issue at the end of merging $n/5$ `dist[]` arrays, each of length $n$. You can probably avoid this merging operation if you check the coloring in between each execution of BFS. There's likely a way to do this in linear time, effectively you'd need to start by iterating over each edge in $G$ performing the coloring check in an outer loop, and only run BFS when you come across a vertex which has no color.
+
+Regardless, you can't get around the fact that BFS starts with no knowledge of the graph, does not restart when its internal queue is empty, and you can't "bring your own" distance/prev arrays in the black-box implementation as stated in [[04.0.1 - Graphs - Black Box Algorithms]].
+
+
+### Algorithm 2 (From Classmate)
+This solution was inspired by a classmate.
+
+Run DFS on the graph, producing the pre-order and post-order numbers. Iterate over all the edges in G.
+
+From [[04.1 - Graphs - SCCs]], we know that an edge $e=(u,v)$ is a "back edge" if the postorder number of v ($post[v]$) is higher than the postorder number of u ($post[u] < post[v]$). Using this property, we can iterate over the edges in $G$ and check whether it's a back edge or not.
+
+Next, we need to check and see if that backedge forms a cycle of odd length. This occurs when the difference between 
+
+If no such edge is found then the graph is bipartite.
+
+> A bipartate graph is one where it can be split into two sets where there is no edge connecting any of the vertices within the same set. To accomplish this, there cannot be a cycle containing an odd number of vertices.
+> 
+> To detect this, our algorithm detects all backedges (an indicator that there is a cycle) and checks the difference in post order numbers. If the difference is even, then we know that there are an add number of vertices within the cycle. So long as no backedges meet this criteria then the graph can be made into a bipartate graph.
+
+See the DFS tree below, with (pre,post) order labelling and backedges noted. Note the backedges, and note how the postorder numbers differ by an even amount on all of these backedges. Any single one of those backedges invalidates $G$ from being bipartite.
+
+```mermaid
+graph TD
+
+A["A (1,10)"]
+B["B (2,9)"]
+C["C (3,6)"]
+D["D (7,8)"]
+E["E (4,5)"]
+
+A --> B
+B --> D
+C --> E
+B --> C
+
+C -.B-.-> A
+D -.B-.-> A
+E -.B-.-> B
+```
+
+Here's the same graph but with an alternate set of backedges. None of these backedges invalidate G from being bipartite, as they all connect a vertex with an even postorder to a vertex with an odd postorder. Therefore, none of them form an odd cycle.
+
+```mermaid
+graph TD
+
+A["A (1,10)"]
+B["B (2,9)"]
+C["C (3,6)"]
+D["D (7,8)"]
+E["E (4,5)"]
+
+A --> B
+B --> D
+C --> E
+B --> C
+
+E -.B-.-> C
+B -.B-.-> A
+C -.B-.-> B
+E -.B-.-> A
+D -.B-.-> B
+```
+
+### Algorithm 2 (From TA)
+We can convert this problem to a 2-SAT problem. See [[04.2 - Graphs - 2-SAT]] for details on that algorithm. To encode this problem as a 2-SAT problem, we need to define the problem in terms of the conjunctive AND of multiple OR clauses, each with 2 literals. How do we do this?
+
+In a bipartite graph, all edges must connect one vertex $v \in S_1$ with a vertex in $u \in S_2$. $V = S_1 \cup S_2$ and $S_1 \cap S_2=\emptyset$. Therefore, we need to model vertex $v$ as being in one set or the other set, and vertex $u$ as being in the opposite set. This can be accomplished as an exclusive-or (XOR).
+
+- The variable $v_i$ indicates the question "Is $v_i \in S_1$?".
+- The literal $v_i$ indicates the answer "$v_i \in S_1$" and simultaneously "$v_i \notin S_2$"
+- The literal $\overline{v_i}$ indicates the answer "$v_i \notin S_1$" and simultaneously "$v_i \in S_2$"
+
+For each edge $e=(v_a, v_b) \in E$, we know that $G$ must be bipartite if:
+$$\big(v_a \wedge \overline{v_b}\big) \vee \big(\overline{v_a} \wedge v_b\big)$$
+
+We can reframe this XOR condition in CNF thusly:
+$$\big(v_a \vee v_b\big) \wedge \big(\overline{v_a} \vee \overline{v_b}\big) $$
+
+Taking the AND across all of these CNF-XOR conditions produces a 2-SAT problem. The conversion from $G$ to $f$ takes $O(n+m)$ time. The 2-SAT algorithm takes $O(n+m)$ time.
+
+## 3.7b - Odd Cycles
+We can't have an odd-length cycle in a bipartite graph, because each edge must connect a vertex $v \in S_1$ with a vertex in $u \in S_2$, where $V = S_1 \cup S_2$ and $S_1 \cap S_2=\emptyset$.
+
+Let's assume that $G$ is a bipartite graph containing an $L$-length cycle, where $L$ is odd. Let's pick some vertex $a$ which is in $S_1$, and is part of the odd-length cycle. If we traverse around the cycle, we reach a vertex in $S_2$, then a vertex in $S_1$, then a vertex in $S_2$. After all even numbered steps, we've reached a vertex in $S_1$. After all odd numbered steps, we've reached a vertex in $S_2$. After $L$ steps, which is an odd number of steps, we've reached vertex $a$, which must be in $S_2$. This presents a contradiction. $a$ must be in both $S_1$ and $S_2$, but the intersection of $S_1$ and $S_2$ is the empty set. Therefore, our initial assumption that $G$ is bipartite is incorrect.
+
+## 3.7c - Coloring Odd-Length Cycles
+You need 3 colors. As you traverse around the cycle, you must give each vertex an alternating color. At the end, you will have 2 adjacent vertices which have the same color. You'll need to change one of them to some third color. QED.