Minimum Spanning Trees

Week 13, Wednesday — Prim’s Algorithm

April 2, 2026

Announcements

Warm-up: Graph Representations

Adjacency list   (you’ve seen this)

graph = {
  "A": [("B",8), ("C",2), ("D",4)],
  "B": [("A",8), ("C",7), ("E",2)],
  "C": [("A",2), ("B",7), ("D",1),
        ("E",3), ("F",9)],
  "D": [("A",4), ("C",1), ("F",5)],
  "E": [("B",2), ("C",3)],
  "F": [("C",9), ("D",5)],
}

Space: \(O(V + E)\)

Iterate neighbors of \(v\): \(O(\deg(v))\)

Check if edge \((u,v)\) exists: \(O(\deg(u))\)

Adjacency matrix   (new today)

	A	B	C	D	E	F
A	–	8	2	4	–	–
B	8	–	7	–	2	–
C	2	7	–	1	3	9
D	4	–	1	–	–	5
E	–	2	3	–	–	–
F	–	–	9	5	–	–

Space: \(O(V^2)\)

Iterate neighbors of \(v\): \(O(V)\)

Check if edge \((u,v)\) exists: \(O(1)\)

Muddy City

You can pave road segments. Each segment costs its number of paving stones.

Goal: pave the __________ stones so every house can reach every other.

 

Which roads do you pave?

How many stones total?

 

(CS Unplugged activity)

Classic CS Unplugged activity. Key insight: you never need a cycle. If two houses are already connected, adding another road between them wastes stones. So the answer is always a tree (connected + acyclic). The minimum-weight spanning tree. MST for this graph: edges 2-5(3), 5-8(3), 1-2(4), 3-6(4), 1-4(5), 4-7(5) = total 24.

Minimum Spanning Tree

Input: connected, undirected graph \(G\) with edge weights

Output: subgraph \(G'\) such that:

• \(G'\) spans \(G\) (contains all vertices)
• \(G'\) is connected and acyclic (a tree)
• \(G'\) has minimum total weight among all spanning trees

 

What is the MST of this graph?

Total weight = ____

MST edges: C-D(1), A-C(2), B-E(2), C-E(3), D-F(5). Total = 13. A tree on n vertices has exactly n-1 edges.

Cycle Property

What’s true about every cycle in this graph?

 

Theorem:   ___________________________________

 

 

 

Proof:   ______________________________________

 

 

 

Theorem: On any cycle, the maximum-weight edge is never in the MST. Proof: Suppose the max-weight edge e were in the MST. Removing e splits T into two components — but the rest of the cycle is a path that reconnects them at strictly lower cost. Swapping e for any other cycle edge gives a lighter spanning tree, contradicting minimality. Cycles: A-C-D (weights 2,1,4 → A-D out), A-B-C (8,7,2 → A-B out), C-D-F-C (1,5,9 → C-F out).

Non-MST Edge Lower Bound

Edge C–F is not in the MST. Using the theorem you just derived — what is the minimum possible weight for C–F?

 

MST path C → F:   _________________

 

Min weight of C–F:   _____

 

 

Theorem:   ___________________________________

(for any non-MST edge)

 

MST path C→F: C–D–F (weights 1, 5). Max = 5. So C–F ≥ 5. Actual C–F = 9 ✓ General theorem: weight(X) ≥ max weight on the unique MST path from u to v. If C–F were 4 — it would replace D–F(5) in the MST.

MST vs. Shortest Paths

MST minimizes total edge weight — the cost of connecting everything.

 

Shortest path minimizes the distance between two specific nodes.

 

These are different objectives.

A→D direct edge = 4. MST path A→D = A–C–D = 2+1 = 3. A→B direct edge = 8. MST path A→B = A–C–E–B = 2+3+2 = 7. The MST optimizes global connectivity cost, not any particular route.

Partition Property (Cut Property)

Partition Property (Cut Property)

Split vertices into any two sets \(S\) and \(V \setminus S\).

The minimum-weight edge crossing the cut is always in some MST.

Partition property (cut property) is the theoretical basis for Prim’s algorithm. Proof sketch: suppose the minimum crossing edge e is NOT in the MST T. Add e to T → creates a cycle. That cycle must have another crossing edge e’ with weight ≥ e. Swap e’ for e to get a lighter spanning tree — contradiction.

Contrast with cycle property (used for Kruskal’s): remove the heaviest edge on any cycle. Both properties together characterise the MST.

The greedy algorithm described here IS Prim’s — we just need an efficient data structure to find the cheapest crossing edge at each step. A priority queue does it.

S={A,C,D}: internal edges A-C(2), A-D(4), C-D(1). Crossing: A-B(8), B-C(7), C-E(3)←min, C-F(9), D-F(5).

Prim’s Algorithm

MST total weight = ____

Prim’s from A (tie-break by lowest weight): 1. A-B(2) → {A,B} 2. A-C(3) → {A,B,C} 3. C-D(2) → {A,B,C,D} 4. D-E(3) → {A,B,C,D,E} 5. E-H(2) → {A,B,C,D,E,H} 6. E-F(3) → {A,B,C,D,E,H,F} (also F-H=3 and E-I=3 but E-F alphabetically first) 7. F-G(3) → …+G 8. H-J(3) → …+J 9. I-J(2) → …+I (done!) Total = 2+3+2+3+2+3+3+3+2 = 23 MST edges: A-B, A-C, C-D, D-E, E-H, E-F, F-G, H-J, I-J

BFS Revisited

from collections import deque

def bfs(graph, start):
    visited = {start}
    queue = deque([start])

    while queue:
        v = queue.popleft()
        for w in graph[v]:          # examine each neighbor
            if w not in visited:
                visited.add(w)
                queue.append(w)

What type is graph? What type is graph[v]?

Running time? (in terms of \(|V|\) and \(|E|\))

• Each vertex enters the queue at most ____ time(s).
• Each edge is examined at most ____ time(s).
• Total: \(O(\)____\()\)

O(V + E). Each vertex enters queue once → O(V) enqueues. Each edge (u,v) is examined when u is dequeued (and again when v is dequeued for undirected) → O(E). graph is a dict; graph[v] is a list (or any iterable of neighbors).

graph	neighbors
A	B, D, E
B	A, E, C
C	B, D
D	A, C
E	A, B

From BFS to Prim’s

The bag determines what the algorithm optimizes:

Bag	Explores by	Algorithm
Queue (FIFO)	distance from source (hops)	BFS
Priority queue (min edge weight)	cheapest edge to tree	Prim’s MST
Priority queue (min total distance)	shortest path from source	Dijkstra’s SSSP

 

One change turns BFS into Prim’s:

Replace the queue with a Priority Queue keyed by edge weight. Instead of “which node did I discover first?”, ask “which unvisited node is cheapest to connect to the tree?”

Prim’s Algorithm: Pseudocode

Initialize:
for each v:  d[v] ← ∞,  p[v] ← null
d[s] ← 0
Q ← min-PQ of all vertices, keyed by d

while Q not empty:

  v ← Q.removeMin()

  for each neighbor w of v:

    if w ∈ Q and cost(v,w) < d[w]:
      d[w] ← cost(v,w)
      p[w] ← v
      Q.decreaseKey(w, d[w])

return p

d[v] = cheapest known edge weight from the current tree S to vertex v (not cumulative path cost — that’s Dijkstra’s). p[v] = which vertex in S is v’s parent in the MST. Terminates when Q is empty, i.e., all n vertices have been added to S. Key contrast: Dijkstra sets d[w] = d[v] + cost(v,w); Prim sets d[w] = cost(v,w) alone. Prim’s from A: A-B(2), B-C(5)? No — after A,B in S: d[C]=min(8,5)=5, d[D]=7, d[E]=7. Pick C(5). Then from C: d[D]=min(7,9)=7, d[E]=min(7,8)=7. Pick D or E (tie). D(7)→F(4). E(7)→F already reached at 4. Done. MST: A-B(2),B-C(5),B-D(7),D-F(4),A-E(7). Total=25.

Prim’s Algorithm: Design Choices

Initialize:
for each v:  d[v] ← ∞,  p[v] ← null
d[s] ← 0
Q ← min-PQ of all vertices, keyed by d

while Q not empty:
  v ← Q.removeMin()
  for each neighbor w of v:
    if w ∈ Q and cost(v,w) < d[w]:
      d[w] ← cost(v,w)
      p[w] ← v
      Q.decreaseKey(w, d[w])

return p

What design choices do we need to make?

 

Put a ⭐ by __________________ operations.

 

Put a 💜 by __________________ operations.

⭐ = priority queue operations: removeMin and decreaseKey. - heap: removeMin O(log n), decreaseKey O(log n) - unsorted array: removeMin O(n), decreaseKey O(1) 💜 = neighbor iteration (“for each neighbor w of v”): depends on graph representation. - adj list: O(deg v) per vertex, O(m) total across all vertices - adj matrix: O(n) per vertex, O(n²) total Students fill in the table on the next slide.

Prim’s Algorithm: Runtime Analysis

Initialize:
for each v:  d[v] ← ∞,  p[v] ← null
d[s] ← 0
Q ← min-PQ of all vertices, keyed by d

while Q not empty:
  v ← Q.removeMin()          ⭐
  for each neighbor w of v:  💜
    if w ∈ Q and cost(v,w) < d[w]:
      d[w] ← cost(v,w)
      p[w] ← v
      Q.decreaseKey(w, d[w])  ⭐

return p

⭐ \(n\) removeMins + \(\leq m\) decreaseKeys
💜 \(O(m)\) total (adj list)  |  \(O(n^2)\) total (adj matrix)

	Adj matrix	Adj list
heap	\(O(n^2 + m \log n)\)	\(O(m \log n)\)
unsorted array	\(O(n^2)\)	\(O(n^2)\)

 

Which is best? Depends on graph density:

• Sparse (\(m=O(n)\)):
• Dense (\(m=O(n^2)\)):

Heap + adj list: n×O(log n) removeMin + m×O(log n) decreaseKey + O(m) neighbor scans = O(m log n). Heap + adj matrix: same PQ cost + O(n) per vertex for neighbor scan = O(n²) + O(m log n). Unsorted array + adj matrix: O(n) removeMin × n = O(n²); decreaseKey O(1); neighbor scan O(n²) total = O(n²). Unsorted array + adj list: O(n²) removeMin dominates = O(n²).

Prim’s Algorithm: Python

import heapq

def prim(graph, start):
    """graph: {vertex: [(neighbor, weight), ...]}"""
    d = {v: float('inf') for v in graph}   # cheapest edge to reach v
    parent = {v: None for v in graph}
    d[start] = 0
    pq = [(0, start)]                       # (edge_weight, vertex)
    visited = set()

    while pq:
        cost, v = heapq.heappop(pq)
        if v in visited:
            continue
        visited.add(v)

        for w, weight in graph[v]:
            if w not in visited and weight < d[w]:
                d[w] = weight              # just the edge weight (not cumulative!)
                parent[w] = v
                heapq.heappush(pq, (weight, w))

    return parent   # MST as parent pointers

Key contrast with Dijkstra’s: - Dijkstra’s: d[w] = d[v] + cost(v,w) → minimizes total path from source - Prim’s: d[w] = cost(v,w) → minimizes single edge into tree

Both use the same priority-queue skeleton. heapq.heappush approximates decreaseKey (lazy deletion via the visited check).