Algo ch23 Min Span Trees

Minimum Spanning Trees
Spanning Tree
A spanning tree of G is a subgraph which
istree (acyclic)
and connect all the vertices in V.
Spanning tree has only |V| - 1 edges.

2
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
Example: MST
4
Example: MST
Generic MST Algorithm
Our goal is to build a spanning tree by adding one

edge at a time to a set T in a “greedy” fashion.
Basically, we just need to somehow guarantee

ourselves that at each step, the current set can be
“extended” to an MST.
Strategy:
Grow the MST one edge at a time, ensuring that
the partial solution remains a subset of some
MST
How do we do that?
6
Let’s assume that our current set of edges A already
satisfies the property that A can be extended to an
MST.
Question:
What edges can we add to A to maintain the
property?
Answer:
an edge e such that w(e) ≤ w(other edges) and
A ∪ {e} is acyclic
We will call such edge a safe edge if it also doesn’t

create a cycle when added to T.
Generic-MST(G, w)
1. A = { }
2. while A does not form a spanning tree
3. find an edge (u, v) that is safe for A
4. Add (u, v) to A
5. return A
How to find a safe edge?
8
Definitions:
A cut (S, V - S) of G = (V, E) is a partition of V into 2
sets
An edge (u, v) ∈ E crosses the cut (S, V - S) if one

point is in S while the other point in V - S
A cut respects a set A of edges if no edges in A

crosses the cut.
An edge is light if its weight is minimum of all edges

crossing the cut
8 7
b c d
4 9
2 S
S 11 14
a i e
6 4
V-S
V-S 8 7 10
h 1 g f
2
black vertices S = (a, b, d, e) cut

white vertices V-S = (c, i, h, g, f)
red line cut
blue edges crossing the cut
(c, d) only light edge
green a subset A of edges
cut (S, V-S) respects A, since no edge of
A crosses the cut
10
Theorem 23.1 (CLRS)
Let G = (V
(V, E) be a connected,
connected, undirected graph
w is weight function w : E→R
Let A ⊆ E be included in some MST T for G
Let (S
(S, V - S) be any cut of G that respect A
Let (u
(u, v) be a light edge (min weight) crossing the cut (S
(min--weight) (S,
V - S)
Then, edge (u(u, v) is safe for A

i.e., (u,v) ∈ T, a MST of G
11
Theorem 23.1 (CLRS)

Proof
suppose (u, v) ∉ T
look at path from u to v in T
swap (x, y) with (u, v)
¾ the first edge on path from u to v in T that crosses from S to V – S
this increases w(T) – contradiction
¾ T supposed to be MST
V-S
S
y
x
u v
12
Generic-MST(G, w)
1. A = { }
4. Add (u, v) to A
5. return A
As the algorithm proceeds:
A is always acyclic
At any point of the execution of the algorithm,
graph GA = (V, A) is a forest, and
each connected component is a tree
Also, any safe edge (u, v) for A
connects distinct components of GA,
since A ∪ (u, v) must be acyclic
13

Generic-MST(G, w)
1. A = { }
4. Add (u, v) to A
5. return A
The loop in lines 2-4 is executed |V|-1 times
Initially when A = {}, there are |V| trees in GA

¾ each tree has only one vertex
When GA (forest) contains only a single tree, the algorithm

terminates
14
Corollary 23.2 (CLRS):
Let A ⊆ E be included in some
MST
Let C1 = (VC1, EC1) and

C2 = (VC2, EC2) be two distinct
connected components (trees) in
the forest GA = (V, A).
If (u, v) is a light edge crossing

the cut = (VC1, VC2) then (u, v) is
safe for A.
15
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
16
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
17
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 by nondecreasing weight w
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
18
Kruskal's Algorithm
Lines 1-3 initialize the set A to empty set and create |V|
trees, one containing each vertex.
The edges in E are sorted into nondecreasing order by
weight in line 4.
The for loop in lines 5-8 checks, for each (u, v), whether
the endpoints u and v belong to the same tree.
If they do, then the edge (u, v) cannot be added to the
forest without creating a cycle, and the edge is
discarded.
Otherwise, the two vertices belong to different trees.
In this case, the edge (u, v) is added to A in line 7, and
the vertices in the two trees are merged in line 8.
19
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 4
2
2 4
¾different components, the addition of the edge (u, v)
does not create a cycle. 5 7
6 3
6 8
20
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 3 5 7
7 4 6 3
2
2 4 6 8
21
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 3 5 7
7 4 6 3
2
2 4 6 8
22
Initially, T is empty
1 3 5 7
2 4 6 8
Initial sets are:

{1} {2} {3} {4} {5} {6} {7} {8}
Does the addition of an edge (u, v) to T result in a

cycle? If not, add edge to T
s1 = Find-Set(u); s2 = Find-Set(v);
if (s1 ≠ s2) then Union(s1, s2);
23
Kruskal’s Algorithm
2 19 2 19
9 9
14 17 14 17
8 25 8 25
5 5
21 13 1 21 13 1
2 19 2 19
9 9
14 17 14 17
8 25 8 25
5 5
21 13 1 21 13 1?
2 19 2? 19
9 9
14 17 14 17
8 25 8 25
5 5
21 13 1 21 13 1
24
2 19 2 19
9 9
14 17 14 17
8 25 8 25
5 5?
21 13 1 21 13 1
2 19 2 19
9 9
14 17 14 17
8 25 8? 25
5 5
21 13 1 21 13 1
2 19 2 19
9 9?
14 17 14 17
25 8 25
5 5
21 13 1 21 13 1
25
2 19 2 19
9 9
14 17 14 17
8 25 8 25
5 5
21 13 1 21 13? 1
2 19 2 19
9 9
14 17 14? 17
8 25 8 25
5 5
21 13 1 21 13 1
2 19 2 19
9 9
14 17 14 17?
8 25 8 25
5 5
21 13 1 21 13 1
26
2 19? 2 19
9 9
14 17 14 17
8 25 8 25
5 5
21 13 1 21? 13 1
2 19 2 19
9 9
14 17 14 17
8 25? 8 25
5 5
21 13 1 21 13 1
2 19
9
14 17
8 25
5
21 13 1
27
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 by nondecreasing weight w
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
28
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 for loop in lines 2-3.
¾ |E| FindSet(), for loop in lines 5-8.
¾ |V| - 1 Union(), for loop in lines 5-8.
¾ which takes O(V + E)
The total running time is

O(E lg E)
Observing that │E │< │V│2 we have lg │E│ = O(lg V),
So total running time becomes O(E lg V).
29
Prim’s Algorithm
Prim’s algorithm has the property that edges in the set A
always form a single tree.
The tree starts from an arbitrary root vertex r and grows until
the tree spans all the vertices in V.
At each step, a light edge is added to the tree A that connects
A to an isolated vertex of GA = (V, A).
Adds only edges that are safe for A.
When algorithm terminates, edges in A form MST.
MST A for G: A={(v, p[v]): v ε V-{r}}.
Vertex based algorithm.

Grows one tree T, one vertex at a time
30
Prim’s Algorithm
MST-Prim(G,w,r)
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] ← NIL
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
9 if v ∈ Q and w(u,v) < key[v] then
10 p[v] ← u
updating
11 key[v] ← w(u,v) keys
• All vertices that are not in tree reside in min-priority queue Q based on a key field.
• 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]
• key[v]= p[v] names parent of v in tree.
• When algorithm terminates the min-
min-priority queue Q is empty.
31
Prim’s Algorithm
Lines 1-
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
each
vertex to NIL, and initialize min-
min-priority queue Q to contain all
vertices.
Line 7 identifies a vertex u є Q incident on a light edge crossing
cut (V-
(V-Q, Q) (except first iteration, u=r due to line 4).
Removing u from set Q adds it to set Q-
Q-V of vertices in tree,
thus adding (u, p[u])
p[u]) to A.
The for loop of lines 8-
8-11 update key and p fields of every
vertex v adjacent to u but not in tree.
32
Run on example graph
6 4
5 9
14 2
10
15
3 8
33
6 ∞ 4
5 9
∞ ∞ ∞
14 2
10
15
∞ ∞ ∞
3 ∞ 8
key[u] = ∞
34
6 ∞ 4
5 9
∞ ∞ ∞
14 2
10
15
r 0 ∞ ∞
3 ∞ 8
Pick a start vertex r
35
6 ∞ 4
5 9
∞ ∞ ∞
14 2
10
15
u 0 ∞ ∞
3 ∞ 8
Red vertices have been removed from Q
36
6 ∞ 4
5 9
∞ ∞ ∞
14 2
10
15
u 0 ∞ ∞
3 3 8
Red arrows indicate parent pointers
37
6 ∞ 4
5 9
14 ∞ ∞
14 2
10
15
u 0 ∞ ∞
3 3 8
38
6 ∞ 4
5 9
14 ∞ ∞
14 2
10
15
0 ∞ ∞
3 3 8
u
39
6 ∞ 4
5 9
14 ∞ ∞
14 2
10
15
0 8 ∞
3 3 8
u
40
6 ∞ 4
5 9
10 ∞ ∞
14 2
10
15
0 8 ∞
3 3 8
u
41
6 ∞ 4
5 9
10 ∞ ∞
14 2
10
15
0 8 ∞
3 3 8
u
42
6 ∞ 4
5 9
10 2 ∞
14 2
10
15
0 8 ∞
3 3 8
u
43
6 ∞ 4
5 9
10 2 ∞
14 2
10
15
0 8 15
3 3 8
u
44
6 ∞ 4
u
5 9
10 2 ∞
14 2
10
15
0 8 15
3 3 8
45
6 ∞ 4
u
5 9
10 2 9
14 2
10
15
0 8 15
3 3 8
46
4 u
6 4
5 9
10 2 9
14 2
10
15
0 8 15
3 3 8
47
4 u
6 4
5 9
5 2 9
14 2
10
15
0 8 15
3 3 8
48
u
6 4 4
5 9
5 2 9
14 2
10
15
0 8 15
3 3 8
49
u 4
6 4
5 9
5 2 9
14 2
10
15
0 8 15
3 3 8
50
u
6 4 4
5 9
5 2 9
14 2
10
15
0 8 15
3 3 8
51
6 4 4
5 9
5 2 9
14 2 u
10
15
0 8 15
3 3 8
52
Prim’s Running Time
• What is the hidden cost in this code?
Extract-Min is executed |V| times
MST-Prim(G,w,r)
1 for each u ∈ V[Q] Decrease-Key is executed O(|E|) times
2 key[u] ← ∞
3 p[u] ← NIL 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
10 p[v] ← u updating
11 key[v] ← w(u,v) keys
DecreaseKey(v, w(u,v));
53
Prim’s Running Time
Time complexity depends on data structure Q

Binary heap: O(E lg V):
BuildHeap takes O(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 = 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)
54

Algo ch23 Min Span Trees

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Algo ch23 Min Span Trees

Uploaded by

Copyright:

Available Formats

Minimum Spanning Trees

 Spanning tree has only |V| - 1 edges.

Generic MST Algorithm

 Our goal is to build a spanning tree by adding one

 Basically, we just need to somehow guarantee

 We will call such edge a safe edge if it also doesn’t

Generic MST Algorithm

 How to find a safe edge?

 An edge (u, v) ∈ E crosses the cut (S, V - S) if one

 A cut respects a set A of edges if no edges in A

 An edge is light if its weight is minimum of all edges

Generic MST Algorithm

black vertices S = (a, b, d, e) cut

 w is weight function w : E→R

 Let A ⊆ E be included in some MST T for G

 Then, edge (u(u, v) is safe for A

Theorem 23.1 (CLRS)

Generic MST Algorithm

 The loop in lines 2-4 is executed |V|-1 times

 Initially when A = {}, there are |V| trees in GA

 When GA (forest) contains only a single tree, the algorithm

 Let C1 = (VC1, EC1) and

 If (u, v) is a light edge crossing

 Edge based algorithm

 From the remaining edges, select a least-cost

 Repeat |V|-1 times

Data Structures For Kruskal’s Algorithm

 Does the addition of an edge (u, v) to T result in a

 Each component of T is defined by the vertices in

Data Structures For Kruskal’s Algorithm

 When an edge (u, v) is added to T, the two

 Initial sets are:

 Does the addition of an edge (u, v) to T result in a

 The total running time is

 Vertex based algorithm.

Run on example graph

Pick a start vertex r

Run on example graph

Red vertices have been removed from Q

Red arrows indicate parent pointers

Run on example graph

Run on example graph

Run on example graph

Run on example graph

Run on example graph

Run on example graph

Run on example graph

Run on example graph

Prim’s Running Time

 Time complexity depends on data structure Q

You might also like

Spanning tree has only |V| - 1 edges.

Our goal is to build a spanning tree by adding one

Basically, we just need to somehow guarantee

We will call such edge a safe edge if it also doesn’t

How to find a safe edge?

An edge (u, v) ∈ E crosses the cut (S, V - S) if one

A cut respects a set A of edges if no edges in A

An edge is light if its weight is minimum of all edges

w is weight function w : E→R

Let A ⊆ E be included in some MST T for G

Then, edge (u(u, v) is safe for A

The loop in lines 2-4 is executed |V|-1 times

Initially when A = {}, there are |V| trees in GA

When GA (forest) contains only a single tree, the algorithm

Let C1 = (VC1, EC1) and

If (u, v) is a light edge crossing

Edge based algorithm

From the remaining edges, select a least-cost

Repeat |V|-1 times

Does the addition of an edge (u, v) to T result in a

Each component of T is defined by the vertices in

When an edge (u, v) is added to T, the two

Initial sets are:

Does the addition of an edge (u, v) to T result in a

The total running time is

Vertex based algorithm.

Time complexity depends on data structure Q