import sys



read = sys.stdin.buffer.read

readline = sys.stdin.buffer.readline



in_n = lambda: int(readline())

in_nn = lambda: list(map(int, readline().split()))

in_nl = lambda: list(map(int, readline().split()))

in_na = lambda: list(map(int, read().split()))

in_s = lambda: readline().rstrip().decode('utf-8')





class UnionFind():

    def __init__(self, n):

        self.n = n

        self.parents = [-1] * n



    def find(self, x):

        if self.parents[x] < 0:

            return x

        else:

            self.parents[x] = self.find(self.parents[x])

            return self.parents[x]



    def union(self, x, y):

        x = self.find(x)

        y = self.find(y)



        if x == y:

            return



        if self.parents[x] > self.parents[y]:

            x, y = y, x



        self.parents[x] += self.parents[y]

        self.parents[y] = x



    def size(self, x):

        return -self.parents[self.find(x)]



    def same(self, x, y):

        return self.find(x) == self.find(y)



    def members(self, x):

        root = self.find(x)

        return [i for i in range(self.n) if self.find(i) == root]



    def roots(self):

        return [i for i, x in enumerate(self.parents) if x < 0]



    def group_count(self):

        return len(self.roots())



    def all_group_members(self):

        return {r: self.members(r) for r in self.roots()}



    def __str__(self):

        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())





def main():

    N, M = in_nn()

    p = in_nl()



    uni = UnionFind(N)

    for i in range(M):

        x, y = in_nn()

        x, y = x - 1, y - 1

        uni.union(x, y)



    edge = [[] for i in range(N)]

    for i in range(N):

        x = uni.find(i)

        edge[x].append(i)



    ans = 0

    for i in range(N):

        if edge[i]:

            s = set(edge[i])

            for e in edge[i]:

                if p[e] - 1 in s:

                    ans += 1



    print(ans)





if __name__ == '__main__':

    main()

import sys



read = sys.stdin.buffer.read

readline = sys.stdin.buffer.readline



in_n = lambda: int(readline())

in_nn = lambda: list(map(int, readline().split()))

in_nl = lambda: list(map(int, readline().split()))

in_na = lambda: list(map(int, read().split()))

in_s = lambda: readline().rstrip().decode('utf-8')





class UnionFind():

    def __init__(self, n):

        self.n = n

        self.parents = [-1] * n



    def find(self, x):

        if self.parents[x] < 0:

            return x

        else:

            self.parents[x] = self.find(self.parents[x])

            return self.parents[x]



    def union(self, x, y):

        x = self.find(x)

        y = self.find(y)



        if x == y:

            return



        if self.parents[x] > self.parents[y]:

            x, y = y, x



        self.parents[x] += self.parents[y]

        self.parents[y] = x



    def size(self, x):

        return -self.parents[self.find(x)]



    def same(self, x, y):

        return self.find(x) == self.find(y)



    def members(self, x):

        root = self.find(x)

        return [i for i in range(self.n) if self.find(i) == root]



    def roots(self):

        return [i for i, x in enumerate(self.parents) if x < 0]



    def group_count(self):

        return len(self.roots())



    def all_group_members(self):

        ret = dict()

        for i in range(self.n):

            r = self.find(i)

            if r in ret:

                ret[r].append(i)

            else:

                ret[r] = [i]

        return ret



    def __str__(self):

        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())





def main():

    N, M = in_nn()

    p = in_nl()



    uni = UnionFind(N)

    for i in range(M):

        x, y = in_nn()

        x, y = x - 1, y - 1

        uni.union(x, y)



    ans = 0

    for root, group in list(uni.all_group_members().items()):

        s = set(group)

        for g in group:

            if p[g] - 1 in s:

                ans += 1



    print(ans)





if __name__ == '__main__':

    main()

import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_nl = lambda: list(map(int, readline().split()))
in_na = lambda: list(map(int, read().split()))
in_s = lambda: readline().rstrip().decode("utf-8")


class UnionFind:
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return
        if self.parents[x] > self.parents[y]:
            x, y = y, x
        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())


def main():
    N, M = in_nn()
    p = in_nl()
    uni = UnionFind(N)
    for i in range(M):
        x, y = in_nn()
        x, y = x - 1, y - 1
        uni.union(x, y)
    edge = [[] for i in range(N)]
    for i in range(N):
        x = uni.find(i)
        edge[x].append(i)
    ans = 0
    for i in range(N):
        if edge[i]:
            s = set(edge[i])
            for e in edge[i]:
                if p[e] - 1 in s:
                    ans += 1
    print(ans)


if __name__ == "__main__":
    main()

import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_nl = lambda: list(map(int, readline().split()))
in_na = lambda: list(map(int, read().split()))
in_s = lambda: readline().rstrip().decode("utf-8")


class UnionFind:
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return
        if self.parents[x] > self.parents[y]:
            x, y = y, x
        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        ret = dict()
        for i in range(self.n):
            r = self.find(i)
            if r in ret:
                ret[r].append(i)
            else:
                ret[r] = [i]
        return ret

    def __str__(self):
        return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())


def main():
    N, M = in_nn()
    p = in_nl()
    uni = UnionFind(N)
    for i in range(M):
        x, y = in_nn()
        x, y = x - 1, y - 1
        uni.union(x, y)
    ans = 0
    for root, group in list(uni.all_group_members().items()):
        s = set(group)
        for g in group:
            if p[g] - 1 in s:
                ans += 1
    print(ans)


if __name__ == "__main__":
    main()

-        return {r: self.members(r) for r in self.roots()} +        ret = dict() +        for i in range(self.n): +            r = self.find(i) +            if r in ret: +                ret[r].append(i) +            else: +                ret[r] = [i] +        return ret -    edge = [[] for i in range(N)] -    for i in range(N): -        x = uni.find(i) -        edge[x].append(i) -    for i in range(N): -        if edge[i]: -            s = set(edge[i]) -            for e in edge[i]: -                if p[e] - 1 in s: -                    ans += 1 +    for root, group in list(uni.all_group_members().items()): +        s = set(group) +        for g in group: +            if p[g] - 1 in s: +                ans += 1