output_description: Print the K-th lexicographically smallest substring of K.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      s
      K
attempt: import sys
  from collections import deque
  
  readline = sys.stdin.readline
  n, m = map(int, readline().split())
  P = list(map(lambda x: int(x) - 1, readline().split()))
  G = [set() for _ in range(n)]
  for i in range(m):
      x, y = map(lambda x: int(x) - 1, readline().split())
      G[x].add(y)
      G[y].add(x)
  
  D = {}
  cnt = 0
  V = [-1] * n
  while -1 in V:
      st = V.index(-1)
      que = deque([st])
      V[st] = cnt
      D[cnt] = set([P[st]])
      while que:
          nw = que.popleft()
          for nx in G[nw]:
              if V[nx] != -1:
                  continue
              D[cnt].add(P[nx])
              V[nx] = cnt
              que.append(nx)
      cnt += 1
  print(sum([int(i in D[V[i]]) for i in range(n)]))
  
problem_description: Statement
  
  You are given a string s. Among the **different** substrings of s, print the
  K-th lexicographically smallest one.
  
  A substring of s is a string obtained by taking out a non-empty contiguous
  part in s. For example, if s = `ababc`, `a`, `bab` and `ababc` are substrings
  of s, while `ac`, `z` and an empty string are not. Also, we say that
  substrings are different when they are different as strings.
  
  Let X = x_{1}x_{2}...x_{n} and Y = y_{1}y_{2}...y_{m} be two distinct strings.
  X is lexicographically larger than Y if and only if Y is a prefix of X or
  x_{j} > y_{j} where j is the smallest integer such that x_{j} \neq y_{j}.
samples: [{"input": "aba\n    4", "output": "b\n    \n\ns has five substrings: `a`, `b`, `ab`, `ba` and `aba`. Among them, we should\nprint the fourth smallest one, `b`. Note that we do not count `a` twice.\n\n* * *"}, {"input": "atcoderandatcodeer\n    5", "output": "andat\n    \n\n* * *"}, {"input": "z\n    1", "output": "z"}]