Download presentation

Presentation is loading. Please wait.

Published byJohanna Brackett Modified over 2 years ago

1
CS 253: Algorithms Chapter 23 Minimum Spanning Tree Credit: Dr. George Bebis

2
Minimum Spanning Trees Spanning Tree A tree (i.e., connected, acyclic graph) which contains all the vertices of the graph Minimum Spanning Tree Spanning tree with the minimum sum of weights Spanning forest If a graph is not connected, then there is a spanning tree for each connected component of the graph a bcd e hgf i 4 8 7 8 11 1 2 7 2 4 14 9 10 6

3
3 Sample applications of MST Find the least expensive way to connect a set of cities, terminals, computers, etc. A town has a set of houses. A road connects 2 and only 2 houses. Repair Cost for road (u,v) is w(u, v) Problem: Repair enough roads such that: 1. Everyone stays connected 2. Total repair cost is minimum a bcd e hgf i 4 8 7 8 11 1 2 7 2 4 14 9 10 6

4
Properties of Minimum Spanning Trees Minimum spanning tree is not unique MST has no cycles (by definition) : # of edges in a MST: |V| - 1

5
Prims Algorithm Starts from an arbitrary root: V A = {a} At each step: Find a light edge crossing (V A, V - V A ) Add this edge to set A (The edges in set A always form a single tree) Repeat until the tree spans all vertices a bcd e hgf i 4 8 7 8 11 1 2 7 2 4 14 9 10 6

6
How to Find Light Edges Quickly? Use a priority queue Q contains vertices not yet included in the tree, i.e. (V - V A ) V A = {a}, Q = {b, c, d, e, f, g, h, i} We associate a key with each vertex v in Q: key[ v ] = minimum weight of any edge (u, v) connecting v to V A After adding a new node to V A we update the weights of all the nodes adjacent to it. e.g., after adding a to the tree, Key[b]=4 and Key[h]=8 a bcd e hgf i 4 8 7 8 11 1 2 7 2 4 14 9 10 6

7
Example 0 Q = {a, b, c, d, e, f, g, h, i} V A = Extract-MIN(Q) a a bcd e hgf i 4 8 7 8 11 1 2 7 2 4 14 9 10 6 a bcd e hgf i 4 8 7 8 11 1 2 7 2 4 14 9 10 6 key [b] = 4 [b] = a key [h] = 8 [h] = a 4 8 Q = {b, c, d, e, f, g, h, i} V A = {a} Extract-MIN(Q) b 4 8

8
4 8 8 Example a bcd e hgf i 4 8 7 8 11 1 2 7 2 4 14 9 10 6 Q = {c, d, e, f, g, h, i} V A = {a, b} key [c] = 8 [c] = b key [h] = 8 [h] = a - unchanged 8 8 Extract-MIN(Q) c a bcd e hgf i 4 8 7 8 11 1 2 7 2 4 14 9 10 6 Q = {d, e, f, g, h, i} V A = {a, b, c} key [d] = 7 [d] = c key [f] = 4 [f] = c key [i] = 2 [i] = c 7 4 8 2 Extract-MIN(Q) i 4 8 8 7 4 2

9
9 Example a bcd e hgf i 4 8 7 8 11 1 2 7 2 4 14 9 10 6 Q = {d, e, f, g, h} V A = {a, b, c, i} key [h] = 7 [h] = i key [g] = 6 [g] = i 7 4 6 7 Extract-MIN(Q) f a bcd e hgf i 4 8 7 8 11 1 2 7 2 4 14 9 10 6 Q = {d, e, g, h} V A = {a, b, c, i, f} key [g] = 2 [g] = f key [d] = 7 [d] = c unchanged key [e] = 10 [e] = f 7 10 2 7 Extract-MIN(Q) g 4 7 8 4 8 2 7 6 4 7 7 6 4 8 2 2 10

10
Example a bcd e hgf i 4 8 7 8 11 1 2 7 2 4 14 9 10 6 Q = {d, e, h} V A = {a, b, c, i, f, g} key [h] = 1 [h] = g 7 10 1 Extract-MIN(Q) h a bcd e hgf i 4 8 7 8 11 1 2 7 2 4 14 9 10 6 Q = {d, e} V A = {a, b, c, i, f, g, h} 7 10 Extract-MIN(Q) d 4 7 10 7 2 4 8 2 1 4 7 1 2 4 8 2

11
11 Example a bcd e hgf i 4 8 7 8 11 1 2 7 2 4 14 9 10 6 Q = {e} V A = {a, b, c, i, f, g, h, d} key [e] = 9 [e] = d 9 Extract-MIN(Q) e Q = V A = {a, b, c, i, f, g, h, d, e} 4 7 10 1 2 4 8 2 9

12
PRIM( V, E, w, r ) % r : starting vertex 1. Q 2. for each u V 3. do key[u] 4. π[u] NIL 5. INSERT( Q, u ) 6. DECREASE-KEY( Q, r, 0 ) % key[r] 0 7. while Q 8. do u EXTRACT-MIN( Q ) 9. for each v Adj[u] 10. do if v Q and w(u, v) < key[v] 11. then π[v] u 12. DECREASE-KEY( Q, v, w(u, v) ) O(V) if Q is implemented as a min-heap Executed |V| times Takes O(lgV) Min-heap operations: O(VlgV) Executed O(E) times total Constant Takes O(lgV) O(ElgV) Total time: O(VlgV + ElgV) = O(ElgV) O(lgV)

13
13 Prims Algorithm Total time: O(ElgV ) Prims algorithm is a greedy algorithm Greedy algorithms find solutions based on a sequence of choices which are locally optimal at each step. Nevertheless, Prims greedy strategy produces a globally optimum solution!

14
14 We would add edge (c, f) a bcd e hgf i 4 8 7 8 11 1 2 7 2 4 14 9 10 6 Kruskals Algorithm Start with each vertex being its own component Repeatedly merge two components into one by choosing the lightest edge that connects them Which components to consider at each iteration? Scan the set of edges in monotonically increasing order by weight. Choose the smallest edge.

15
Example 1. Add (h, g) 2. Add (c, i) 3. Add (g, f) 4. Add (a, b) 5. Add (c, f) 6. Ignore (i, g) 7. Add (c, d) 8. Ignore (i, h) 9. Add (a, h) 10. Ignore (b, c) 11. Add (d, e) 12. Ignore (e, f) 13. Ignore (b, h) 14. Ignore (d, f) a bcd e hgf i 4 8 7 8 11 1 2 7 2 4 14 9 10 6 1: (h, g) 2: (c, i), (g, f) 4: (a, b), (c, f) 6: (i, g) 7: (c, d), (i, h) 8: (a, h), (b, c) 9: (d, e) 10: (e, f) 11: (b, h) 14: (d, f) {g, h}, {a}, {b}, {c},{d},{e},{f},{i} {g, h}, {c, i}, {a}, {b}, {d}, {e}, {f} {g, h, f}, {c, i}, {a}, {b}, {d}, {e} {g, h, f}, {c, i}, {a, b}, {d}, {e} {g, h, f, c, i}, {a, b}, {d}, {e} {g, h, f, c, i, d}, {a, b}, {e} {g, h, f, c, i, d, a, b}, {e} {g, h, f, c, i, d, a, b, e} {a}, {b}, {c}, {d}, {e}, {f}, {g}, {h}, {i}

16
Operations on Disjoint Data Sets Kruskals Alg. uses Disjoint Data Sets (UNION-FIND : Chapter 21) to determine whether an edge connects vertices in different components MAKE-SET( u ) – creates a new set whose only member is u FIND-SET( u ) – returns a representative element from the set that contains u. It returns the same value for any element in the set UNION( u, v ) – unites the sets that contain u and v, say S u and S v E.g.: S u = {r, s, t, u}, S v = {v, x, y} UNION (u, v) = {r, s, t, u, v, x, y} We had seen earlier that FIND-SET can be done in O(lgn) or O(1) time and UNION operation can be done in O(1) (see Chapter 21)

17
1. A 2. for each vertex v V 3. do MAKE-SET( v ) 4. sort E into non-decreasing order by w 5. for each (u, v) taken from the sorted list 6. do if FIND-SET( u ) FIND-SET( v ) 7. then A A { (u, v) } 8. UNION( u, v ) 9. return A Running time: O(V+ElgE+ElgV) O(ElgE) Implemented by using the disjoint-set data structure (UNION-FIND) Kruskals algorithm is greedy It produces a globally optimum solution KRUSKAL( V, E, w ) O(V) O(ElgE) O(E) O(lgV)

18
Problem 1 Compare Prims algorithm with Kruskals algorithm assuming: (a) Sparse graphs: E=O(V) Kruskal: UNION-FIND: O(ElgE) = O(VlgV) Prim: Binary heap: O(ElgV) = O(VlgV) (b) Dense graphs: E = O(V 2 ) Kruskal: O(ElgE) = O(V 2 lgV 2 ) = O(2V 2 lgV) = O(V 2 lgV) Prim: Binary heap: O(ElgV) = O(V 2 lgV)

19
19 Problem 2 Analyze the running time of Kruskals algorithm when weights are in the range [1 … V] ANSWER: Sorting can be done in O(E) time (e.g., using counting sort) However, overall running time will not change, i.e., O(ElgV)

20
20 Problem 3 Suppose that some of the weights in a connected graph G are negative. Will Prims algorithm still work? What about Kruskals algorithm? Justify your answers. ANSWER: Yes, both algorithms will work with negative weights. There is no assumption in the algorithm about the weights being positive.

21
21 Problem 4 Analyze Prims algorithm assuming: (a) an adjacency-list representation of G O(ElgV) (b) an adjacency-matrix representation of G O(ElgV+V 2 ) (see next slide)

22
PRIM( V, E, w, r ) 1. Q 2. for each u V 3. do key[u] 4. π[u] NIL 5. INSERT( Q, u ) 6. DECREASE-KEY( Q, r, 0 ) % key[r] 0 7. while Q 8. do u EXTRACT-MIN( Q ) 9. for each v Adj[u] 10. do if v Q and w(u, v) < key[v] 11. then π[v] u 12. DECREASE-KEY( Q, v, w(u, v) ) O(V) if Q is implemented as a min-heap Executed |V| times Takes O(lgV) Min-heap operations: O(VlgV) Executed O(E) times total Constant Takes O(lgV) O(ElgV) Total time: O(VlgV + ElgV) = O(ElgV) O(lgV)

23
PRIM( V, E, w, r ) 1. Q 2. for each u V 3. do key[u] 4. π[u] NIL 5. INSERT( Q, u ) 6. DECREASE-KEY( Q, r, 0 ) % key[r] 0 7. while Q 8. do u EXTRACT-MIN( Q ) 9. for (j=0; j<|V|; j++) 10. do if (A [u][j]=1) and ( v Q ) and ( w(u, v)

24
24 Problem 5 Find an algorithm for the maximum spanning tree. That is, given an undirected weighted graph G, find a spanning tree of G of maximum cost. Prove the correctness of your algorithm. Consider choosing the heaviest edge (i.e., the edge associated with the largest weight) in a cut. The generic proof can be modified easily to show that this approach will work. Alternatively, multiply the weights by -1 and apply either Prims or Kruskals algorithms without any modification at all!

25
Problem 6 Let T be a MST of a graph G, and let L be the sorted list of the edge weights of T. Show that for any other MST T of G, the list L is also the sorted list of the edge weights of T Proof: Kruskals algorithm will find T in the order specified by L. Similarly, if T is also an MST, Kruskals algorithm should be able to find it in the sorted order, L. If L L, then there is a contradiction! Because at the point where L and L differ, Kruskals should have picked the smaller of the two and therefore L is impossible to obtain. T, L = {1,2}

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google