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)

#[allow(unused_imports)]
use std::cmp::{min,max};

struct DisjointSet {
    ps: Vec<Option<usize>>,
    ns: Vec<i64>,
}

fn init(n: usize) -> DisjointSet {
    return DisjointSet { ps: vec![None; n], ns: vec![1; n] };
}

fn unite(ds: &mut DisjointSet, x: usize, y: usize) {
    let nx = find(ds, x);
    let ny = find(ds, y);
    if nx == ny {
        return;
    }
    let (a,b) = if ds.ns[nx] < ds.ns[ny] { (nx,ny) } else { (ny,nx) };
    ds.ps[a] = Some(b);
    ds.ns[b] += ds.ns[a];
}

fn find(ds: &mut DisjointSet, x: usize) -> usize {
    match ds.ps[x] {
        Some(y) => {
            let res = find(ds, y);
            ds.ps[x] = Some(res);
            return res;
        },
        None => {
            return x;
        },
    }
}

fn same(ds: &mut DisjointSet, x: usize, y: usize) -> bool {
    return find(ds,x) == find(ds,y);
}

fn main() {
    let xs = read_vec_i64();
    let (n,q) = (xs[0] as usize, xs[1] as usize);
    let mut ds = init(n);
    for _ in 0..q {
        let ys = read_vec_i64();
        let (com,x,y) = (ys[0], ys[1] as usize, ys[2] as usize);
        if com == 0 {
            unite(&mut ds, x, y);
        }
        else {
            println!("{}", if same(&mut ds,x,y) { 1 } else { 0 });
        }
    }
}

#[allow(dead_code)]
fn read_line() -> String {
    let mut ret = String::new();
    std::io::stdin().read_line(&mut ret).ok();
    ret.pop();
    return ret;
}

#[allow(dead_code)]
fn read_i64() -> i64 {
    let ss = read_line();
    return ss.parse::<i64>().unwrap();
}

#[allow(dead_code)]
fn read_vec_i64() -> Vec<i64> {
    let mut res = vec![];
    let ss = read_line();
    for ts in ss.split_whitespace() {
        let x = ts.parse::<i64>().unwrap();
        res.push(x);
    }
    return res;
}