Problem:
Score : 100 points

Problem Statement

You are given an undirected graph with N vertices and 0 edges. Process Q queries of the following types.

0 u v: Add an edge (u, v).

1 u v: Print 1 if u and v are in the same connected component, 0 otherwise.

Constraints

1 \leq N \leq 200,000

1 \leq Q \leq 200,000

0 \leq u_i, v_i \lt N

Input

Input is given from Standard Input in the following format:

N Q
t_1 u_1 v_1
t_2 u_2 v_2
:
t_Q u_Q v_Q

出力

For each query of the latter type, print the answer.

Sample Input 1

4 7
1 0 1
0 0 1
0 2 3
1 0 1
1 1 2
0 0 2
1 1 3

Sample Output 1

0
1
0
1

Solution in C# (.NET Core 3.1.201) (judge verdict: Accepted)

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace AtCoderLibraryCSharp.Examples
{
    public static class Program
    {
        public static void Main()
        {
            var NQ = Console.ReadLine().Split(" ").Select(int.Parse).ToArray();
            var (N, Q) = (NQ[0], NQ[1]);
            var dsu = new DisjointSetUnion(N);
            for (var i = 0; i < Q; i++)
            {
                var TUV = Console.ReadLine().Split(" ").Select(int.Parse).ToArray();
                var (t, u, v) = (TUV[0], TUV[1], TUV[2]);
                if (t == 0) dsu.Merge(u, v);
                else Console.WriteLine(dsu.IsSame(u, v) ? 1 : 0);
            }
        }
        
        public class DisjointSetUnion
            {
                private readonly int _n;
                private readonly int[] _parentOrSize;
        
                public DisjointSetUnion(int n = 0)
                {
                    _n = n;
                    _parentOrSize = Enumerable.Repeat(-1, n).ToArray();
                }
        
                public int Merge(int a, int b)
                {
                    if (a < 0 || _n <= a) throw new IndexOutOfRangeException(nameof(a));
                    if (b < 0 || _n <= b) throw new IndexOutOfRangeException(nameof(b));
                    var (x, y) = (LeaderOf(a), LeaderOf(b));
                    if (x == y) return x;
                    if (-_parentOrSize[x] < -_parentOrSize[y]) (x, y) = (y, x);
                    _parentOrSize[x] += _parentOrSize[y];
                    _parentOrSize[y] = x;
                    return x;
                }
        
                public bool IsSame(int a, int b)
                {
                    if (a < 0 || _n <= a) throw new IndexOutOfRangeException(nameof(a));
                    if (b < 0 || _n <= b) throw new IndexOutOfRangeException(nameof(b));
                    return LeaderOf(a) == LeaderOf(b);
                }
        
                public int LeaderOf(int a)
                {
                    if (a < 0 || _n <= a) throw new IndexOutOfRangeException(nameof(a));
                    if (_parentOrSize[a] < 0) return a;
                    return _parentOrSize[a] = LeaderOf(_parentOrSize[a]);
                }
        
                public int SizeOf(int a)
                {
                    if (a < 0 || _n <= a) throw new IndexOutOfRangeException(nameof(a));
                    return -_parentOrSize[LeaderOf(a)];
                }
        
                public IEnumerable<IEnumerable<int>> GetGroups()
                {
                    var leaders = new int[_n];
                    var groupSize = new int[_n];
                    for (var i = 0; i < _n; i++)
                    {
                        leaders[i] = LeaderOf(i);
                        groupSize[leaders[i]]++;
                    }
        
                    var ret = new List<int>[_n].Select(x => new List<int>()).ToArray();
                    for (var i = 0; i < _n; i++) ret[leaders[i]].Add(i);
                    return ret.Where(x => x.Any());
                }
            }
    }
}