Disjoint Sets : ADT. Disjoint-Set : Find-Set

Transcription

1 Disjoint Sets : ADT Disjoint-Set Forests Make-Set( x ) Union( s, s ) Find-Set( x ) : π( ) : π( ) : ν( log * n ) amortized cost 6 9 {,, 9,, 6} set # {} set # 7 5 {5, 7, } set # Disjoint-Set : Find-Set Disjoint Set : Union 9 6 {,, 9,, 6} set # Find-Set( 6 ) = Find-Set( ) = Find-Set( ) = π( h ) 9 6 Union(, ) 7 5

2 Disjoint Set : Union Disjoint Set : Two Heuristics Union(, ) Union : Smart Union Find-Set : Path Compression Union by height Union by size Disjoint Set : Smart Union Union by height Smart Union 7 5 Union by size

3

4

5

6 height = π( log n ) Union : π(), Find-Set : π( log n )

7 Path Compression Path Compression 7 7 Find-Set( ) = Find-Set( ) = Find-Set( ) = 7 p[] = 7 Find-Set( ) = Find-Set( ) = Find-Set( ) = 7 p[] = p[] = 7 Path Compression 7 Find-Set( ) = Find-Set( ) = Find-Set( ) = 7 p[] = p[] = p[] = 7 Union by Rank With path compression Union by height : inefficient to recompute heights Union by size : perfectly compatible Union by rank rank = estimated height no height updates during path compression

8 Make-Set Union by Rank Make-Set( x ) { p[x] = x rank[x] = } Union( s, s ) { if rank[s] > rank[s] p[s] = s else p[s] = s if rank[s] = rank[s] rank[s]++ } x 5 y rank[x] < rank[y] 5 y x 5 rank[x] = rank[y] Union(x, y) Union(x, y) Union by Rank x x y y Find-Set( x ) { if x = p[x] return x p[x] = Find-Set( p[x] ) return p[x] } No rank is updated during path compression Find-Set

9 Union by Rank & Path Compression n elements (n Make-Sets, at most n- Unions) m Make-Set, Union, and Find-Set operations m = Ω( n ) worst case = Ο( m α(m, n) ) α(m, n) is the inverse of Ackermann s function a very very very slow function Ackermann s Function and Inverse A(, j ) = j for j A( i, ) = A( i-, ) for i A( i, j ) = A( i-, A(i, j-) ) for i, j α( m, n ) = min{ i : A( i, m/n ) > lg n } Ackermann s Function Analysis i j } } n elements (n Make-Sets, at most n- Unions) m Make-Set, Union, and Find-Set operations m = Ω( n ) union by rank, path compression worst case = O( m α(m, n) ) = O( m log * n ) }6 }6 } }6 } } lg* m n = n + proof this

10 Properties of Ranks : # For all tree roots x, size( x ) rank( x ) Basis : rank =, = = only one root node Induction : Let s Union( a, b ) rank is increased by only if rank(a) = rank(b) size( a b ) = size( a ) + size( b ) rank[ a ] + rank[ b ] Properties of Ranks : # The ranks of the nodes on a path from a leaf to a root increase monotonically x y z = rank[ a ]+ = rank[ a b ] x y z Find-Set( x ) Properties of Ranks : # The number of nodes of rank r is at most n/ r each node of rank r is the root of a subtree of at least r nodes (property #) all subtrees are disjoint there are at most n / r disjoint subtrees of rank r there are at most n / r nodes of rank r Properties of Ranks For all tree roots x, size(x) rank(x) The ranks of the nodes on a path from a leaf to a root increase monotonically The number of nodes of rank r is at most n/ r

11 Analysis Actual cost of Find-Set( x ) is the number of nodes of the path from x to the root Accounting method : deposit baht for every node on the path from x to the root For m operations, how many bahts did we spend? Rank Grouping Partition ranks into groups group contains only elements of rank rank r goes to group G(r) the largest rank in any group g is F(g), F = G - the number of ranks in any group g > is F(g)-F(g-) Rank Grouping : Example Money Deposit F( g ) = g G( r ) = r.5 Group Rank,, 5, 6,..., 9,,, 6 i (i-) +,, i Find-Set( x ) group x Rank # s are monotonically increasing group group central account

12 Money Deposit Money Deposit Rules After path compression 9 x All of the deposited nodes along the access path get a new parent of higher rank central account Deposit one baht at the central account if v is the root the parent of v is the root the parent of v is in a different group from v Otherwise deposit one baht into the node Central Account Central Account Deposit After m operations, the total deposit at the central account is at most m( G(n) + ) Each operation deposits at most ( G(n) + ) bahts. groups : G(n) = Find-Set( x ) x bahts G(n) bahts

13 Central Account Each operation deposits at most ( G(n) + ) bahts. The total deposit at the central account, after m operations, is at most m( G(n) + ) Node Accounts Let node v be in group g. How many bahts can be deposited into node v? If one baht is deposited into a node v, v will get a new parent of higher rank. Money Deposit Money Deposit Find-Set( x ) x Find-Set( x ) x

14 Money Deposit Node Accounts After path compression 9 x All of the deposited nodes along the access path get a new parent of higher rank. Let node v be in group g. How many bahts can be deposited into node v? If one baht is deposited into a node v, v will get a new parent of higher rank. How many times can v be moved before its parent get pushed out of group g? Answer : the number of ranks in group g = F(g) - F(g-) - ( F(g) is the largest rank # in group g )

15

16

17

18 + + + Group Rank,,, 5,..., + Any node in group can be deposited at most - = bahts.

19 The Number of Nodes in a Group Total Node Deposit The number of nodes, V(g), in group g > is at most n/ F(g-) V ( g) n = F ( g ) n r r= F ( g ) + r r= F ( g ) + n F ( g ) + s= = F ( g ) + n = F ( g ) n s The maximum number of bahts deposited to all nodes in group g is at most n F(g) / F(g-) the number of nodes in group g > is at most n/ F(g-) each node gets at most F(g)-F(g-)- bahts F(g) - F(g-) - < F(g) G(n) The total node deposit is at most Σ n F(g) / F(g-) g= Total Deposit Total Deposit G(n) m ( G(n)+ ) + n Σ F(g) / F(g-) g= Central account deposit Total node deposit What are G(n) and F(g)? G(n) m ( G(n)+ ) + n Σ F(g) / F(g-) g= Let F( g ) = g, G( r ) = r n m ( n + ) + n Σ g / (g-) g= < m ( n + ) + n = O( m n ) Very loose upper bound, worse than O( m log n )

20 G(n) m ( G(n)+ ) + n Σ F(g) / F(g-) g= Total Deposit Let F( g ) = F(g-), G( r ) = + lg* n +lg*n m ( +lg*n + ) + n Σ (g-) / (g-) g= = m ( +lg*n ) + n( +lg*n ) = O( m log* n ) m = Ω(n) Conclusion n elements (n Make-Sets, at most n- Unions) m Make-Set, Union, and Find-Set operations m = Ω( n ) union by rank, path compression worst case = O( m log* n ) : almost linear amortized cost = O( log* n ) : almost constant