🖨️ Printing Instructions: Press Ctrl/Cmd + P and select "Save as PDF".

Prim's, Kruskal's, and the Cut Property

Learning Goals

Understand the Minimum Spanning Tree problem.
Master Kruskal's algorithm with Union-Find.
Master Prim's algorithm with priority queues.
Learn the Cut Property and correctness proofs.

Problem Definition

Spanning Tree

Given a connected, weighted graph $G = (V, E)$.
A Spanning Tree $T$ is a subset of $E$ that:
1. Touches all vertices $V$.
2. Is Connected.
3. Is Acyclic (Tree).
A spanning tree always has exactly $|V| - 1$ edges.
A graph can have many spanning trees.

Minimum Spanning Tree (MST)

Cost of tree = sum of edge weights.
Goal: Find a spanning tree with minimum total cost.
Applications: Network design (Cable TV, Roads, Circuitry).
Key idea: Connect everyone as cheaply as possible.

Uniqueness

If all edge weights are distinct, the MST is unique.
If weights are not distinct, there may be multiple MSTs — but all share the same total cost.
Prerequisite: The graph must be connected. Otherwise, no spanning tree exists (we get a Minimum Spanning Forest).

The Cut Property

Definition of a Cut

A Cut $(S, V \setminus S)$ partitions vertices into two non-empty sets.
An edge crosses the cut if one endpoint is in $S$ and the other in $V \setminus S$.
A cut respects a set of edges $A$ if no edge in $A$ crosses the cut.

The Cut Property (Crucial)

Theorem: For any cut, the minimum-weight edge crossing the cut belongs to some MST.
Intuition: To connect $S$ and $V \setminus S$, we MUST pick at least one crossing edge. Be greedy — pick the cheapest.
This single property justifies both Prim's and Kruskal's algorithms.

Proof of Cut Property

Suppose MST $T$ does not contain the min-weight crossing edge $e$.
Adding $e$ to $T$ creates a cycle.
This cycle must cross the cut again via some other edge $e'$.
Since $w(e) \le w(e')$, replacing $e'$ with $e$ gives a tree with weight $\le w(T)$.
If $w(e) < w(e')$, the new tree is strictly cheaper — contradicting that $T$ is an MST.

Generic Greedy MST

Generic Algorithm

$A = \emptyset$.
While $A$ is not a spanning tree:
Find a cut that respects $A$ (no edge in $A$ crosses it).
Add the light edge (min-weight crossing edge) to $A$.
Return $A$.
Both Prim's and Kruskal's are instantiations of this framework.

Two Instantiations

1. Prim's Algorithm: Cut separates "In Tree" from "Not In Tree". Grows one tree outward.
2. Kruskal's Algorithm: Cut separates components in a forest. Merges components together.

Kruskal's Algorithm

Strategy

Sort all edges by weight (ascending).
Iterate through edges in order.
If edge $(u, v)$ connects two different components → Add it.
If $u$ and $v$ are already connected → Discard it (would create a cycle).
Stop when we have $|V| - 1$ edges.

Kruskal(G)

A = empty
for each vertex v:
    Make-Set(v)
Sort edges E by weight ascending
for each edge (u, v) in sorted E:
    if Find-Set(u) != Find-Set(v):
        A = A ∪ {(u, v)}
        Union(u, v)
return A

Disjoint Set Union (DSU / Union-Find)

Data structure to track which component each vertex belongs to.
Make-Set(x): Create singleton set $\{x\}$.
Find-Set(x): Return representative of the set containing $x$.
Union(x, y): Merge the sets containing $x$ and $y$.
Optimizations: Path Compression + Union by Rank.
With both optimizations, $m$ operations run in $O(m \cdot \alpha(n))$ — nearly $O(m)$.

Kruskal's Analysis

Sorting edges: $O(E \log E)$.
DSU operations: $O(E) \cdot \alpha(V) \approx O(E)$.
Total: $O(E \log E) = O(E \log V)$.
(Since $E \le V^2$, we have $\log E \le 2 \log V = O(\log V)$.)

Kruskal Trace

Edges: (A,B,1), (C,D,2), (A,C,4), (B,C,5).
Step 1: Pick (A,B,1). Components: {A,B}, {C}, {D}.
Step 2: Pick (C,D,2). Components: {A,B}, {C,D}.
Step 3: Pick (A,C,4). Merges {A,B} and {C,D}. Component: {A,B,C,D}.
Step 4: (B,C,5) — same component. Discard.
MST edges: (A,B), (C,D), (A,C). Total cost: 1 + 2 + 4 = 7.

Interactive: Kruskal's Algorithm

🚀 Interactive Demo: kruskal_demo.html

Prim's Algorithm

Strategy

Start from an arbitrary root vertex $r$.
Maintain set $S$ of vertices already in the tree.
At each step, add the minimum-weight edge connecting $S$ to $V \setminus S$.
Repeat until all vertices are in $S$.
Very similar in structure to Dijkstra's algorithm.

Prim(G, r)

for each u in V:
    key[u] = ∞
    π[u] = NIL
key[r] = 0
Q = V   // Min-priority queue keyed by key[]
while Q is not empty:
    u = Extract-Min(Q)
    for each v in Adj[u]:
        if v ∈ Q and w(u, v) < key[v]:
            π[v] = u
            key[v] = w(u, v)   // Decrease-Key

Prim's Key Concepts

key[v]: Minimum weight of any edge connecting $v$ to the current tree.
π[v]: The vertex in the tree that causes $v$'s key value (parent in MST).
When $u$ is extracted, edge $(\pi[u], u)$ is added to the MST.
Neighbors of $u$ may get cheaper connections — update their keys (relaxation).

Prim's Analysis

Priority queue operations:
$|V|$ Extract-Min operations.
Up to $|E|$ Decrease-Key operations.
With Binary Heap: $O((V + E) \log V) = O(E \log V)$.
With Fibonacci Heap: $O(E + V \log V)$.
Identical complexity profile to Dijkstra's algorithm.

Prim Trace

Graph: A—B (weight 1), A—C (weight 4), B—C (weight 2). Start at A.
Init Q: [(A, 0), (B, ∞), (C, ∞)].
Pop A. Update neighbors: key[B] = 1, key[C] = 4.
Q: [(B, 1), (C, 4)].
Pop B. Neighbor C has w(B,C) = 2 < key[C] = 4. Update key[C] = 2, π[C] = B.
Q: [(C, 2)].
Pop C. Q empty. Done.
MST edges: (A, B) and (B, C). Total cost: 1 + 2 = 3.

Interactive: Prim's Algorithm

🚀 Interactive Demo: prim_demo.html

Comparison

Kruskal vs Prim

Kruskal's Algorithm
Best for sparse graphs ($E \approx V$).
Easy to implement with Union-Find.
Logic: Globally sort edges, merge components.
Prim's Algorithm
Best for dense graphs ($E \approx V^2$); with adjacency matrix: $O(V^2)$.
Logic: Locally grow a single tree.
Both run in $O(E \log V)$ with standard data structures.

Advanced Topics

Reverse-Delete Algorithm

Start with all edges (the full graph).
Sort edges in descending order of weight.
For each edge: if removing it does not disconnect the graph, remove it.
Result is an MST. (Reverse greedy — dual of Kruskal's.)
Slower in practice: connectivity checks are expensive.

Borůvka's Algorithm

Oldest MST algorithm (1926).
For each component, find the cheapest edge leaving it.
Add all such edges simultaneously. Merge components.
Repeat until one component remains.
Each phase halves the number of components → $O(\log V)$ phases.
Total: $O(E \log V)$. Highly parallelizable.

Practice Problems

Problem 1: Heaviest Edge

Q: Can the heaviest edge in the graph be in the MST?
A: Usually no — but yes if it is a bridge (the only edge connecting two parts of the graph).
Example: A graph shaped like a dumbbell where the heaviest edge is the only connection.

Problem 2: Lightest Edge

Q: Is the lightest edge in the graph always in the MST?
A: Yes, always.
Proof: Consider the cut that isolates one endpoint of the lightest edge. That edge is the minimum-weight crossing edge. By the Cut Property, it belongs to every MST.

Problem 3: Squaring Weights

Q: If we square all edge weights, does the MST change?
A: No (assuming all weights are positive).
For positive values: $w_1 < w_2 \Rightarrow w_1^2 < w_2^2$.
The sorted order of edges is preserved, so Kruskal's makes identical decisions.

Problem 4: Adding a Constant

Q: If we add a constant $c$ to all edge weights, does the MST change?
A: No. Adding a constant preserves the relative order of edge weights.
The total MST cost increases by $c \cdot (|V| - 1)$, but the structure is the same.

Common Pitfalls

Watch Out For...

Forgetting that MST requires a connected graph. If disconnected, you get a Minimum Spanning Forest.
Confusing Prim's with Dijkstra's: Prim uses edge weight as key, Dijkstra uses total distance.
In Kruskal's, forgetting to check if endpoints are in different components before adding an edge.
Assuming MST gives shortest paths between vertices — it does not.
Assuming a unique MST when edge weights are not distinct.

Interactive Practice

Activity 1: Kruskal's Trace

❓ Problem:
Edges: (A,B,3), (A,C,1), (B,C,7), (B,D,5), (C,D,4), (C,E,2), (D,E,6).
Run Kruskal's algorithm. List the MST edges and total cost.
Take 2 minutes to solve this.

Solution 1

💡 Sorted: (A,C,1), (C,E,2), (A,B,3), (C,D,4), (B,D,5), (D,E,6), (B,C,7).
Pick (A,C,1) — connects {A,C}.
Pick (C,E,2) — connects {A,C,E}.
Pick (A,B,3) — connects {A,B,C,E}.
Pick (C,D,4) — connects {A,B,C,D,E}. Done!
MST cost: 1 + 2 + 3 + 4 = 10.

Activity 2: Prim's Trace

❓ Problem:
Same graph. Run Prim's starting from vertex A.
Show the key updates and extraction order.
Take 2 minutes to solve this.

Solution 2

💡 Start A (key 0). Update: key[B]=3, key[C]=1.
Extract C (key 1). Update: key[B]=min(3,7)=3, key[D]=4, key[E]=2.
Extract E (key 2). Update: key[D]=min(4,6)=4.
Extract B (key 3). Update: key[D]=min(4,5)=4.
Extract D (key 4). Done.
MST edges: (A,C), (C,E), (A,B), (C,D). Same MST, cost = 10.

Activity 3: Cut Property Application

❓ Problem:
Given cut $S = \{A, B\}$, $V \setminus S = \{C, D, E\}$.
Crossing edges: (A,C,1), (B,C,7), (B,D,5).
Which edge must be in the MST? Why?
Take 2 minutes to solve this.

Solution 3

💡 Answer:
Edge (A,C,1) — it is the minimum-weight edge crossing the cut.
By the Cut Property, this edge belongs to every MST (assuming distinct weights).

Activity 4: Cycle Property

❓ Problem:
The Cycle Property states: the heaviest edge in any cycle is NOT in the MST (assuming distinct weights). Why?
Take 2 minutes to think about this.

Solution 4

💡 Answer:
If the heaviest edge $e$ in a cycle were in the MST, removing $e$ splits the MST into two components.
Some other edge $e'$ in the cycle also connects these components, and $w(e') < w(e)$.
Replacing $e$ with $e'$ gives a cheaper spanning tree — contradiction.

Activity 5: Prim vs. Dijkstra

❓ Problem:
Prim's and Dijkstra's look almost identical. What is the key difference that makes their outputs different?
Take 2 minutes to solve this.

Solution 5

💡 Answer:
Prim's key update: key[v] = w(u, v) — just the edge weight.
Dijkstra's key update: dist[v] = dist[u] + w(u, v) — cumulative path distance.
Prim minimizes total edge weight. Dijkstra minimizes distance from source.

Activity 6: Edge Count

❓ Problem:
A connected graph has 10 vertices. How many edges does its MST have? What if the graph has 3 connected components?
Take 1 minute to solve this.

Solution 6

💡 Answer:
Connected graph with 10 vertices → MST has 9 edges ($|V| - 1$).
3 connected components → Minimum Spanning Forest has $10 - 3 = $ 7 edges.
In general: $|V| - k$ edges for $k$ components.

Summary

Key Takeaways

The Cut Property is the theoretical foundation: the lightest crossing edge belongs to the MST.
Kruskal's: Sort edges globally, merge components with Union-Find. $O(E \log V)$.
Prim's: Grow tree locally with a priority queue. $O(E \log V)$ or $O(E + V \log V)$ with Fibonacci heap.
MST ≠ Shortest Paths. Prim's ≠ Dijkstra's.
MST has exactly $|V| - 1$ edges and is unique when all weights are distinct.

Interactive: Kruskal's Algorithm

🚀 Interactive Demo: kruskal_demo.html

🚀 Interactive Demo: prim_demo.html

Supplementary Resources

🚀 Interactive Demo: worked_examples.html

🚀 Interactive Demo: reading_practice.html

🚀 Interactive Demo: handout.html