output_description: Print the maximum possible number of i such that p_i = i after operations.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N M
      p_1 p_2 .. p_N
      x_1 y_1
      x_2 y_2
      :
      x_M y_M
attempt: def read_values(): return map(int, input().split())
  def read_index(): return map(lambda x: int(x) - 1, input().split())
  def read_list(): return list(read_values())
  def read_lists(N): return [read_list() for n in range(N)]
  
  
  class UF:
      def __init__(self, N):
          self.state = [-1] * N
          self.rank = [0] * N
          self.num_group = N
      
      def get_parent(self, a):
          p = self.state[a]
          if p < 0:
              return a
          
          q = self.get_parent(p)
          self.state[a] = q
          return q
  
      def make_pair(self, a, b):
          pa = self.get_parent(a)
          pb = self.get_parent(b)
          if pa == pb:
              return
  
          if self.rank[pa] > self.rank[pb]:
              pa, pb = pb, pa
              a, b = b, a
          elif self.rank[pa] == self.rank[pb]:
              self.rank[pb] += 1
  
          self.state[pb] += self.state[pa]
          self.state[pa] = pb
          self.state[a] = pb
          self.num_group -= 1
      
      def is_pair(self, a, b):
          return self.get_parent(a) == self.get_parent(b)
  
      def get_size(self, a):
          return -self.state[self.get_parent(a)]
  
  N, M = read_values()
  A = read_list()
  uf = UF(N)
  for _ in range(M):
      i, j = read_index()
      uf.make_pair(A[i] - 1, A[j] - 1)
  
  res = 0
  for i, a in enumerate(A):
      if uf.is_pair(i, A[i] - 1)
  
  print(res)
problem_description: Statement
  
  We have a permutation of the integers from 1 through N, p_1, p_2, .., p_N. We
  also have M pairs of two integers between 1 and N (inclusive), represented as
  (x_1,y_1), (x_2,y_2), .., (x_M,y_M). AtCoDeer the deer is going to perform the
  following operation on p as many times as desired so that the number of i (1 ≤
  i ≤ N) such that p_i = i is maximized:
  
    * Choose j such that 1 ≤ j ≤ M, and swap p_{x_j} and p_{y_j}.
  
  Find the maximum possible number of i such that p_i = i after operations.
samples: [{"input": "5 2\n    5 3 1 4 2\n    1 3\n    5 4", "output": "2\n    \n\nIf we perform the operation by choosing j=1, p becomes `1 3 5 4 2`, which is\noptimal, so the answer is 2.\n\n* * *"}, {"input": "3 2\n    3 2 1\n    1 2\n    2 3", "output": "3\n    \n\nIf we perform the operation by, for example, choosing j=1, j=2, j=1 in this\norder, p becomes `1 2 3`, which is obviously optimal. Note that we may choose\nthe same j any number of times.\n\n* * *"}, {"input": "10 8\n    5 3 6 8 7 10 9 1 2 4\n    3 1\n    4 1\n    5 9\n    2 5\n    6 5\n    3 5\n    8 9\n    7 9", "output": "8\n    \n\n* * *"}, {"input": "5 1\n    1 2 3 4 5\n    1 5", "output": "5\n    \n\nWe do not have to perform the operation."}]