Union-Find Algorithm

1. Dynamic Connectivity Problem

• Points on an N x N grid are initially not connected.
• Direct connections between adjacent points are to be added randomly.
• At each step a point is selected randomly and then a random neighbor is selected.
• If these two points are not already connected by some sequence of connected points, then connect them; otherwise don't add a connection.
• This is an example of the dynamic connectivity problem
• In particular the problem is to determine whether the points are already connected or not.

2. UF (Union-Find) Interface

public interface UF
{
    public int find(int p);          // returns site p's component/group id
    public boolean connected(int p, int q); // returns true if p and q are connected
    public void union(int p, int q); // adds connection between p and q
    public int count();              // returns number of components
}

• A class that implements this interface will have a constructor that takes an integer parameter n, that specifies the number of sites.
• The integers 0, 1, ..., n-1 will represent the n sites.
• The count() method returns the number of connected groups (components).
• Before any direct connections are made, each site is in its own component (i.e., singletons). So there would initially be n components, and count() would be n.
• If every site is connected to every other site, there would be just 1 component.

Representation of site-components using an array (named 'id').

• An array g of size n; id[v] = group number for site v. id[v] represents v’s “group”.

        0   1   2   3   4   5   6   7
      +---+---+---+---+---+---+---+---+
  id  | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
      +---+---+---+---+---+---+---+---+ 

3. Approach #1: Quick-Find

• Each time we connect v and w, change all entries for v’s group to w’s group. In other words,
• union(v,w): change id[i] to id[v] for all i where id[i] == id[w]

 public void union(int p, int q)
{
  int pcomp = find(p);
  int qcomp = find(q);
        
  if(pcomp == qcomp) {
    return;
  }
  components--;
  for(int i = 0; i < n; i++) {
    if (id[i] == pcomp) {
      id[i] = qcomp;
    }
  }
}

        0   1   2   3   4   5   6   7
      +---+---+---+---+---+---+---+---+
  id  | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
      +---+---+---+---+---+---+---+---+ 

      +---+---+---+---+---+---+---+---+
  id  | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
      +---+---+---+---+---+---+---+---+ 

      +---+---+---+---+---+---+---+---+
  id  | 3 | 3 | 2 | 3 | 4 | 5 | 6 | 7 |
      +---+---+---+---+---+---+---+---+ 

        0   1   2   3   4   5   6   7
      +---+---+---+---+---+---+---+---+
  id  | 3 | 3 | 2 | 3 | 5 | 5 | 6 | 7 |
      +---+---+---+---+---+---+---+---+ 

        0   1   2   3   4   5   6   7
      +---+---+---+---+---+---+---+---+
  id  | 5 | 5 | 2 | 5 | 5 | 5 | 6 | 7 |
      +---+---+---+---+---+---+---+---+ 

        0   1   2   3   4   5   6   7
      +---+---+---+---+---+---+---+---+
  id  | 5 | 5 | 7 | 5 | 5 | 5 | 6 | 7 |
      +---+---+---+---+---+---+---+---+ 

But the complexity is not so good. Order of growth of union(p,q) is n if p and q are not connected.

EXERCISE: [Textbook Exercise #1.5.1 (p.  235)] Show the contents of the id[] array and the number of times the array is accessed for each input pair when you use quick-find for the sequence 9-0, 3-4, 5-8, 7-2, 2-1, 5-7, 0-3, 4-2.

4. Approach #2: Quick-Union

• Maintain an array of indices of “parents”
• If v has no parent (v is root), parent[v] == v
• union(v,w) : parent[root(w)] = v
• connected(v,w): root(v) == root(w)

Conceptually this scheme is easier to understand if we think of a tree model:

• For each component, one of its members will serve as the label.
• All the other sites in a component will be thought of as children of that site. E.g.,

  For n = 10 and three components:

        {0,2,6} {1,3,4} {5,7,8,9}
      

  could be represented as three trees:

        0         1           5
        |         |           |
      +---+     +---+       +-+-+
      |   |     |   |       | | |     
      2   6     3   4       7 8 9
     

  while the array representation is

          0   1   2   3   4   5   6   7   8   9
        +---+---+---+---+---+---+---+---+---+---+
    id  | 0 | 1 | 0 | 1 | 1 | 5 | 0 | 5 | 5 | 5 |
        +---+---+---+---+---+---+---+---+---+---+ 

  Then union(0,1) only makes id[0] = 1, but doesn't change id[2] or id[6]:

           1             5
           |             |
       +---+---+       +-+-+
       |   |   |       | | |     
       0   3   4       7 8 9
       |  
     +---+
     |   |
     2   6
  

          0   1   2   3   4   5   6   7   8   9
        +---+---+---+---+---+---+---+---+---+---+
    id  | 1 | 1 | 0 | 1 | 1 | 5 | 0 | 5 | 5 | 5 |
        +---+---+---+---+---+---+---+---+---+---+ 

• Another diagram from the textbook:
  
• Now then union() becomes:

  public void union(int p, int q)
  {
    int pcomp = find(p);
    int qcomp = find(q);
  
    if (pcomp == qcomp) {
      return;
    }
  
    components--;
    id[pcomp] = qcomp;  // (**)
  }

• Another Example:

        0   1   2   3   4   5   6   7
      +---+---+---+---+---+---+---+---+
  id  | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
      +---+---+---+---+---+---+---+---+ 

      +---+---+---+---+---+---+---+---+
  id  | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
      +---+---+---+---+---+---+---+---+ 

      +---+---+---+---+---+---+---+---+
  id  | 1 | 3 | 2 | 3 | 4 | 5 | 6 | 7 |
      +---+---+---+---+---+---+---+---+ 

        0   1   2   3   4   5   6   7
      +---+---+---+---+---+---+---+---+
  id  | 1 | 3 | 2 | 3 | 5 | 5 | 6 | 7 |
      +---+---+---+---+---+---+---+---+ 

        0   1   2   3   4   5   6   7
      +---+---+---+---+---+---+---+---+
  id  | 1 | 3 | 2 | 5 | 5 | 5 | 6 | 7 |
      +---+---+---+---+---+---+---+---+ 

        0   1   2   3   4   5   6   7
      +---+---+---+---+---+---+---+---+
  id  | 1 | 3 | 7 | 5 | 5 | 5 | 6 | 7 |
      +---+---+---+---+---+---+---+---+ 

• But find() requires tracing up the path to the root..

  public find(int p)
  {
    while(p != id[p]) { // parent not the same
      p = id[p]; // re-assign p to be its parent
    }
    return p;
  }

  And the path may become long... There are two ways to reduce the heights:

  • weighted union
  • path compression in find

5. Approach #4: Weighted Union

• Rather than arbitrarily connecting the second tree to the first for union()in the quick-union algorithm, we keep track of the size of each tree and always connect the smaller tree to the larger.

  

6. Approach #5: Weighted Union with Path Compression

     4 (height 0)          8  (height 1)
                          /|\ 
                         3 9 5

      0         1           5  
      |         |           |  
    +---+     +---+       +---+
    |   |     |   |       |   |
    2   6     3   4       7   8
        |                      
        9                        

1. p = 9 and q = 8

2. pcomp = 0 and qcomp = 5

3. make 0 be a child of 5      

4. make sites p to pcomp be a children of qcomp: make 9 and 6 be
   children of 5
    

   0         1           5               1               5
   |         |           |               |               |    
 +---+     +---+       +---+    =>     +---+         +---+---+
 |   |     |   |       |   |           |   |         |   |   |
 2   6     3   4       7   8           3   4         0   7   8
     |                                               |         
     9                                             +---+       
                                                   |   |       
                                                   2   6       
                                                       |       
                                                       9      

           1                    5
           |                    |
 =>      +---+              +-+-+-+-+
         |   |              | | | | |
         3   4              0 9 6 7 8
                            |  
                            2