Complexity of Prim s Algorithm

Transcription

1 The main loop is: Complexity of Prim s Algorithm while ( not ISEMPTY(Q) ): u = EXTRACT-MIN(Q) if p[u]!= NIL: A = A U {(p[u],u)} for v in adjacency-list[u]: if v in Q and w(u,v) < priority[v] : DECREASE-PRIORITY(v, w(u,v)) p[v] = u Q: What would you expect the complexity of DECREASE-PRIORITY to be? O(log n) Q: How many times does the while loop iterate? at most once for every vertex in the graph. Q: How many times do we consider each edge? To answer this let s look at what happens for u the current vertex. Consider the current vertex u that gets inserted into A: Which edges does the algorithm consider? The algorithm analyzes ea How many times can each of these edges be looked at? Since u is added to A and never becomes the current vertex again, w 83

2 What is the worst case complexity when considering each edge? When we consider an edge, we might decrease the priority of What is the overall loop complexity then? The loop takes time at most What is the complexity of building the initial heap take? n log n Therefore, the worst-case running time is O(m log n). Heap Sort How can we use a heap to sort an array? def HEAP-SORT(array A): BUILD-HEAP(A) while ( heapsize>1): swap(a[heapsize 84

3 [ Section 4.2 ] The Disjoint Set ADT: Disjoint Set or Union-Find ADT Objects: A collection of nonempty disjoint sets S = S 1,S 2,...,S k, i.e., each S i is a nonempty set that has no element in common with any other S j. In mathematical notation this is: S i \ S j =, 8i 6= j Each set is identified by a unique element called its representative. Operations: MAKE-SET(x): Given an element x that does not already belong to one of the sets, create a new set {x} that contains only x (a FIND-SET(x): Given an element x, return the representative of the UNION(x,y): Given two distinct elements x and y let S x be the set that contains x and S y be the set that contains y. UNION(x,y) is an operation that results in a new set consisting of S x [ S y. 85

4 Two things need to be updated to maintain a valid collection of sets: 1. Remove S x and S y from the collection (since all the sets must be 2. Picks a representative for the new set. Note: If both x and y belong to the same set already (i.e., S x = S y ), nothing is done by this operation. Applications Maintaining the set of connected components of a graph. Maintain lists of duplicate copies of webpages. Constructing a minimum spanning tree for a graph (Kruskal). Finding connected components: For all v in V do MAKE-SET(v) For all (u,v) in E do UNION(u,v) Q: How can we test whether u and v are connected? FIND-SET(u) == FIND-SET(v)? 86

5 Kruskal s Algorithm for MSTs Intuition: Grow an MST A by repeatedly adding the lightest edge from E that does not create a cycle. Example s Order of edges in priority queue: 2,4,5,6,8,9, Let G =(V,E) and w : E! Z be a function that gives the weight of each edge. We use the weight of each edge as it s priority. Let Q be a priority queue. KRUSKAL-MST(G=(V,E),w:E->Z): A = {} for e in E: Q.ENQUEUE(e) for v in V: MAKE-SET(v) while (Q not empty): e = EXTRACT-MIN(Q): \\ e = (u,v) if FIND-SET(u)!= FIND-SET(v): UNION(u,v) A = A U {e} 87

6 Q: Which line checks that adding edge e to A does not create a cycle? FIND-SET(u) 6= FIND-SET(v). 1. Arrays 2. Linked lists 3. Trees Arrays Data Structures for Disjoint Sets One position for each element. Each position stores the element and an index to the set representative. For example, the collection of sets {{A}, {B, E}, {C, F, G}, {D}} could be represented using the following array: A B C D E F G

7 Operations MAKE-SET(x): store x in the next available location, takes time: O(1): FIND-SET(x): the index value stored with x indicates the representative of the set containing x, so FIND-SET(x) takes time O(1). UNION(x,y): Let X be the index value stored with x and Y be the index value stored with y. If X 6= Y, then... go through every element in the array and replace every index value Example: UNION(A,E) results in: A B C D E F G 89

8 Linked-list with front pointer. Represent each set by a linked list, with the first element in the list being its representative each element in the list has a pointer back to the head and a pointer to the next element. Let list x represent the list containing x. You may assume the head of the list also has a pointer to the tail for the UNION operation. Operations MAKE-SET(x): create a new linked list with element x Complexity: O(1) FIND-SET(x): Follow x s pointer back to the head. Complexity: O(1) UNION(x,y): Append list y to the end of list x, update the pointers. Complexity: (length of list y ) Why? Since we can find the head of list y and the tail of list x in constant tim 90

9 Worst-case sequence complexity for m operations: Upper Bound The number of elements in the structure at any point in any sequence of m operations is apple m. The complexity of each operation in a sequence is O(m), so the total time is O(m 2 ). Lower Bound Perform m/2+1 MAKE-SETs with different elements. Then do m/2 1 UNIONs with a set of size one and the growing lis Total time is (m 2 )= P m/2 i=1 i. Problem? still very inefficient if we have long unions. Q: How can we fix this? Linked list with extra pointer to front and union-by-weight ) Now we keep track of the number of elements in each list. Q: Are MAKE-SET and FIND-SET affected? no. Q: What about UNION? We always append the smaller set to the longer one (so we have fewer po This is called union-by-weight. The weight of a set is simply its size. 91

10 Worst-case sequence complexity for m operations: Upper Bound Let n be the number of MAKE-SET operations in the sequence (so there are never more than n elements in total). For some arbitrary element x, how many times can x s back pointer can be updated? Consider when this happens: This happens only when list x is UNIONed with a set that is no small So each time x s back pointer is updated, the resulting set must have size at least twice list x. So the limit on the number of times that x 0 s back pointer is updated is log(n) times. This is true for every element x. Therefore, the total number of pointer updates during the entire sequence of operations is O(n log n). Since the time for other operations is still O(1), and there are m operations in total, the total time for the entire sequence is O(m + n log n). 92