Minimum Spanning Trees

Week 14, Monday — Prim’s Algorithm

April 8, 2026

Announcements

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.

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: Pseudocode

1. Initialize structure:

   • For all v: d[v] = INF, p[v] = null
   • Let d[s] = 0
   • Initialize PQ by d[v]

2. Repeat n times:

   • Remove minimum d[] unlabelled vertex: v
   • Label vertex v
   • For all unlabelled neighbors w of v:
     • If (wt[(v,w)] < d[w])
       • d[w] = wt[(v,w)]
       • p[w] = v

Where is the solution?

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

1. Initialize structure:

   • For all v: d[v] = INF, p[v] = null
   • Let d[s] = 0
   • Initialize PQ by d[v]

2. Repeat n times:

   • Remove minimum d[] unlabelled vertex: v
   • Label vertex v
   • For all unlabelled neighbors w of v:
     • If (wt[(v,w)] < d[w])
       • d[w] = wt[(v,w)]
       • p[w] = v

3. 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

1. Initialize structure:

   • For all v: d[v] = INF, p[v] = null
   • Let d[s] = 0
   • Initialize PQ by d[v] ⭐

2. Repeat n times:

   • Remove minimum d[] unlabelled vertex: v ⭐
   • Label vertex v
   • For all unlabelled neighbors w of v: 💜
     • If (wt[(v,w)] < d[w])
       • d[w] = wt[(v,w)] ⭐
       • p[w] = v

3. 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).

Single Source Shortest Path

Given a start vertex (source) \(s\), find the path of least total cost from \(s\) to every vertex in the graph.

Single Source Shortest Path

• Input: directed graph \(G\) with non-negative edge weights, and a start vertex \(s\).
• Output: A subgraph \(G’\) consisting of the shortest (minimum total cost) paths from \(s\) to every other vertex in the graph.

Dijkstra’s Algorithm (1959)

 

Note:

1. change (d,e) to -2: DIJK may not find shortest path
2. change (g,s) to -10: no shortest path exists

SSSP Algorithm

Given a source vertex \(s\), we wish to find the shortest path from \(s\) to every other vertex in the graph.

1. Initialize structure:

   • d:
   • p:

2. Repeat these steps:

   • Label a new (unlabelled) vertex \(v\), whose shortest distance has been found
   • Update \(v\)’s neighbors with improved distance and predecessor

SSSP Algorithm

1. Initialize structure:

   • For all v: d[v] = INF, p[v] = null
   • Let d[s] = 0
   • Initialize PQ by d[v]

2. Repeat n times:

   • Remove minimum d[] unlabelled vertex: v
   • Label vertex v
   • For all unlabelled neighbors w of v:
     • If (________________ < d[w])
       • d[w] = ________________
       • p[w] = v

3. Return p

Three Observations:

• When a node becomes labeled, its shortest distance is final. It will never improve again.

• d[] values only decrease, never increase.

• The predecessors p[] form a shortest-path tree.

Your Turn

Execute Dijkstra’s algorithm on this graph: