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: printn = lambda x: print(x, end="")
  inn = lambda: int(input())
  inl = lambda: list(map(int, input().split()))
  inm = lambda: map(int, input().split())
  ins = lambda: input().strip()
  DBG = True  # and False
  BIG = 10**18
  R = 10**9 + 7
  
  
  def ddprint(x):
      if DBG:
          print(x)
  
  
  def ufinit(n):
      global ufsz, ufances
      ufsz = [1] * n
      ufances = [0] * n
      for i in range(n):
          ufances[i] = i
  
  
  def ufroot(x):
      global ufances
      a = []
      y = x
      while ufances[y] != y:
          a.append(y)
          y = ufances[y]
      for z in a:
          ufances[z] = y
      return y
  
  
  def ufconn(x, y):
      global ufsz, ufances
      i = ufroot(x)
      j = ufroot(y)
      if i == j:
          return
      # k  = [i,j].min
      k = j if (ufsz[i] < ufsz[j]) else i
      if k == j:
          ufances[i] = j
      else:
          ufances[j] = i
      ufsz[k] = ufsz[i] + ufsz[j]
  
  
  n, m = inm()
  p = inl()
  p[0:0] = [0]
  x = []
  y = []
  for i in range(m):
      xx, yy = inm()
      x.append(xx)
      y.append(yy)
  ufinit(n + 1)
  for i in range(m):
      ufconn(x[i], y[i])
  ga = [0] * (n + 1)
  gb = [0] * (n + 1)
  for i in range(1, n + 1):
      r = ufroot(i)
      ga[i] = gb[p[i]] = r
  sm = 0
  for i in range(1, n + 1):
      if ga[i] == gb[i]:
          sm += 1
  print(sm)
  
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."}]