1. Minimum Spanning Trees

2. Minimum- Spanning Trees
1. Concrete example: computer connection
2. Definition of a Minimum- Spanning Tree

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

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

5. Problem: Laying Telephone Wire
Central office

6. Wiring: Naive Approach
Central office
Expensive!

7. Wiring: Better Approach
Central office
Minimize the total length of wire connecting the customers

8. A graph may have many spanning trees. Some Spanning Trees from Graph A
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 or or or

9. All 16 of its Spanning Trees
Complete Graph
All 16 of its Spanning Trees

10. Total Number of Spanning Trees
A complete graph with n vertices has n (n-2) spanning trees.(Cayley's formula)
53 is is is 100 million is Compare: there are *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
*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.

11. 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
Greedy Algorithms
Generic MST algorithm
Kruskal’s algorithm
Prim’s algorithm

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

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

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

15. How to Find A Safe Edge?
Theorem 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

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

18. Example: MST

19. Example: MST

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

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

22. 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
A ¬ A È {(u,v)}
Union(Set(u),Set(v)) // merge
9 return A

23. 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.
different components, the addition of the edge (u, v) does not create a cycle. 1 3 7 4 2 2 4 5 7 6 3 6 8

24. 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 3 5 7 2 4 6 8

25. 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 3 5 7 7 4 6 3 2 6 8 2 4

26. Kruskal’s Algorithm

27. Kruskal’s Algorithm

28. Kruskal’s Algorithm

29. Kruskal’s Algorithm

30. 5 A B 4 6 2 2 D C 3 1 2 3 E F 4

31. 5 A B 4 6 2 2 D C 3 1 2 3 E F 4

32. 5 A B 4 6 2 2 D C 3 1 2 3 E F 4

33. 5 A B 4 6 2 2 D C 3 1 2 3 E F 4

34. 5 A B 4 6 2 2 D C 3 1 2 3 E F 4

35. 5 A B 4 6 2 2 D
cycle!! C 3 1 2 3 E F 4

36. 5 A B 4 6 2 2 D C 3 1 2 3 E F 4

37. 5 A B 4 6 2 2 D C 3 1 2 3 E F 4

38. minimum- spanning treeB 2 2 D C 1 2 3 E F

39. Kruskal's Algorithm // takes O(E) MST-Kruskal(G,w) 1 A ¬ Æ
2 for each vertex v Î V[G] do // takes O(V)
3 Make-Set(v)
4 sort the edges of E // takes O(E lg E)
// takes O(E)
5 for each (u,v)ÎE, in nondecreasing of weight do
6 if Find-Set(u) ¹ Find-Set(v) then
A ¬ A È {(u,v)}
Union(Set(u),Set(v))
9 return A

40. 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)
We have lg │E│ = O(lg V) because # of E = V-1
So total running time becomes O(E lg V).

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

42. Prim’s Algorithm updating keys
MST-Prim(G,w,r) //G: graph with weight w and a root vertex r
1 for each u Î V[G]{
2 key[u] ¬ ¥
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
for each v Î Adj[u] do
if v Î Q and w(u,v)  key[v] then
p[v] ¬ u
key[v] ¬ w(u,v)
updating keys
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.

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

44. Run on example graph

45. Run on example graph

46. Run on example graph

47. Run on example graph

48. Run on example graph

49. Run on example graph

50. Run on example graph
Extract_min from Q

51. Run on example graph

52. Run on example graph

53. Run on example graph

54. Run on example graph

55. Run on example graph

56. Run on example graph

57. Run on example graph

58. Run on example graph

59. Run on example graph

60. Run on example graph

61. Run on example graph

62. Run on example graph

63. Run on example graph

64. DecreaseKey(v, w(u,v));
Prim’s Running Time
What is the hidden cost in this code?
MST-Prim(G,w,r)
1 for each u Î V[Q]
2 key[u] ¬ ¥
3 p[u] ¬ NULL
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
for each v Î Adj[u] do
if v Î Q and w(u,v) < key[v] then
p[v] ¬ u
key[v] ¬ w(u,v)
DecreaseKey(v, w(u,v));
Extract-Min is executed |V| times
Decrease-Key is executed O(|E|) times
while loop is executed |V| times
updating keys

65. Prim’s Running Time Time complexity depends on data structure Q
Binary heap: O(E lg V):
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)

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