/*******************************************************************************
 * Copyright (c) 2002 - 2006 IBM Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package com.ibm.wala.util.intset;


/**
 * An implementation of Tarjan's union-find, using path compression and balancing, for non-negative integers
 */
public class IntegerUnionFind {
  
  private final static int MAX_VALUE = Integer.MAX_VALUE / 4;

  final private static int DEFAULT_SIZE = 100;
  /**
   * 
   * parent[i+1] =
   * <ul>
   * <li>j > 0 if i is in the same equiv class as j
   * <li>j <= 0 if i is the representative of a class of size -(j)+1
   * </ul>
   * 
   * we initialize parent[j] = 0, so each element is a class of size 1
   */
  int[] parent;

  public IntegerUnionFind() {
    this(DEFAULT_SIZE);
  }

  /**
   * @param size initial size of the tables
   */
  public IntegerUnionFind(int size) {
    if (size  < 0 || size > MAX_VALUE) {
      throw new IllegalArgumentException("illegal size: " + size);
    }
    parent = new int[size + 1];
  }

  /**
   * union the equiv classes of x and y
   */
  public void union(int x, int y) {
    if (x < 0) {
      throw new IllegalArgumentException("invalid x : " + x);
    }
    if (y < 0) {
      throw new IllegalArgumentException("invalid y: " + y);
    }
    if (x > MAX_VALUE) {
      throw new IllegalArgumentException("x is too big: " + x);
    }
    if (y > MAX_VALUE) {
      throw new IllegalArgumentException("y is too big: " + y);
    }
    if (x >= size() || y >= size()) {
      grow(2 * Math.max(x, y));
    }
    // shift by one to support sets including 0
    x += 1;
    y += 1;
    x = findInternal(x);
    y = findInternal(y);
    if (x != y) {
      // glue smaller tree onto larger tree (balancing)
      if (parent[x] < parent[y]) {
        // x's class has more elements
        parent[x] += parent[y] - 1;
        parent[y] = x;
      } else {
        // y's class has more elements (or the same number)
        parent[y] += parent[x] - 1;
        parent[x] = y;
      }
    }
  }

  private void grow(int size) {
    int[] old = parent;
    parent = new int[size + 1];
    System.arraycopy(old, 0, parent, 0, old.length);
  }

  /**
   * @param x
   * @return representative of x's equivalence class
   */
  public int find(int x) {
    if (x < 0) {
      throw new IllegalArgumentException("illegal x " + x);
    }
    if (x >= size()) {
      return x;
    }

    // shift by one to support sets including 0
    return findInternal(x + 1) - 1;
  }

  /**
   * @param x
   * @return representative of x's equivalence class
   */
  private int findInternal(int x) {
    int root = x;
    while (parent[root] > 0) {
      root = parent[root];
    }
    // path compression
    while (parent[x] > 0) {
      int z = x;
      x = parent[x];
      parent[z] = root;
    }

    return root;
  }

  /**
   */
  public int size() {
    return parent.length - 1;
  }

}