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::{self, Read};
use std::str::FromStr;
pub struct Scanner<R: Read> {
    reader: R,
}
impl<R: Read> Scanner<R> {
    pub fn new(reader: R) -> Scanner<R> {
        Scanner { reader: reader }
    }
    pub fn read<T: FromStr>(&mut self) -> T {
        let s = self
            .reader
            .by_ref()
            .bytes()
            .map(|c| c.expect("failed to read char") as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect::<String>();
        s.parse::<T>().ok().expect("failed to parse token")
    }
}

struct UnionFind {
    vals: Vec<usize>, // 自身の親を記録する。親がない場合は自身のindexを保持する
}

impl UnionFind {
    fn new(size: usize) -> UnionFind {
        UnionFind {
            vals: (0..size).map(|i| i).collect(),
        }
    }

    fn parent(&mut self, idx: usize) -> usize {
        if self.vals[idx] == idx {
            idx
        } else {
            // 親の探索と同時に根となる親へ参照を変更する
            let p = self.vals[idx];
            let p = self.parent(p);
            self.vals[idx] = p;
            p
        }
    }

    fn same(&mut self, id1: usize, id2: usize) -> bool {
        self.parent(id1) == self.parent(id2)
    }

    fn unite(&mut self, id1: usize, id2: usize) {
        let p1 = self.parent(id1);
        let p2 = self.parent(id2);
        if p1 != p2 {
            self.vals[p1] = p2;
        }
    }
}

fn main() {
    let sin = io::stdin();
    let sin = sin.lock();
    let mut sc = Scanner::new(sin);

    let n: usize = sc.read();
    let q: usize = sc.read();

    let mut uf = UnionFind::new(n);

    for _ in 0..q {
        let com: usize = sc.read();
        let x: usize = sc.read();
        let y: usize = sc.read();

        match com {
            0 => { uf.unite(x, y); },
            1 => { 
                if uf.same(x,y) {
                    println!("1");
                } else {
                    println!("0");
                };
            },
            _ => { panic!("irregular command"); },
        }
    }
}