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)

struct UnionFind{
    par:Vec<usize>,
}

impl UnionFind{
    fn new(n:usize)->UnionFind{
        let mut v=Vec::<usize>::new();
        for i in 0..n{
            v.push(i);
        }
        UnionFind{par:v,}
    }

    fn find(&mut self,x:usize)->usize{
        if self.par[x]!=x{
            let z=self.par[x];
            self.par[x]=self.find(z);
            self.par[x]
        }
        else {
            x
        }
    }
    fn unite(&mut self,x:usize,y:usize){
        let xx=self.find(x);
        let yy=self.find(y);
        self.par[yy]=xx;
    }

    fn same(&mut self,x:usize,y:usize)->i32{
        if self.find(x)==self.find(y){
            return 1;
        }
        0
    }
}

fn main(){
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    let v:Vec<usize>=s.trim().split_whitespace()
                    .map(|e|e.parse().unwrap()).collect();
    let (n,m)=(v[0],v[1]);
    let mut uf =UnionFind::new(n);
    for _ in 0..m {
        let mut t = String::new();
        std::io::stdin().read_line(&mut t).unwrap();
        let x:Vec<usize>=t.trim().split_whitespace()
                    .map(|e|e.parse().unwrap()).collect();
        match x[0]{
            1 => println!("{}",uf.same(x[1], x[2]) ),
            0 => uf.unite(x[1],x[2]),
            _ => println!("{}",x[0]),
        }
    }
}