Union-Find: A Data Structure for Disjoint Set Operations

Transcription

1 Union-Find: A Data Structure for Disjoint Set Operations 1

2 Equivalence Relations A equivalence relation R is defined on a set S, if for every pair of elements (a,b) in S, a R b is either false or true a R b is true iff: (Reflexive) a R a, for each element a in S (Symmetric) a R b if and only if b R a (Transitive) a R b and b R c implies a R c The equivalence class of an element a (in S) is the subset of S that contains all elements related to a 2

3 Equivalence Relations: Examples Electrical cable connectivity network Cities belonging to the same country 3

4 The Problem Given a set S of n elements, [a 1 a n ], compute all the equivalent class of all its elements 4

5 Properties of Equivalence Classes OBSERVATION: Each element has to belong to exactly one equivalence class COROLLARY: All equivalence classes are mutually disjoint What we are after is the set of all maximal equivalence classes 5

6 Disjoint Set Operations To identify all equivalence classes 1. Initially, put each each element in a set of its own 2. Permit only two types of operations: Find(x): Returns the equivalence class of x Union(x, y): Merges the equivalence classes corresponding to elements x and y, if and only if x is related to y 6

7 Steps in the Union (x, y) 1. EqClass x = Find (x) 2. EqClass y = Find (y) 3. EqClass xy = EqClass 1 U EqClass 1 Merge or union 7

8 A Simple Algorithm Using Union and Find operations Initially, put each element in a set of its own FOR EACH element pair (a,b): Check [a R b = true] IF a R b THEN Union(a,b) O(n 2 ) iterations 8

9 Initialization Initially, each element is put in one set of its own Start with n sets 9

10 After Union(4,5) After Union(6,7) 10

11 After Union(5,6) 11

12 The Union-Find Data Structure Two basic operations Find (x) Union (x, y) The set can be input as an array Uniquely identify each element by its array index (ie., value does not matter for find or union) 12

13 Union-Find Data Structure 13

14 Entry s[i] points to i th parent -1 means root 14

15 Union performed arbitrarily

16 Analysis of the simple version Each Union() takes only O(1) in the worst case Each Find() also could take O(n) time Therefore, m operations, where m>>n, would take O(mn) in the worst-case 16

17 Smarter Union Algorithms Problem with the arbitrary root attachment strategy in the simple approach is that: The tree, in the worst-case, could just grow along one long (O(n)) path Idea: Prevent such long chains from happening How? Enforce Union() to happen in a balanced way 17

18 Heuristic: Union-By-Size Attach the root of the smaller tree to the root of the larger tree Size=1 Size=4 How to Union(3,4)? 18

19 Union-By-Size: Good way An arbitrary union: Bad way 19

20 Alternative Heuristic: Union-By-Height Attach the root of the shallower tree to the root of the deeper tree Height=0 How to Union(3,4)? Height=2 20

21 Union-By-Height: (aka Union-By- Rank ) 21

22 How Good Are These Union Heuristics? Worst-case tree Maximum depth restricted to O(log n) 22

23 Code for Union-By-Rank 23

24 Analysis: Smart Union Heuristics Find() now takes O(log n), while Union() still takes O(1) time For m operations: O(m log n) run-time Can it be better? What is still causing the (log n) factor is the number of hops from each node to the root Idea: Get the root as close as possible to each node Path Compression! 24

25 Path Compression Heuristic During Find(x) operation: Update all the nodes along the path from x to the root point directly to the root A two-pass algorithm root It can be proven that path compression alone ensures that find(x) can be achieved in O(log n) over m operations Find(x): x 1 st Pass 2 nd Pass 25

26 Path Compression: Code 26

27 Heuristics & their Gains Arbitrary Union, Simple Find Union-by-size, Simple Find Union-by-rank, Simple Find Arbitrary Union, Path compression Find Union-by-rank, Path compression Find Worst-case run-time for m operations O(m n) O(m log n) O(m log n) O(m log n) Extremely slow Growing function O(m Inv.Ackermann(m,n)) = O(m log*n) 27

28 What is Inverse Ackermann Function? A(1,j) = 2 j for j>=1 A(i,1)=A(i-1,2) for i>=2 A(i,j)= A(i-1,A(i,j-1)) for i,j>=2 InvAck(m,n) = min{i A(i,floor(m/n))>log N} InvAck(m,n) = O(log*n) (pronounced log star n ) Even Slower! A very slow function 28

29 How Slow is Inverse Ackermann Function? InvAck(m,n) = O(log*n) Even Slower! A very slow function log*n = log log log log. n How many times we have to repeatedly take log on n to make the value to 1? log*65536=4, but log* =5 29

30 Union-by-Rank & Path-Compression: Code Init() Union() Find()

31 An Application: Maze 31

32 32

33 33

34 Example 2: Jigsaw Puzzle Merging Criterion: Visual & Geometric Alignment Picture Source: