package edu.princeton.cs.algs4.ch15;
import edu.princeton.cs.introcs.*;
/****************************************************************************
* Compilation: javac UF.java
* Execution: java UF < input.txt
* Dependencies: StdIn.java StdOut.java
* Data files: http://algs4.cs.princeton.edu/15uf/tinyUF.txt
* http://algs4.cs.princeton.edu/15uf/mediumUF.txt
* http://algs4.cs.princeton.edu/15uf/largeUF.txt
*
* Weighted quick-union by rank with path compression by halving.
*
* % java UF < tinyUF.txt
* 4 3
* 3 8
* 6 5
* 9 4
* 2 1
* 5 0
* 7 2
* 6 1
* 2 components
*
****************************************************************************/
/**
* The <tt>UF</tt> class represents a <em>union-find data type</em>
* (also known as the <em>disjoint-sets data type</em>).
* It supports the <em>union</em> and <em>find</em> operations,
* along with a <em>connected</em> operation for determinig whether
* two sites in the same component and a <em>count</em> operation that
* returns the total number of components.
* <p>
* The union-find data type models connectivity among a set of <em>N</em>
* sites, named 0 through <em>N</em> – 1.
* The <em>is-connected-to</em> relation must be an
* <em>equivalence relation</em>:
* <ul>
* <p><li> <em>Reflexive</em>: <em>p</em> is connected to <em>p</em>.
* <p><li> <em>Symmetric</em>: If <em>p</em> is connected to <em>q</em>,
* <em>q</em> is connected to <em>p</em>.
* <p><li> <em>Transitive</em>: If <em>p</em> is connected to <em>q</em>
* and <em>q</em> is connected to <em>r</em>, then
* <em>p</em> is connected to <em>r</em>.
* </ul>
* An equivalence relation partitions the sites into
* <em>equivalence classes</em> (or <em>components</em>). In this case,
* two sites are in the same component if and only if they are connected.
* Both sites and components are identified with integers between 0 and
* <em>N</em> – 1.
* Initially, there are <em>N</em> components, with each site in its
* own component. The <em>component identifier</em> of a component
* (also known as the <em>root</em>, <em>canonical element</em>, <em>leader</em>,
* or <em>set representative</em>) is one of the sites in the component:
* two sites have the same component identifier if and only if they are
* in the same component.
* <ul>
* <p><li><em>union</em>(<em>p</em>, <em>q</em>) adds a
* connection between the two sites <em>p</em> and <em>q</em>.
* If <em>p</em> and <em>q</em> are in different components,
* then it replaces
* these two components with a new component that is the union of
* the two.
* <p><li><em>find</em>(<em>p</em>) returns the component
* identifier of the component containing <em>p</em>.
* <p><li><em>connected</em>(<em>p</em>, <em>q</em>)
* returns true if both <em>p</em> and <em>q</em>
* are in the same component, and false otherwise.
* <p><li><em>count</em>() returns the number of components.
* </ul>
* The component identifier of a component can change
* only when the component itself changes during a call to
* <em>union</em>—it cannot change during a call
* to <em>find</em>, <em>connected</em>, or <em>count</em>.
* <p>
* This implementation uses weighted quick union by rank with path compression
* by halving.
* Initializing a data structure with <em>N</em> sites takes linear time.
* Afterwards, the <em>union</em>, <em>find</em>, and <em>connected</em>
* operations take logarithmic time (in the worst case) and the
* <em>count</em> operation takes constant time.
* Moreover, the amortized time per <em>union</em>, <em>find</em>,
* and <em>connected</em> operation has inverse Ackermann complexity.
* For alternate implementations of the same API, see
* {@link QuickUnionUF}, {@link QuickFindUF}, and {@link WeightedQuickUnionUF}.
*
* <p>
* For additional documentation, see <a href="http://algs4.cs.princeton.edu/15uf">Section 1.5</a> of
* <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne.
*
* @author Robert Sedgewick
* @author Kevin Wayne
*/
public class UF {
private int[] id; // id[i] = parent of i
private byte[] rank; // rank[i] = rank of subtree rooted at i (cannot be more than 31)
private int count; // number of components
/**
* Initializes an empty union-find data structure with <tt>N</tt>
* isolated components <tt>0</tt> through <tt>N-1</tt>
* @throws java.lang.IllegalArgumentException if <tt>N < 0</tt>
* @param N the number of sites
*/
public UF(int N) {
if (N < 0) throw new IllegalArgumentException();
count = N;
id = new int[N];
rank = new byte[N];
for (int i = 0; i < N; i++) {
id[i] = i;
rank[i] = 0;
}
}
/**
* Returns the component identifier for the component containing site <tt>p</tt>.
* @param p the integer representing one object
* @return the component identifier for the component containing site <tt>p</tt>
* @throws java.lang.IndexOutOfBoundsException unless <tt>0 ≤ p < N</tt>
*/
public int find(int p) {
if (p < 0 || p >= id.length) throw new IndexOutOfBoundsException();
while (p != id[p]) {
id[p] = id[id[p]]; // path compression by halving
p = id[p];
}
return p;
}
/**
* Returns the number of components.
* @return the number of components (between <tt>1</tt> and <tt>N</tt>)
*/
public int count() {
return count;
}
/**
* Are the two sites <tt>p</tt> and <tt>q</tt> in the same component?
* @param p the integer representing one site
* @param q the integer representing the other site
* @return true if the two sites <tt>p</tt> and <tt>q</tt> are in the same component; false otherwise
* @throws java.lang.IndexOutOfBoundsException unless
* both <tt>0 ≤ p < N</tt> and <tt>0 ≤ q < N</tt>
*/
public boolean connected(int p, int q) {
return find(p) == find(q);
}
/**
* Merges the component containing site <tt>p</tt> with the
* the component containing site <tt>q</tt>.
* @param p the integer representing one site
* @param q the integer representing the other site
* @throws java.lang.IndexOutOfBoundsException unless
* both <tt>0 ≤ p < N</tt> and <tt>0 ≤ q < N</tt>
*/
public void union(int p, int q) {
int i = find(p);
int j = find(q);
if (i == j) return;
// make root of smaller rank point to root of larger rank
if (rank[i] < rank[j]) id[i] = j;
else if (rank[i] > rank[j]) id[j] = i;
else {
id[j] = i;
rank[i]++;
}
count--;
}
/**
* Reads in a an integer <tt>N</tt> and a sequence of pairs of integers
* (between <tt>0</tt> and <tt>N-1</tt>) from standard input, where each integer
* in the pair represents some site;
* if the sites are in different components, merge the two components
* and print the pair to standard output.
*/
public static void main(String[] args) {
int N = StdIn.readInt();
UF uf = new UF(N);
while (!StdIn.isEmpty()) {
int p = StdIn.readInt();
int q = StdIn.readInt();
if (uf.connected(p, q)) continue;
uf.union(p, q);
StdOut.println(p + " " + q);
}
StdOut.println(uf.count() + " components");
}
}
/*************************************************************************
* Copyright 2002-2012, Robert Sedgewick and Kevin Wayne.
*
* This file is part of algs4-package.jar, which accompanies the textbook
*
* Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,
* Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.
* http://algs4.cs.princeton.edu
*
*
* algs4-package.jar is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* algs4-package.jar is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with algs4-package.jar. If not, see http://www.gnu.org/licenses.
*************************************************************************/