//include
//------------------------------------------
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>


#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include<queue>
using namespace std;
//conversion
//------------------------------------------
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
//math
//-------------------------------------------
template<class T> inline T sqr(T x) {return x*x;}
//typedef
//------------------------------------------
typedef long long ll;
typedef long long LL;
typedef vector<int> VI;
typedef vector<long long > VLL;
typedef vector<long long > vll;
typedef pair <long long , long long > pll;
//container util
//------------------------------------------
#define ALL(a)  (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define VECMAX(x) *max_element(ALL(x))
#define VECMIN(x) *min_element(ALL(x))
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
//repetition
//------------------------------------------
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)
#define MULTIPLE(i,n,k) for(int i = (k) ; i<(n) ; i+=k+1)//倍数ループ
//constant
//------------------------------------------
const double EPS = 1e-10;
const double PI  = acos(-1.0);
//clear memory
#define CLR(a) memset((a), 0 ,sizeof(a))
//debug
#define dump(x)  cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
#define SIZEOF(x) sizeof(x)/sizeof(x[0])



//----------------search for specific figure--------------------
//--------------------------------------------------------------


pll maxP(vll a , ll size){
    pair <ll , ll> p;
    ll Max = a[0];
    ll place = 0;
    REP(i,size){
        if(a[i] > Max){
            Max = a[i];
            place = i;
        }
    }
    p.first = Max;
    p.second = place;
    return p;
}

pll minP(vll a , ll size){
    pair <ll , ll> p;
    ll min = a[0];
    ll place = 0;
    REP(i,size){
        if(a[i] < min){
            min = a[i];
            place = i;
        }
    }
    p.first = min;
    p.second = place;
    return p;
}

ll sumL(vll a , ll size){
    ll sum = 0;
    REP(i,size){
        sum += a[i];

    }
    return sum;
}

ll counT(VLL a , ll t ){
    sort(a.begin(),a.end());
    return upper_bound(a.begin(),a.end(),t)-lower_bound(a.begin() , a.end() , t);
}

#define COUNT(a,b) counT((a),(b))
#define MAX(x) maxP(x,x.size())
#define MIN(x) minP(x,x.size())
#define SUM(x) sumL(x,x.size())

//-------------------DIVIDE----------------------
// DIV[i][j] は　i の j分割数 j == 0 && i != 0 なら 0  

ll DIV[1000+1][1000+1];
void DIVIDE(ll n ,ll m){
    DIV[0][0]= 1;
    FOR(i,1,n+1){
        DIV[i][0] = 0;
    }
    REP(i,n+1){
        DIV[i][1] = 1;
    }
    FOR(i,1,m+1){
        FOR(t,0,n+1){
            if(DIV[t][i] > 0)continue;
            if(t>=i){
                DIV[t][i]=DIV[t-i][i] + DIV[t][i-1];
            }else{
                DIV[t][i] = DIV[t][i-1];
            }
        }
    }
}


//----UnionFind-----

class UnionFind{
    public:
    VI par;
    UnionFind(LL N):par(N){
        REP(i,N)par[i] = i;
    }
    ~UnionFind(){}
    LL root(LL x){
        if(par[x] ==x)return x;
        else {
            par[x] = root(par[x]);
            return par[x];
        }
    }
    void unite(LL x, LL y){
        LL rx = root(x);
        LL ry = root(y);
        if(rx == ry)return;
        par[rx] = ry;
    }
    bool same(LL x, LL y){
        LL rx = root(x);
        LL ry = root(y);
        return rx == ry;
    }
};


//--------BFS---------

pair<LL , LL >  operator+(pair<LL , LL> &a, pair<LL , LL > &b){
    pair<LL , LL> p;
    p.first = a.first + b.first;
    p.second = a.second + b.second;
    return p;
}
bool operator ==(pair<LL , LL> &a, pair<LL , LL > &b){
    return (a.first == b.first && a.second == b.second);
}
bool is_in_field(int h, int w, const pair<LL , LL> &point)
{
    const int c = point.second;
    const int r = point.first;
    return (0 <= c && c < w) && (0 <= r && r < h); 
}
#include<queue>
LL BFS(vector<vector <char> > &p , LL h , LL w){
    
    pair <LL , LL> c[4];
    c[0].first = 0;
    c[0].second = 1;
    c[1].first = 0;
    c[1].second = -1;
    c[2].first = 1;
    c[2].second = 0;
    c[3].first = -1;
    c[3].second = 0;
    vector< vector<LL> >memo;
    REP(i,h){
        vector <LL> k(w);
        REP(t,w)k[t] =  0;
        memo.push_back(k);
    }
    queue <pair<LL ,LL> >Q;
    pair<LL , LL> s;
    s.first = 0;
    s.second = 0;
    Q.push(s);
    while(Q.empty() == false){
        pair <LL , LL> now = Q.front();
        Q.pop();        

        for(int u = 0; u < 4 ; u++){
            pair<LL , LL > x = c[u];
            pair<LL , LL> next = now + x;
            if(is_in_field(h,w,next)){
                if(p[next.first][next.second] == '.'){

                    if(memo[next.first][next.second] == 0){
                        memo[next.first][next.second] = memo[now.first][now.second] + 1;
                        Q.push(next);
                    }
                }
            }
        }
    }
    if(memo[h-1][w-1] == 0)return -1;
    else return memo[h-1][w-1];
}


//-----------MAIN------------//


int main(){
    LL n,m;
    cin >> n >> m;
    vll p(n+1);
    REP(i,n){
        cin >> p[i];

        p[i]--;

    }
    map<ll , ll> Isgrouped;
    UnionFind U(n);
    REP(i,m){
        ll aaa;
        ll bbb;
        cin >> aaa >> bbb;
        U.unite(aaa-1,bbb-1);
        Isgrouped[aaa-1] = 1;
        Isgrouped[bbb-1] = 1;
    
    }   
    vector<map <ll , ll> >RootGroupe(n+1);
    REP(i,n){
        RootGroupe[U.root(i)][i] = 1;
    }
    ll count = 0;
    REP(i,n){
        if(Isgrouped[p[i]] == 1){
            if(RootGroupe[U.root(p[i])][i] == 1){
                count += 1;
            }
        }else{
            if(p[i] == i)count += 1;
        }
    }


    cout << count;






    
    return 0;

}


Measured memory_bytes: 20096