Disjoint Sets. Chapter 21. CPTR 430 Algorithms Disjoint Sets 1

Transkript

1 Disjoint Sets Chapter 21 CPTR 430 Algorithms Disjoint Sets 1

2 S2 Disjoint Sets A disjoint-set data structure maintains a collection S 1 S k of disjoint dynamic sets Each set has a designated representative which is an element of the set For some applications, the representative may be arbitrary For others, the smallest element is the representative (if the elements can be ordered) CPTR 430 Algorithms Disjoint Sets 2

3 Disjoint Set Operations makeset(x) creates a new set whose only member is x union(x,y) combines the sets that contain elements x and y If x S x and y S y, then union(x,y) returns a new set equal to S x S y S x and S y are disjoint before the union() operation The representative of the resulting set can be any element in S x S y, but usually we choose either the representative of S x or S y The original sets, S x and S y are removed from findset(x) returns a reference to the representative of the set containing x CPTR 430 Algorithms Disjoint Sets 3

4 Skeleton Implementation public class DisjointSet { public static void makeset(dselement element) { /* To be determined */ public static void union(dselement x, DSElement y) { /* To be determined */ public static DSElement findset(dselement element) { /* To be determined */ CPTR 430 Algorithms Disjoint Sets 4

5 Disjoint Set Analysis n the number makeset() operations m the total number of makeset(), and union(), and findset() operations The sets in are disjoint, so Each union() operation reduces by 1 After n 1 union() operations 1 The number of union() operations is at most n 1 m n For the purposes of analysis, assume the first n operations are makeset() operations CPTR 430 Algorithms Disjoint Sets 5

6 Applications of Disjoint Sets Determining the connected components of an undirected graph Kruskal s minimum spanning tree algorithm In FORTRAN, handling the EQUIVALENCE(X,Y) statement Type unification by compilers and interpreters of dynamically typed programming languages Image processing blob coloring Colorizing old movies CPTR 430 Algorithms Disjoint Sets 6

7 Sample Application Detecting the Connected Components of an Undirected Graph This undirected graph has four connected components: a b e f h j c d g i CPTR 430 Algorithms Disjoint Sets 7

8 Connectivity Algorithm public class ConnectedGraph { public static void connectedcomponents(graph g) { Vertex[] vertices = g.getvertices(); Edge[] edges = g.getedges(); for ( int i = 0; i < vertices.length; i++ ) { DisjointSet.makeSet(vertices[i]); for ( int i = 0; i < edges.length; i++ ) { DSElement fromsetrep = DisjointSet.findSet(edges[i].from), tosetrep = DisjointSet.findSet(edges[i].to); if ( fromsetrep!= tosetrep ) { DisjointSet.union(fromSetRep, tosetrep); public static boolean samecomponent(vertex v1, Vertex v2) { return DisjointSet.findSet(v1) == DisjointSet.findSet(v2); CPTR 430 Algorithms Disjoint Sets 8

9 Connectivity Algorithm connectedcomponents() initially places each vertex into its own set Next, all edges are examined; an edge connecting two vertices implies that the two vertices are to be unioned into one set After all edges have been examined, two vertices are within the same connected component if samecomponent() returns true For things to work, a vertex object must reference an associated disjoint set object and vice-versa CPTR 430 Algorithms Disjoint Sets 9

10 Linked List Implementation The linked list implementation is simple The first element in the list is the set s representative Each element in the list contains: a data object a pointer to the next element in the list a pointer to the representative data next rep CPTR 430 Algorithms Disjoint Sets 10

11 Linked List Implementation (cont.) Pointers head and tail refer, respectively, to the first and last elements in the list head points to the representative tail points to the position where a new element can be added and another set can be unioned a b c d head data data data data next next next next tail rep rep rep rep CPTR 430 Algorithms Disjoint Sets 11

12 Efficiency of the Linked Implementation makeset() Create a new list with one element O 1 findset() Return the pointer to the representative stored in each node O 1 union() Attach one list to end of the other The end can be found quickly via the tail pointer Updating the representative pointers in every node in the attached list takes time proportional to the length of the attached list O n CPTR 430 Algorithms Disjoint Sets 12

13 x2 The Amortized Analysis In the worst case, a sequence of m operations requires O n 2 time Take objects x 1 x n perform the operations Operation Number of Objects Updated makeset(x 1 ) 1 makeset(x 2 ) 1.. makeset(x n ) 1.. union(x 1 x2)1 union(x 2 x3)2 union(x 3 x4)3 union(x n.. 1 xn)n CPTR 430 Algorithms Disjoint Sets 13 1

14 The Amortized Analysis (cont.) The operation sequence is n makeset()s following by n such that the longer list is always appended to the shorter list The n makeset() operations take Θ n time The i th union() operation updates i objects Total number of objects updated by all n 1 union()s 1 union() operations is n 1 i 1 i Θ n 2 The total number of operations is 2n Each operation on average requires Θ n 1 time By aggregate analysis, then, the amortized cost of each operation is Θ n CPTR 430 Algorithms Disjoint Sets 14

15 Weighted-union Heuristic Ensure that the shorter list is always appended to the longer list Fewer representative pointers to update Maintain the length of each list (easy add an extra integer field) A union can still require Ω n if both lists have Ω n elements Helps a little? CPTR 430 Algorithms Disjoint Sets 15

16 It Does Better than Θ n 2 Given: linked list representation with the weighted-union heuristic Any sequence of m makeset(), findset(), and union() operations, n of which are makeset() operations, takes O m nlgn time (Theorem 21.1) Why? CPTR 430 Algorithms Disjoint Sets 16

17 Consider each object in a set of size n For a given object, x, how many times has its representative been updated? The first time it was updated it originally had to have been an element in the smaller set, since the weighted-union heuristic always appends the smaller list to the larger one After x s representative was updated the first time, x s resulting set must have had at least two elements (Why?) The next time x s representative is updated, x s set must have at least four elements (Again, why?) For all k n, the resulting set has at least k elements after x s representative has been updated times lgn CPTR 430 Algorithms Disjoint Sets 17

18 Proof of Theorem 21.1 (cont.) For all k n, the resulting set has at least k elements after x s representative has been updated times lgn The largest set has at most n elements (Why?) Each element in that largest set has been updated at most lgn times The time to update the n elements is O nlgn The time to adjust the head and tail pointers, as well as the length field, is constant CPTR 430 Algorithms Disjoint Sets 18

19 Proof of Theorem 21.1 (cont.) The makeset() and findset() operations take O 1 time There are O m makeset() and findset() operations The time for the entire sequence of m operations is O m nlgn CPTR 430 Algorithms Disjoint Sets 19

20 Disjoint-set Forests A set is represented by a rooted tree The root is the set s representative Each node points to its parent (the root points to itself) So, unlike trees we are used to seeing, the pointers point up instead of down c f f h e d union( e,g) c d b g h e g b CPTR 430 Algorithms Disjoint Sets 20

21 Operation Implementations makeset() create a tree containing one node findset() follow parent pointers until the root is found The path is called the find path union() redirect the parent pointer of one of the roots to point to the other root c f f h e d union( e,g) c d b g h e g b CPTR 430 Algorithms Disjoint Sets 21

22 Efficiency of Disjoint-set Forests The straightforward approach is no better than the linked list version A sequence of n 1 union() operations can create a tree of height n A couple of heuristics can tweak the implementation into the asymptotically fastest disjoint-set data structure known Union by rank Path compression CPTR 430 Algorithms Disjoint Sets 22

23 Union by Rank Same idea as weighted-union for linked lists The root of the tree with fewer nodes points to the root of the tree with more nodes We could have each node keep track of the number of nodes in its subtree Instead, each node maintains a rank that is an upper bound on its height union() then redirects the pointer of the root of the tree with smaller rank to the root of the tree with larger rank CPTR 430 Algorithms Disjoint Sets 23

24 Path Compression Simple in concept and to implement but very effective Alter the findset() operation so that each node on the find path points directly to the root instead of its immediate parent Path compression does not affect any ranks (Why?) c c h e d g findset( ) g b h e d b f f g CPTR 430 Algorithms Disjoint Sets 24

25 Disjoint-set Forest Implementation The node definition is slightly different: public class Node { public DSElement data; // Element to store public Node parent; // Pointer to the parent node public int rank; public Node(DSElement d) { data = d; parent = this; // No parent node yet rank = 0; // No subtree for this new node data.setnode(this); CPTR 430 Algorithms Disjoint Sets 25

26 Disjoint-set Forest Implementation (cont.) public class DisjointSet { public static void makeset(dselement element) { new Node(element); public static void union(dselement x, DSElement y) { link(findset(x), findset(y)); private static void link(dselement x, DSElement y) { Node nx = findset(x).getnode(), ny = findset(y).getnode(); if ( nx.rank >= ny.rank ) { ny.parent = nx; else { nx.parent = ny; if ( nx.rank == ny.rank ) { ny.rank++;... CPTR 430 Algorithms Disjoint Sets 26

27 Disjoint-set Forest Implementation (cont.) public class DisjointSet {... public static DSElement findset(dselement element) { Node node = element.getnode(); if ( node.parent!= node ) { node.parent = findset(node.parent.data).getnode(); return node.parent.data; Note the recursion in findset() findset() uses two passes: The first pass up the tree to find the root (representative) The second pass is down the tree to update the parents of all the nodes in the find path (to point directly to the root) The recursive calls make up the first pass The returns from the recursive calls make up the second pass CPTR 430 Algorithms Disjoint Sets 27

28 Do the Heuristics Help? Union by rank, by itself, yields a running time of O mlgn Path compression, by itself, yields a running time of Θ n f 1 log 2 f n n where n is the number of makeset() operations (which means at most n union() operations) f is the number of findset() operations 1 CPTR 430 Algorithms Disjoint Sets 28

29 The Combined Effect Together, they yield a running time of O m α n where α n is a very slowly growing function For all practical applications of disjoint sets, α n 4 Thus, the running time is linear in m, for all practical purposes CPTR 430 Algorithms Disjoint Sets 29