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 Rust (judge verdict: Accepted)

use std::io::{stdin, Read, StdinLock};
use std::str::FromStr;

use std::vec;

struct UnionFind {
    par: vec::Vec<i32>,
}

impl UnionFind {
    fn new(n: usize) -> UnionFind {
        let mut res = UnionFind { par: vec::Vec::with_capacity(n), };
        for _i in 0..n {
            res.par.push(-1);
        }
        res
    }
    fn root(&mut self, x: i32) -> i32 {
        let x_id = x as usize;
        if self.par[x_id] < 0 {
            x
        } else {
            let p = self.par[x_id];
            self.par[x_id] = self.root(p);
            self.par[x_id]
        }
    }

    fn unite(&mut self, x: i32, y: i32) -> bool {
        let x = self.root(x);
        let y = self.root(y);
        if x == y {
            false
        } else {
            let x_id = x as usize;
            let y_id = y as usize;
            if self.size(x) < self.size(y) {
                self.par[y_id] = self.par[y_id] + self.par[x_id];
                self.par[x_id] = y;
            } else {
                self.par[x_id] = self.par[x_id] + self.par[y_id];
                self.par[y_id] = x;
            }
            true
        }
    }

    fn same(&mut self, x: i32, y: i32) -> bool {
        self.root(x) == self.root(y)
    }

    fn size(&mut self, x: i32) -> i32 {
        let r = self.root(x) as usize;
        -self.par[r]
    }
}

struct Scanner<'a> {
    cin: StdinLock<'a>,
}

impl<'a> Scanner<'a> {
    fn new(cin: StdinLock<'a>) -> Scanner<'a> {
        Scanner {cin: cin}
    }

    fn read1<T: FromStr>(&mut self) -> Option<T> {
        let token = self.cin.by_ref().bytes().map(|c| c.unwrap() as char)
                    .skip_while(|c| c.is_whitespace())
                    .take_while(|c| !c.is_whitespace())
                    .collect::<String>();
        token.parse::<T>().ok()
    }

    fn read<T: FromStr>(&mut self) -> T {
        self.read1().unwrap()
    }
}

fn main() {
    let cin = stdin();
    let cin = cin.lock();
    let mut sc = Scanner::new(cin);
    let n: usize = sc.read();
    let q: i32 = sc.read();
    let mut uf = UnionFind::new(n);
    for _q in 0..q {
        let com: i32 = sc.read();
        let x: i32 = sc.read();
        let y: i32 = sc.read();
        if com == 0 {
            uf.unite(x, y);
        } else {
            println!("{}", uf.same(x, y) as i32);
        }
    }
}