Disjoint Sets. Definition Linked List Representation Disjoint-Set Forests. CS 5633 Analysis of Algorithms Chapter 21: Slide 1

Transcription

1 Disjoint Sets Definition Linked List Representation Disjoint-Set Forests CS 56 Analysis of Algorithms Chapter : Slide

2 Disjoint Sets (Union-Find Problem) O(lgn) O(lgn) A disjoint set data structure supports the following. x and y are elements. Make-Set(x): Creates a new set {x}. x must not be in any other set. Union(x, y): Combine the set that contains x with the set that contains y. Find-Set(x): Find-Set(x) = Find-Set(y) iff x and y are in the same set. CS 56 Analysis of Algorithms Chapter : Slide

3 Connected Components Example O(lgn) O(lgn) Example: Connected components of an undirected graph Connected-Components(G) for each vertex v in graph G Make-Set(v) for each edge (u,v) in graph G if Find-Set(u) Find-Set(v) then Union(u, v) CS 56 Analysis of Algorithms Chapter : Slide

4 Linked List Representation O(lgn) O(lgn) CS 56 Analysis of Algorithms Chapter : Slide 4

5 Linked List Operations O(lgn) O(lgn) Make-Set(x) set new set set.head x set.tail x set.size x.set set x.next nil Find-Set(x) return x.set Union(x, y) sx Find-Set(x) sy Find-Set(y) if sx = sy return if sx.size < sy.size then exchange sx sy sx.tail.next sy.head sx.tail sy.tail sx.size sx.size + sy.size while y nil y.set sx y y.next CS 56 Analysis of Algorithms Chapter : Slide 5

6 Amortized Analysis of Linked List O(lgn) O(lgn) Assume m including n Make-Sets. Analyze number of assignments to set field. Using accounting method of amortized analysis: Use amortized cost +lg n units per Make-Set. Consider an arbitrary element x. Use one unit immediately for Make-Set(x). Use one unit each time Union modifies x.set. CS 56 Analysis of Algorithms Chapter : Slide 6

7 Amortized Analysis Continued O(lgn) O(lgn) Union changes set fields of the smaller set, so a change to x.set at least doubles x s set size. The size of a set cannot exceed n = lgn, so the cost lgn+ covers all changes to x.set. Over n elements, the total amortized cost is n(lgn+). There can be O(m) Find-Set, so total time is O(m+nlgn). Easy to show n Unions can make (n/)lgn changes to set fields, so O(m+nlgn) is tight. CS 56 Analysis of Algorithms Chapter : Slide 7

8 Disjoint-Set Forests disjoint-set forests O(lgn) O(lgn) CS 56 Analysis of Algorithms Chapter : Slide 8

9 Disjoint-Set Forest Operations O(lgn) O(lgn) Assume x has fields parent and rank. Make-Set(x) x.parent x x.rank 0 Find-Set(x) if x = x.parent then return x else y Find-Set(x.parent) x.parent y return y CS 56 Analysis of Algorithms Chapter : Slide 9

10 Forest Operations Continued O(lgn) O(lgn) Union(x, y) x Find-Set(x) y Find-Set(y) if x = y return if x.rank > y.rank then y.parent x else x.parent y if x.rank = y.rank then y.rank y.rank+ CS 56 Analysis of Algorithms Chapter : Slide 0

11 O(lg n) Per Operation Analysis O(lgn) analysis O(lgn) The rank r is the height h of the tree: Basis: When r = 0, then h = 0. Assume: When r = k, then h k. Show: When r = k +, h k +. Induction: h can increase only when combining two trees with same r. CS 56 Analysis of Algorithms Chapter : Slide

12 O(lg n) Per Op. Analysis Continued O(lgn) O(lgn) analysis A tree with rank r has r nodes. Basis: When r = 0, there is 0 = node. Assume: When r = k, there are k nodes. Show: When r=k+, there are k+ nodes. Induction: r increases only when combining two trees with same r. Their union must have ( k ) = k+ nodes. Without considering compression, this implies that Find-Set will traverse lg n links/call. CS 56 Analysis of Algorithms Chapter : Slide

13 Amortized Analysis for O(lglgn) (not in book) O(lgn) O(lgn) O(lglgn) Let f be the number of Find-Sets excluding recursion. Let l,...,l f be the number of links compressed by calls to Find-Set. Want to bound f i= l i. Why? If a call to Find-Set compresses l links, then l nodes are closer to the root. Proof: A subtree of rank l now points to the root. This subtree has l nodes. CS 56 Analysis of Algorithms Chapter : Slide

14 O(lg lg n) Analysis Continued (not in book) O(lgn) O(lgn) O(lglgn) Let l be the average of l,...,l f. The number of recursive calls is fl. It can be shown that f i= l i f l. For, note that l + l+ > l + l There is nlgn distance to compress because each node is lgn away from the root. nlgn distance to compress implies f l nlgn. CS 56 Analysis of Algorithms Chapter : Slide 4

15 O(lglgn) Analysis Finished (not in book) O(lgn) O(lgn) O(lglgn) analysis Case : f n/(lgn) f n/(lgn) and l lgn imply fl n. Case : f n/(lgn) Start with f l nlgn. Implies (lgf)+l (lgn)+(lglgn) Implies l (lgn)+(lglgn) (lgf) (lgn)+(lglgn) lg(n/lgn) = (lgn)+(lglgn) (lgn)+(lglgn) = lglgn. so l is O(lglgn), which implies that the total cost of f Find-Sets is O(n+f lglgn). CS 56 Analysis of Algorithms Chapter : Slide 5