Union-Find Disjoint Set

Transcription

1

2 Union-Find Disjoint Set An ADT(Abstract Data Type) used to manage disjoint sets of elements. Operations supported Union: Given3 2 elements, if they belong to different sets, merge the Union(1, 2) 4 sets into Find(5) Find: Given 2an element, find the set it belongs 2to 4 6

3 Implementing Union-Find Disjoint Set Data structure for Disjoint Set Algorithms for Union and Find operations Run time analysis & reflection

4 Version 1(Quick Find) Data Structure Each Set is represented as a list, and the head of the list is used as the representative(identifier) of the set To facilitate find, each node contains a pointer to its representative The representative records the number of elements in the set

5 Version 1(Quick Find) Union(x,y) Merge all elements in the smaller set to the larger set Update the number of elements in the combined set Redirect the representative pointer in all the elements of the smaller set Find(x) If the representative pointer of x is null, return itself Else, return its representative pointer

6 Example of Version 1 Initial state 1 Union(2,6) Union(3,8) Union(3,9) Union(2,3)

7 Analysis of Version 1

8 Analysis of Version 1 Amortized run time of Union(cont ) If an element is still contained in a singleton, we say it is still not touched by the Union operations; or else, it is touched k Union operations touch at most 2*k elements If an Union operation merges 2 singletons, it adds 2 untouched elements If it merges a singleton to an non-singleton, it adds 1 untouched element

9 Analysis of Version 1 Amortized run time of Union(cont ) The total run time of k Union operations is at most 2 * k * log n The amortized run time = 2 * k * log n / k = O (log n)

10 Reflection on Version 1 It is because we have to update all the representative pointers in the smaller set that makes Union operation slow What if we only update the representative pointer of the representative of the smaller set?

11 Version 2(Quick Union) Data Structure Each element has a pointer to the representative of the set it was merged to(if any) Each element records the size of the set of which it was the representative Next pointer is not needed any more because we do not have to update the representative pointer of all elements in the smaller set

12 Version 2(Quick Union) Union(x, y) Find the representatives of x and y using Find Redirect the representative pointer of the smaller set to the representative of the larger set Find(x) Follow the representative pointer chain until root and return root.

13 Example of Version 2/Union Initial state 1 Union(2,6) Union(3,8) Union(3,9)

14 Example of Version 2/Union Union(3,9) Union(2,3)

15 Analysis of Version 2 T T1 T2

16 Analysis of Version 2 If the size of the set is n, the height of its tree representation is at most log n + 1 Proof by contradiction using the previous characteristic The worst run time of both Union and Find is O(log n) The amortized run time is better log n Find

17 Reflection on Version 2 If we do m Finds on element e, the total time is m * log n; if we redirect the representative pointer to root in the first Find, the total time becomes shorter.

18 Version 3(Path Compression) Data Structure The same as Version 2 Union The same as Version 2 Find(x) For all the node in the path from x to root, redirect their representative pointer to root

19 Example Find(4)

20 Example Find(12)

21 Run time analysis of Version 3

22 Review of non-recursive algorithm analysis + S=0; for (j = 1; j <= n; j++) { for (k=j; k <= n; k++){ S++; } } + + = 11/15/

23 Analyzing recursive algorithms F1(A, k1, k2): m = (k2-k1+1)/2; if (m <= 0): return; B = new a vector of size m; for (j = 1; j < m; j++): B[j] = A[k1+2*j] A[k1+2*j-1]; F1(A, k1, k1+m); F1(A, k1+m+1, k2); F1(B, 1, m); 11/15/ = Recurrence + 23

24 Recursion tree(1) 11/15/

25 Important properties of logarithm 11/15/

26 Recursion tree(2) Property 2 11/15/

27 Recursion tree(3) Property 2 11/15/

28 Recursion tree(4) 11/15/

29 Example 11/15/

30 Recursion tree 11/15/

31 Many recurrence relations arising from divide-and-conquer algorithms have the form: T(n) = at(n/b) + f(n) where a 1, b>1 are constants and f is asymptotically positive We create a problem instances, each of size n/b 31

32 32

33 33

34 34

35 Solving T(n) = at(n/b) + f(n) 35

36 f(n) grows polynomially slower than g(n) Does a polynomial nε separate and g(n)? f(n) 36

37 T(n) = at(n/b) + f(n) 37

38 38

39 T(n) = at(n/b) + f(n) 39

40 40

41 T(n) = at(n/b) + f(n) 41

42 f(n) grows polynomially faster than g(n) 42

43 T(n) = T(n/2) + n log n = Ɵ (n log n) a=1, b=2, n logb a = O(1), f(n) = n log n regularity condition: 1*n/2*log (n/2) < n/2 log n we have c=1/2<1 T(n) = 4T(n/2) + n3 = Ɵ(n3) 43 a=4, b=2, n log a = n2, f(n) = n3

44 44

45 Outside the Master Theorem T(n) = T( n) + c = O(log log n) T(n) = T(n/4) + T(n/2) + n2 = O(n2) T(n) = 2T(n-1) + 1 = O(2n) f(n) = f(n-1) + f(n-2) 45 T(n) = 4T(n/2) + n2/log n Has the right form, but... compare n2 and n2/log n: f(n) is smaller