output_description: For each same operation, print 1 if x and y are in the same set, otherwise 0,
  in a line.
input_description: 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.
attempt: #!python3
  
  import sys
  
  iim = lambda: map(int, input().rstrip().split())
  
  
  def resolve():
      N, Q = iim()
  
      S = [[i] for i in range(N)]
  
      def find(i):
          x = S[i]
          while True:
              k = S[i][0]
              if k == i:
                  x[0] = i
                  return i
              S[i] = x
              i = k
  
      def union(i, j):
          ai = find(i)
          aj = find(j)
          if ai != aj:
              S[aj][0] = S[ai][0]
              S[aj] = S[ai]
  
      def same(i, j):
          ai = find(i)
          aj = find(j)
          return ai == aj
  
      ans = []
      for com, x, y in (map(int, line.split()) for line in sys.stdin):
  
          if com == 0:
              union(x, y)
              # print(x, y, *tuple(map(lambda x: (x, hex(id(x))[-4:]), S)))
          elif com == 1:
              ans.append(1 if same(x, y) else 0)
          else:
              raise 1
      print(*ans, sep="\n")
  
  
  if __name__ == "__main__":
      resolve()
  
problem_description: 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.
samples: [{"input": "12\n    0 1 4\n    0 2 3\n    1 1 2\n    1 3 4\n    1 1 4\n    1 3 2\n    0 1 3\n    1 2 4\n    1 3 0\n    0 0 4\n    1 0 2\n    1 3 0", "output": "0\n    1\n    1\n    1\n    0\n    1\n    1"}]