Problem:
Disjoint Set

Write a program which manipulates a disjoint set S = {S1, S2, . . . , Sk}.

First of all, the program should read an integer n, then make a disjoint set where each element consists of 0, 1, ... n−1 respectively.

Next, the program should read an integer q and manipulate the set for q queries. There are two kinds of queries for different operations:

unite(x, y): unites sets that contain x and y, say Sx and Sy, into a new set.

same(x, y): determine whether x and y are in the same set.

Input

n q
com1 x1 y1
com2 x2 y2
...
comq xq yq

In the first line, n and q are given. Then, q queries are given where com represents the type of queries. '0' denotes unite and '1' denotes same operation.

Output

For each same operation, print 1 if x and y are in the same set, otherwise 0, in a line.

Constraints

1 ≤ n ≤ 10000

1 ≤ q ≤ 100000

x ≠ y

Sample Input

5 12
0 1 4
0 2 3
1 1 2
1 3 4
1 1 4
1 3 2
0 1 3
1 2 4
1 3 0
0 0 4
1 0 2
1 3 0

Sample Output

0
0
1
1
1
0
1
1

Solution in Scala (judge verdict: Accepted)

object Main extends App {
  val Seq(n,q): Seq[Int] = io.StdIn.readLine().split(" ").map(_.toInt)
  val ds = new DisjointSets(n)
  (0 until q) foreach {_ =>
    io.StdIn.readLine().split(" ").map(_.toInt) match {
      case Array(0, x, y) => ds.union(x, y)
      case Array(1, x, y) => println(if (ds.same(x,y)) 1 else 0)
    }
  }
}
class DisjointSets(size: Int) {
  val parent: Array[Int] = Array.tabulate(size)(i => i)
  val rank: Array[Int] = Array.fill(size)(0)
  def union(x: Int, y: Int): Unit = {
    val i = find(x)
    val j = find(y)
    if (rank(i) > rank(j)) parent(j) = i
    else {
      parent(i) = j
      rank(i) += (if (rank(i) == rank(j)) 1 else 0)
    }
  }
  def find(x: Int): Int = parent(x) match {
    case p if x == p => x
    case p =>
      val i = find(p)
      parent(x) = i
      rank(x) = 0
      i
  }
  def same(x: Int, y: Int):Boolean = find(x) == find(y)
}