Minimum Spanning Trees
1
Minimum- Spanning Trees
1. Concrete example: computer connection
2. Definition of a Minimum- Spanning Tree
Concrete example
Imagine: You wish to connect all the computers in an
office building using the least amount of cable
- Each vertex in a graph G represents a computer
- Each edge represents the amount of cable needed to
connect all computers
Spanning Tree

A spanning tree of G is a subgraph which
 is tree (acyclic)
 and connect all the vertices in V.
 Spanning
tree has only |V| - 1 edges.
Problem: Laying Telephone Wire
Central office
Wiring: Naive Approach
Central office
Expensiv
e!
Wiring: Better Approach
Central office
Minimize the total length of wire connecting
the customers
Spanning
Trees
A spanning tree of a graph is just a
subgraph that contains all the
vertices and is a tree.
A graph may have many spanning trees.
Graph
A
Some Spanning Trees from
Graph A
o
r
o
r
o
r
Complete
Graph
All 16 of its
Spanning Trees
Total Number of Spanning Trees





A complete graph with n vertices has
n (n-2) spanning trees.(Cayley's formula)
53 is 125
86 is 262144
108 is 100 million
10098 is 10196
Compare: there are
31.5576*106 seconds in a year.
A nanosecond is one billionth (10-9) of a second.
(An electrical signal can travel about 30cm in a
nanosecond.) There are
31.5576*1015 nanoseconds in a year.
We are not going to be able to find all spanning
trees for large graphs even on the fastest computers,
at least not in our lifetimes. We have to get smart
about trees.
10
Minimum Spanning Tree

Input:
 Undirected connected graph G = (V, E) and weight
function w : E→R,

Output:
 A Minimum spanning tree T : tree that connects all
the vertices and minimizes
w(T ) 
w(u, v)

( u ,v )T

Greedy Algorithms
 Generic MST algorithm
 Kruskal’s algorithm
 Prim’s algorithm
11
Hallmark for “greedy”
algorithms
Greedy-choice property
A locally optimal choice
is globally optimal.
Theorem. Let T be the MST of G = (V, E),
and let A  V. Suppose that (u, v) ∈ E is the
least-weight edge connecting A to V – A.
Then, (u, v) ∈ T.
12
12
Growing a Minimum Spanning Tree
(MST)

Generic algorithm
 Grow MST one edge at a time
 Manage a set of edges A, maintaining the
following loop invariant:
 Prior to each iteration, A is a subset of some MST

At each iteration, we determine an edge (u, v)
that can be added to A without violate this
invariant
 A  {(u, v)} is also a subset of a MST
 (u, v) is called a safe edge for A
13
13
GENERIC-MST
–Loop in lines 2-4 is executed |V| - 1
times
• Any MST tree contains |V| - 1 edges
• The execution time depends on how
to find a safe edge
14
14
How to Find A Safe Edge?

Theorem 23.1. Let A be a subset of E that is
included in some MST, let (S, V-S) be any cut of
G that respects A, and let (u, v) be a light edge
crossing (S, V-S). Then edge (u, v) is safe for A
 Cut (S, V-S): a partition of V
 Crossing edge: one endpoint in S and the
other in V-S


A cut respects a set of A of edges if no edges in A crosses the
cut
A light edge crossing a cut if its weight is the minimum of any
edge crossing the cut
16
16
Illustration of Theorem 23.1
• A={(a,b}, (c, i}, (h, g}, {g, f}}
• S={a, b, c, i, e}; V-S = {h, g, f, d}
 many kinds of cuts satisfying the
requirements of Theorem 23.1
• (c, f) is the light edges crossing S
and V-S and will be a safe edge
17
Example: MST
18
Example: MST
19
Kruskal's Algorithm

Edge based algorithm

Greedy strategy:

From the remaining edges, select a least-cost
edge that does not result in a cycle when added
to the set of already selected edges

Repeat |V|-1 times
20
Kruskal's Algorithm


INPUT:
 edge-weighted graph G = (V, E), with |V| = n
OUTPUT:
 a spanning tree A of G
 touches all vertices,
 has n-1 edges
 of minimum cost ( = total edge weight)

Algorithm:
 Start with A empty,
 Add the edges one at a time, in increasing weight order
 An edge is accepted it if connects vertices of distinct
trees (if the edge does not form a cycle in A)
 until A contains n-1 edges
21
Kruskal's Algorithm
MST-Kruskal(G,w)
1 A  
2 for each vertex v  V[G] do
3
Make-Set(v) //creates set containing v (for initialization)
4 sort the edges of E
5 for each (u,v)E do
6
if Find-Set(u)  Find-Set(v) then // different
component
7
A  A  {(u,v)}
8
Union(Set(u),Set(v)) // merge
9 return A
22
Data Structures For Kruskal’s Algorithm
Does the addition of an edge (u, v) to T result in a
cycle?
 Each component of T is a tree.
 When u and v are in the

same component, the addition of the edge (u, v)
creates a cycle.
1
3
7
2
4
2
4
different components, the addition of the edge (u, v)
does not create a cycle. 5
7
6
6
23
3
8
Data Structures For Kruskal’s Algorithm



Each component of T is defined by the vertices in
the component.
Represent each component as a set of vertices.
 {1, 2, 3, 4}, {5, 6}, {7, 8}
Two vertices are in the same component iff they
are in the same set of vertices.
1
7
2
2
3
5
6
7
3
4
6
8
4
24
Data Structures For Kruskal’s Algorithm


When an edge (u, v) is added to T, the two
components that have vertices u and v combine to
become a single component
In our set representation of components, the set that
has vertex u and the set that has vertex v are united.
 {1, 2, 3, 4} + {5, 6}  {1, 2, 3, 4, 5, 6}
1
2
2
7
3
5
6
7
3
4
6
8
4
25
Kruskal’s Algorithm
2
8
14
25
21
8
25
21
1
9
17
8
5
1
14
8
5
1
14
21
26
5
1
19
25
21
9
9
17
13
9
17
5
13
2?
17
13
25
21
19
25
14
19
2
13
2
8
8
5
19
21
14
9
17
13
2
14
2
19
1?
19
25
9
17
5
13
1
Kruskal’s Algorithm
2
8
14
25
21
8
25
1
9
17
8?
5
14
8
5
14
21
1
27
5?
1
19
25
9
17
5
13
2
9
9
17
13
21
1
17
13
25
21
19
25
14
19
2
13
2
21
8
5
19
21
14
9
17
13
2
14
2
19
1
19
25
9?
17
5
13
1
Kruskal’s Algorithm
2
8
14
25
21
8
25
21
1
9
17
8
5
1
14?
8
5
1
14
21
28
5
1
19
25
21
9
9
17
13?
9
17
5
13
2
17
13
25
21
19
25
14
19
2
13
2
8
8
5
19
21
14
9
17
13
2
14
2
19
1
19
25
9
17?
5
13
1
Kruskal’s Algorithm
2
8
14
25
21
8
21
9
17
1
25
21?
9
17
13
1
8
14
25
21
2
21
29
9
17
5
13
1
1
9
17
5
13
19
25
5
19
14
8
5
9
17
13
2
19
25?
19
14
8
5
13
2
14
2
19?
1
5
A
4
6
2
2
C
B
1
3
3
D
2
E
4
30
F
5
A
4
6
2
2
C
B
1
3
3
D
2
E
4
31
F
5
A
4
6
2
2
C
B
1
3
3
D
2
E
4
32
F
5
A
4
6
2
2
C
B
1
3
3
D
2
E
4
33
F
5
A
4
6
2
2
C
B
1
3
3
D
2
E
4
34
F
5
A
4
6
2
2
C
B
1
3
3
D
2
E
4
35
F
cycle!!
5
A
4
6
2
2
C
B
1
3
3
D
2
E
4
36
F
5
A
4
6
2
2
C
B
1
3
3
D
2
E
4
37
F
minimum- spanning tree
A
B
2
2
C
D
1
3
2
E
F
38
Kruskal's Algorithm
MST-Kruskal(G,w)
1 A  
2 for each vertex v  V[G] do //
3
Make-Set(v)
4 sort the edges of E //
takes
takes O(V)
O(E lg E)
// takesO(E)
5 for each (u,v)E, in nondecreasing of weight do
6
if Find-Set(u)  Find-Set(v) then
7
A  A  {(u,v)}
8
Union(Set(u),Set(v))
9 return A
39
Running Time of Kruskal’s Algorithm

Kruskal’s Algorithm consists of two stages.
 Initializing the set A in line 1 takes O(1) time.
 Sorting the edges by weight in line 4.
 takes O(E lg E)

Performing
 |V| MakeSet() operations
 |E| FindSet(),
 |V| - 1 Union(),
 which takes
O(V + E)

for loop in lines 2-3.
for loop in lines 5-8.
for loop in lines 5-8.
The total running time is
 O(E lg E)
 We have lg │E│ = O(lg V) because # of E = V-1
 So total running time becomes O(E lg V).
40
Prim’s Algorithm

The tree starts from an arbitrary root vertex r and
grows until the tree spans all the vertices in V.

At each step,
 Adds only edges that are safe for A.
 When algorithm terminates, edges in A form
MST.

Vertex based algorithm.

Grows one tree T, one vertex at a time
41
Prim’s Algorithm
MST-Prim(G,w,r) //G: graph with weight w and a root vertex r
1 for each u  V[G]{
2 key[u]  
3 p[u]  NULL
// parent of u
}
4 key[r]  0
5 Q = BuildMinHeap(V,key); // Q – vertices out of T
6 while Q   do
7
u  ExtractMin(Q) // making u part of T
8
for each v  Adj[u] do
updating
9
if v  Q and w(u,v)  key[v] then
keys
10
p[v]
 u
11
key[v]
 w(u,v)
• For each vertex v, key [v] is min weight of any edge connecting v to a vertex in tree.
• key [v]= ∞ if there is no edge and p [v] names parent of v in tree.
• When algorithm terminates the min-priority queue Q is empty.
42
Prim’s Algorithm

Lines 1-5 set the key of each vertex to ∞ (except root r, whose
key is set to 0 first vertex processed). Also, set parent of each
vertex to NULL, and initialize min-priority queue Q to contain
all vertices.

Line 7 identifies a vertex u є Q

Removing u from set Q adds it to set Q-V of vertices in tree,
thus adding (u, p[ u]) to A.

The for loop of lines 8-11 update key and p fields of every
vertex v adjacent to u but not in tree.
43
Run on example graph
6
4
9
5
14
2
10
15
3
8
44
Run on example graph

6
4
5

14


15

2
10


3
9

8
key[u] = 
45
Run on example graph

6
5

14
r
4


15

2
10

0
3
9

8
Pick a start vertex r
46
Run on example graph

6
5

14
u
4


15

2
10

0
3
9

8
Red vertices have been removed from Q
47
Run on example graph

6
5

14
u
4


15

2
10

0
3
9
3
8
Red arrows indicate parent pointers
48
Run on example graph

6
5
14
14
u
4


15

2
10

0
3
9
3
8
49
Run on example graph

6
4
5
14
14


0
u

15

2
10
3
9
3
8
Extract_min from Q
50
Run on example graph

6
4
5
14
14

0
8
u

15

2
10
3
9
3
8
51
Run on example graph

6
4
5
10
14

0
8
u

15

2
10
3
9
3
8
52
Run on example graph

6
4
5
10
14


15

2
10
0
8
3
9
3
8
u
53
Run on example graph

6
4
5
10
14
2

15

2
10
0
8
3
9
3
8
u
54
Run on example graph

6
4
5
10
14
9
2
2
10
0
8
3

3
8
u
55
15
15
Run on example graph

6
5
10
14
u
4

2
10
0
8
3
9
2
3
8
56
15
15
Run on example graph

6
5
10
14
u
4
9
2
10
0
8
3
9
2
3
8
57
15
15
Run on example graph
4
6
5
10
14
u
4
9
2
10
0
8
3
9
2
3
8
58
15
15
Run on example graph
4
6
5
5
14
u
4
9
2
10
0
8
3
9
2
3
8
59
15
15
Run on example graph
4
6
u
4
5
5
14
9
2
10
0
8
3
9
2
3
8
60
15
15
Run on example graph
u
4
6
4
5
5
14
9
2
10
0
8
3
9
2
3
8
61
15
15
Run on example graph
4
6
u
4
5
5
14
9
2
10
0
8
3
9
2
3
8
62
15
15
Run on example graph
4
6
4
5
5
14
2
0
8
3
8
63
9
u
2
10
3
9
15
15
Prim’s Running Time
• What is the hidden cost in this code?
Extract-Min is executed |V| times
MST-Prim(G,w,r)
Decrease-Key is executed O(|E|) times
1 for each u  V[Q]
2
key[u]  
3
p[u]  NULL
while loop is executed |V| times
4 key[r]  0
5 Q = BuildHeap(V,key); //Q – vertices out of T
6 while Q   do
7
u  ExtractMin(Q) // making u part of T
8
for each v  Adj[u] do
9
if v  Q and w(u,v) < key[v] then
updating
10
p[v]
 u
keys
11
key[v]
 w(u,v)
DecreaseKey(v, w(u,v));
64
Prim’s Running Time
 Time complexity depends
 Binary heap: O(E lg V):
on data structure Q
 BuildHeap
takes O(log V) time
 number of “while” iterations: V
ExtractMin takes O(lg V) time
 total
number of “for” iterations: E
DecreaseKey takes O(lg V) time
 Hence,
 Time
= log V + V.T(ExtractMin) +
E.T(DecreaseKey)
 Time = O(V lg V + E lg V) = O(E lg V)
Since E  V – 1 (because G is connected)
65
Minimum bottleneck spanning tree



A bottleneck edge is the highest weighted edge in a
spanning tree.
A spanning tree is a minimum bottleneck
spanning tree (or MBST) if the graph does not
contain a spanning tree with a smaller bottleneck
edge weight.
A MST is necessarily a MBST, but a MBST is not
necessarily a MST.
66