#include <iostream> // cout, endl, cin
#include <string> // string, to_string, stoi
#include <vector> // vector
#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <utility> // pair, make_pair
#include <tuple> // tuple, make_tuple
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <deque> // deque
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cmath>
#include <limits>
#include <list>
#include <cassert>
#include <iterator>
#define ALL(x) (x).begin(),(x).end()
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define int_INF 2147483647
#define pint_INF 2000000000
#define ll_INF 	9223372036854775807
#define MOD 1000000007
#define vi vector<int>
#define vvi vector<vector<int>>
#define vvll vector<vector<long long>>
#define vvc vector<vector<char>>
#define vll vector<long long>
#define pii pair<int,int>
#define vpii vector<pair<int,int>>
#define sysp system("PAUSE")
#define pno cout << "no" << endl
#define pyes cout << "yes" << endl
#define pYes cout << "Yes" << endl
#define pNo cout << "No" << endl
#define pNO cout << "NO" << endl
#define pYES cout << "YES" << endl
#define endl "\n"
#define pi 3.14159265358979
using namespace std;
using ll = long long;

class UnionFind {
protected:
    vector<vector<int>> Graph;// {ID,Value,ParentID,Height}
    vector<bool> isClosed;
public:
    void push(int x) {
        int i = Graph.size();
        Graph.push_back({ i,x,i,1 });
        isClosed.push_back(false);
    }
    void unite(int x, int y) {
        if (root(x) == root(y)) {
            isClosed[root(x)] = true;
            isClosed[root(y)] = true;
        }
        int hx = Graph[root(x)][3];
        int hy = Graph[root(y)][3];
        if (hx < hy) {
            Graph[root(x)][2] = root(y);
            flatten(x, root(y));
        }
        else if (hx == hy) {
            Graph[root(y)][2] = root(x);
            Graph[root(x)][3]++;
            flatten(y, root(x));
        }
        else {
            Graph[root(y)][2] = root(x);
            flatten(y, root(x));
        }
    }
    bool same(int x, int y) {
        return root(x) == root(y);
    }

    void flatten(int x, int rootid) {
        int parentid = Graph[x][0];
        while (Graph[parentid][0] != Graph[parentid][2]) {
            Graph[parentid][2] = rootid;
            int next = Graph[parentid][2];
            parentid = next;
        }
    }
    int root(int x) {
        int parentid = Graph[x][0];
        while (Graph[parentid][0] != Graph[parentid][2]) {
            int next = Graph[parentid][2];
            parentid = next;
        }

        return parentid;
    }
    int count_groups() {
        int cnt = 0;
        for (int i = 0; i < Graph.size(); i++) {
            if (Graph[i][2] == Graph[i][0]) {
                cnt++;
            }
        }
        return cnt;
    }
    vector<vector<int>> group_indices() {
        vector<vector<int>> groups(Graph.size());
        for (int i = 0; i < Graph.size(); i++) {
            groups[root(i)].push_back(i);
        }
        return groups;
    }
};

int main() {
    int N, M; cin >> N >> M;
    UnionFind uf;
    rep(i, N) uf.push(i);
    vector<int> P(N);
    int ans = 0;
    for (int i = 0; i < N; i++) {
        int p; cin >> p; --p;
        P[i] = p;
    }
    for (int qq = 0; qq < M; qq++) {
        int x, y; cin >> x >> y; --x; --y;
        uf.unite(x, y);
    }
    vvi groups = uf.group_indices();
    for (int g = 0; g < groups.size(); g++) {
        vi tmp = groups[g]; // true indices
        set<int> ideal;
        for (auto& ind : tmp) {
            ideal.insert(ind);
        }
        set<int> given;
        for (auto& ind : tmp) {
            given.insert(P[ind]);
        }
        set<int> intersect;
        set_intersection(ALL(ideal), ALL(given),inserter(intersect,intersect.end()));
        ans += intersect.size();
    }
    cout << ans << endl;
}

Measured memory_bytes: 26024