diff --git a/writeup.md b/writeup.md
index eda66f5..c48d986 100644
--- a/writeup.md
+++ b/writeup.md
@@ -2,8 +2,200 @@
 
 ## Student Responses
 
-<!-- Write your solutions below. Add sections for each problem as needed. -->
-<!-- Use proper mathematical notation where applicable. -->
+---
 
-[Your solutions here]
+## Problem 1: True or False
 
+### Part (a)
+
+**TRUE.**
+
+**Proof:** Let f be any maximum flow in G. If f contains a cycle C = (v₁ → v₂ → ... → vₖ → v₁) in which every edge has positive flow, let ε = min_{e ∈ C} f(e) > 0. Define a new flow f' by:
+- f'(e) = f(e) − ε for every edge e in C
+- f'(e) = f(e) for every edge not in C
+
+This is a valid flow: capacity constraints hold (we only decreased flow on cycle edges), and flow conservation holds at every vertex because we removed a balanced cycle (each vertex in C has one unit of ε removed from both its incoming and outgoing cycle edges). The total flow value |f'| = |f|, since the cycle contributes zero net flow from s to t.
+
+Note that f' has strictly fewer edges carrying positive flow than f (the edge(s) achieving the minimum are reduced to 0). Since edge flows are bounded below by 0, repeatedly applying this process terminates. The final flow is a maximum flow with no cycle of positive flow.
+
+---
+
+### Part (b)
+
+**FALSE.**
+
+**Counterexample:** Consider the graph with nodes s, a, b, t and edges:
+- s → a: capacity 2
+- s → b: capacity 3
+- a → t: capacity 4
+- b → t: capacity 5
+- a → b: capacity 6
+
+All five capacities are distinct. The minimum cut is {s} | {a,b,t} with capacity 2 + 3 = 5, so the maximum flow value is 5. Both s → a and s → b must be saturated.
+
+For any 0 ≤ x ≤ 2, the following is a valid maximum flow of value 5:
+- f(s→a) = 2, f(s→b) = 3, f(a→t) = 2−x, f(a→b) = x, f(b→t) = 3+x
+
+Every such flow has value 5. Since x can range over [0, 2], there are infinitely many maximum flows, so the maximum flow is not unique even with distinct capacities.
+
+---
+
+### Part (c)
+
+**TRUE.**
+
+**Proof:** Let λ > 0. For any s-t cut (S, T), its capacity after multiplying all edges by λ is:
+
+cap_λ(S, T) = Σ_{(u,v) ∈ E, u ∈ S, v ∈ T} λ · c(u,v) = λ · cap(S, T)
+
+Since λ > 0 is a common positive factor, the relative ordering of all cuts by capacity is preserved:
+
+cap(S₁, T₁) ≤ cap(S₂, T₂)  ⟺  cap_λ(S₁, T₁) ≤ cap_λ(S₂, T₂)
+
+Therefore the cut(s) achieving the minimum are exactly the same before and after scaling. The minimum cut (as a set of edges forming the partition) is unchanged.
+
+---
+
+### Part (d)
+
+**FALSE.**
+
+**Counterexample:** Consider the graph with nodes s, a, b, c, d, t and edges:
+- s → a: capacity 10
+- a → b, a → c, a → d: each capacity 1
+- b → t, c → t, d → t: each capacity 1
+
+Key cuts:
+- Cut A: {s} | {a,b,c,d,t} — capacity = 10 (single edge s→a)
+- Cut B: {s,a} | {b,c,d,t} — capacity = 1+1+1 = 3 (three edges)
+
+Initially, Cut B is the minimum cut with capacity 3 (< 10 = capacity of Cut A).
+
+After adding λ = 4 to every edge capacity:
+- Cut A: capacity = 10 + 4 = 14
+- Cut B: capacity = (1+4)+(1+4)+(1+4) = 15
+
+Now Cut A (value 14) is smaller than Cut B (value 15), so the minimum cut has **changed** from Cut B to Cut A. The minimum cut does not stay unchanged.
+
+(In general, adding λ to each edge increases a cut with k crossing edges by kλ, so cuts with more edges are penalized more. A cut that was minimum because its edges were small can become non-minimum once λ is large enough.)
+
+---
+
+## Problem 2: Flow Reduction
+
+**Goal:** Given a unit-capacity flow network G = (V, E) with source s and sink t, find a set F ⊆ E with |F| = k that minimizes the maximum s-t flow in G' = (V, E \ F).
+
+**Key Observation:** Let c* = max-flow in G = value of the minimum s-t cut in G (by Max-Flow Min-Cut theorem). We claim the minimum achievable max-flow after removing k edges is max(0, c* − k), and it is achieved by removing k edges from the minimum cut.
+
+**Lower bound:** For any set F with |F| = k, the max-flow in G' satisfies:
+
+max-flow(G') = min-cut(G') = min_{(S,T)} cap_{G'}(S, T)
+
+For any cut (S, T):
+cap_{G'}(S, T) = cap_G(S, T) − |F ∩ E(S,T)|  ≥  cap_G(S, T) − k  ≥  c* − k
+
+(The last inequality uses c* ≤ cap_G(S, T) for every cut, since c* is the minimum.) Taking the min over all cuts: max-flow(G') ≥ max(0, c* − k).
+
+**Upper bound:** By removing k edges from the minimum cut, we achieve max-flow(G') ≤ c* − k (for k ≤ c*) or 0 (for k > c*).
+
+**Algorithm:**
+1. Compute a maximum flow in G using any standard algorithm. Record the flow value c*.
+2. Find the corresponding minimum s-t cut (S*, T*) by BFS/DFS from s in the residual graph; S* = vertices reachable from s.
+3. Let C = {edges (u,v) ∈ E : u ∈ S*, v ∉ S*} be the set of cut edges. Note |C| = c*.
+4. If k ≤ c*: set F = any k edges from C.
+5. If k > c*: set F = C ∪ (any k − c* edges from E \ C).
+6. Return F.
+
+**Correctness:** By the argument above, F achieves max-flow max(0, c* − k) in G', which is optimal.
+
+**Complexity:** For unit-capacity graphs, max flow can be computed in O(E · √V) time (via Hopcroft-Karp-style blocking flows). Finding the min cut via BFS on the residual graph takes O(V + E). The total running time is **O(E√V)**, which is polynomial in |V| and |E| (k does not appear in the exponent).
+
+---
+
+## Problem 3: Node Capacities
+
+**Problem:** Find a maximum s-t flow in a graph where each node v has a capacity cᵥ constraining the total incoming flow f^in(v) ≤ cᵥ.
+
+**Algorithm: Node Splitting**
+
+Construct a new "edge-capacitated" flow network G' = (V', E') as follows:
+
+1. **Node splitting:** For each vertex v ∈ V, create two vertices v_in and v_out with a directed edge (v_in → v_out) of capacity cᵥ.
+2. **Original edges:** For each directed edge (u, v) ∈ E, add the edge (u_out → v_in) in E' with capacity ∞ (or any value ≥ sum of all node capacities).
+3. **Source and sink:** The new source is s_out (or equivalently s_in, since s_in → s_out has capacity cₛ which bounds flow through s). Use s_out as source and t_in as sink. (If the problem states s and t have no incoming capacity constraint, set c_s = c_t = ∞.)
+
+Run any standard max-flow algorithm on G' from s_out to t_in. Return the maximum flow value.
+
+**Correctness:** Each unit of flow passing through a node v in the original graph must traverse the edge v_in → v_out in G'. Since this edge has capacity cᵥ, at most cᵥ units of flow can pass through v. This exactly enforces the node capacity constraint f^in(v) ≤ cᵥ. Flow conservation and capacity constraints on original edges are preserved because the (u_out → v_in) edges have infinite capacity (they do not restrict flow beyond what the node edges already do). A flow in G is feasible if and only if the corresponding flow in G' is feasible.
+
+**Complexity:**
+- G' has |V'| = 2|V| vertices and |E'| = |E| + |V| edges.
+- Running Edmonds-Karp on G' takes O(|V| · |E|²) time (with |V|, |E| referring to the original graph).
+- This is polynomial in the input size, so the algorithm runs in **polynomial time**.
+
+---
+
+## Problem 4: Station Closing
+
+**Problem:** Given an undirected graph G = (V, E) (stations = vertices, rail lines = edges), find the minimum number of vertices (other than A and B) to remove so that no path exists from A to B.
+
+This is the **minimum vertex cut** problem (restricted to internal vertices), which reduces to a max-flow problem via node splitting.
+
+**Algorithm:**
+
+1. **Build G':** Apply node splitting to every vertex except A and B:
+   - For each vertex v ∉ {A, B}: create v_in and v_out with edge (v_in → v_out) of capacity 1.
+   - For A: use A as source (or add A_in → A_out with capacity ∞, since A cannot be closed).
+   - For B: similarly, add B_in → B_out with capacity ∞ (B cannot be closed).
+   - For each undirected edge {u, v} ∈ E: add directed edges (u_out → v_in) and (v_out → u_in) with capacity ∞.
+
+2. **Run max flow** from A_out to B_in in G'.
+
+3. **Output:** The value of the maximum flow equals the minimum number of stations to close.
+
+**Correctness:** By the max-flow min-cut theorem, the max flow equals the minimum cut in G'. Any finite-capacity cut must consist entirely of internal node edges (v_in → v_out) of capacity 1, since the edge copies and A/B internal edges have infinite capacity. Each node edge (v_in → v_out) in the cut corresponds to closing station v. A min cut separates A_out from B_in if and only if the corresponding closed stations block all A-to-B paths. Since the original graph is undirected (both directions are included), every path from A to B in G corresponds to a directed path from A_out to B_in in G'.
+
+**Complexity:** G' has O(|V|) vertices and O(|E| + |V|) edges. Edmonds-Karp on G' runs in **O(|V|³)** or O(|V| · |E|²) time, which is polynomial.
+
+---
+
+## Problem 5: Exam Scheduling
+
+**Problem:** Assign each of n classes a room and time slot such that:
+- Class i is in room j only if E[i] < S[j].
+- At most one exam per (room, time slot) pair.
+- Every class is assigned.
+
+**Algorithm: Max-Flow on a Bipartite Graph**
+
+Build a flow network with the following nodes and edges:
+
+- **Source** s and **Sink** t.
+- **Class nodes:** One node cᵢ for each class i (1 ≤ i ≤ n).
+- **Room nodes:** One node rⱼ for each room j (1 ≤ j ≤ r).
+
+Edges:
+1. s → cᵢ with capacity 1, for each class i. (Each class needs exactly one assignment.)
+2. cᵢ → rⱼ with capacity 1, for each (i,j) pair where E[i] < S[j]. (Class i is eligible for room j.)
+3. rⱼ → t with capacity t, for each room j. (Room j has t time slots, so it can host at most t exams total.)
+
+Compute the maximum flow from s to t.
+
+**Output:**
+- If max flow = n: a valid assignment exists. For each class i, it is assigned to the room rⱼ for which f(cᵢ → rⱼ) = 1. Time slots are assigned greedily: for each room, number the assigned classes 1, 2, ... and give them time slots 1, 2, ... (at most t per room).
+- If max flow < n: no valid assignment exists.
+
+**Correctness:**
+- Each s → cᵢ edge (cap 1) ensures class i is assigned to at most one room.
+- Each rⱼ → t edge (cap t) ensures at most t classes are assigned to room j — one per time slot.
+- The edge cᵢ → rⱼ exists only when E[i] < S[j], enforcing the size constraint.
+- A max flow of n saturates all s → cᵢ edges, meaning every class is assigned. If fewer than n units flow, some class cannot be assigned.
+- The time-slot step works: if k ≤ t classes are assigned to the same room, assigning them distinct time slots 1 through k is always feasible.
+
+**Complexity:**
+- |V| = n + r + 2 nodes.
+- |E| ≤ n + nr + r edges (at most one edge per (class, room) pair).
+- The maximum flow value is at most n.
+- Using BFS-based augmenting paths, each augmentation takes O(|E|) = O(nr) time and increases flow by at least 1, so there are at most n augmentations.
+- **Total time: O(n²r).**
+- Alternatively, using Hopcroft-Karp-style blocking flows (since this is a unit-supply network): **O(nr√n)**.