#include <stdio.h>
#include <iostream>
#include <cstdio>
#include <algorithm> 
#include <stdio.h>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <list>
#include <utility>
#include <set>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
#include <bitset>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <random>

using namespace std;

static const double EPS = 1e-9;
template<class T> bool INRANGE(T x, T a, T b) { return a <= x && x <= b; }
template<class T> void amin(T &a, T v) { if (a > v) a = v; }
template<class T> void amax(T &a, T v) { if (a < v) a = v; }
int ROUND(double x) { return (int)(x + 0.5); }
bool ISINT(double x) { return fabs(ROUND(x) - x) <= EPS; }
bool ISEQUAL(double x, double y) { return fabs(x - y) <= EPS * max(1.0, max(fabs(x), fabs(y))); }
double SQSUM(double x, double y) { return x * x + y * y; }
template<class T>
vector<T> make_vector(int n, T t) {
	return vector<T>(n, t);
}
 
template<class ...Ts>
auto make_vector(int n, Ts ... ts) {
	return vector<decltype(make_vector(ts...))>(n, make_vector(ts...));
}

#define PI  (acos(-1))
#define ARRAY_NUM(a) (sizeof(a)/sizeof(a[0])) 
#define NG (-1)
#define BIG ((int)1e9+10)
#define BIGLL ((ll)4e18)
#define SZ(a) ((int)(a).size())
#define SQ(a) ((a)*(a))
#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define ALL(x) (x).begin(),(x).end()
#define YES(n) cout << ((n) ? "YES" : "NO"  ) << endl
#define Yes(n) cout << ((n) ? "Yes" : "No"  ) << endl
#define POSSIBLE(n) cout << ((n) ? "POSSIBLE" : "IMPOSSIBLE"  ) << endl
#define Possible(n) cout << ((n) ? "Possible" : "Impossible"  ) << endl

#define BitSet(arg,posn) ((arg) |= (1LL << (posn)))
#define BitClr(arg,posn) ((arg) &= ~(1LL << (posn)))
#define BitFlp(arg,posn) ((arg) ^= (1LL << (posn)))
#define IsBit(arg,posn) static_cast<bool>((arg) & (1LL << (posn)))

// #define DEBUG(x) cerr<<#x<<": "<<(x)<<endl
// #define DEBUG_VEC(v) cerr<<#v<<": ";REP(__i,(v).size())cerr<<((v)[__i])<<", ";cerr<<endl

typedef unsigned long long ull;
typedef long long ll;

struct in {
	int n;
	in() {}
	in(int n_) : n(n_) {};
	template <class T> operator T() {
		T ret;
		cin >> ret;
		return ret;
	}
	template <class T> operator vector<T>() {
		vector<T> ret(n);
		for (int i = 0; i < n; i++) cin >> ret[i];
		return ret;
	}
};

// modint: mod 計算を int を扱うように扱える構造体
template<int MOD>
struct ModInt {
	long long val;
	constexpr ModInt(long long v = 0) noexcept : val(v % MOD) {
		if (val < 0) v += MOD;
	}
	constexpr int getmod() { return MOD; }
	constexpr ModInt operator - () const noexcept {
		return val ? MOD - val : 0;
	}
	constexpr ModInt operator + (const ModInt& r) const noexcept { return ModInt(*this) += r; }
	constexpr ModInt operator - (const ModInt& r) const noexcept { return ModInt(*this) -= r; }
	constexpr ModInt operator * (const ModInt& r) const noexcept { return ModInt(*this) *= r; }
	constexpr ModInt operator / (const ModInt& r) const noexcept { return ModInt(*this) /= r; }
	constexpr ModInt& operator += (const ModInt& r) noexcept {
		val += r.val;
		if (val >= MOD) val -= MOD;
		return *this;
	}
	constexpr ModInt& operator -= (const ModInt& r) noexcept {
		val -= r.val;
		if (val < 0) val += MOD;
		return *this;
	}
	constexpr ModInt& operator *= (const ModInt& r) noexcept {
		val = val * r.val % MOD;
		return *this;
	}
	constexpr ModInt& operator /= (const ModInt& r) noexcept {
		long long a = r.val, b = MOD, u = 1, v = 0;
		while (b) {
			long long t = a / b;
			a -= t * b; swap(a, b);
			u -= t * v; swap(u, v);
		}
		val = val * u % MOD;
		if (val < 0) val += MOD;
		return *this;
	}
	constexpr bool operator == (const ModInt& r) const noexcept {
		return this->val == r.val;
	}
	constexpr bool operator != (const ModInt& r) const noexcept {
		return this->val != r.val;
	}

	friend ostream& operator << (ostream &os, const ModInt<MOD>& x) noexcept {
		return os << x.val;
	}
	friend istream& operator >> (istream &is, ModInt<MOD>& x) noexcept {
		return is >> x.val;
	}
	friend constexpr ModInt<MOD> modpow(const ModInt<MOD> &a, long long n) noexcept {
		if (n == 0) return 1;
		auto t = modpow(a, n / 2);
		t = t * t;
		if (n & 1) t = t * a;
		return t;
	}
};

// 二項係数ライブラリ
template<class T> struct BiCoef
{
	constexpr BiCoef() {}
	constexpr BiCoef(int n) noexcept : mFact(n, 1), mInv(n, 1), mFInv(n, 1)
	{
		Init(n);
	}

	constexpr void Init(int n) noexcept
	{
		mFact.assign(n, 1), mInv.assign(n, 1), mFInv.assign(n, 1);
		int factMod = mFact[0].getmod();
		for (int i = 2; i < n; i++) {
			mFact[i] = mFact[i - 1] * i;
			mInv[i] = -mInv[factMod%i] * (factMod / i);
			mFInv[i] = mFInv[i - 1] * mInv[i];
		}
	}

	constexpr T Fact(int n) const noexcept {
		if (n < 0) return 0;
		return mFact[n];
	}

	constexpr T Comb(int n, int k) const noexcept {
		if (n < k || n < 0 || k < 0) return 0;
		return mFact[n] * mFInv[k] * mFInv[n - k];
	}

	constexpr T Perm(int n, int k) const noexcept {
		if (n < k || n < 0 || k < 0) return 0;
		return mFact[n] * mFInv[k] * mFInv[n - k];
	}

	constexpr T Homo(int n, int r) const {
		if (n < 0 || r < 0) return 0;
		return r == 0 ? 1 : Comb(n + r - 1, r);
	}

	constexpr T inv(int n) const noexcept {
		if (n < 0) return 0;
		return mInv[n];
	}

	constexpr T finv(int n) const noexcept {
		if (n < 0) return 0;
		return mFInv[n];
	}

	vector<T> mFact;
	vector<T> mInv;
	vector<T> mFInv;
};

const int MOD = 1000000007;
using mint = ModInt<MOD>;
// BiCoef<mint> bc(1234567); // 1M * 3 * 8B(ll) = 24MB 

class UnionFind
{
public:
	UnionFind(int sz)
	{
		data.assign(sz, -1);
	}

	bool same(int x, int y)
	{
		x = find(x);
		y = find(y);

		return x != y;
	}

	bool unite(int x, int y)
	{
		x = find(x);
		y = find(y);

		if (x == y) return false;
		if (data[x] > data[y]) swap(x, y);
		data[x] += data[y];
		data[y] = x;

		return true;
	}

	vector <int> allBoss()
	{
		vector <int> ret(SZ(data));

		for (int i = 0; i < SZ(data); ++i)
		{
			ret[i] = find(i);
		}

		return ret;
	}


	int size(int k)
	{
		return(-data[find(k)]);
	}

private:

	int find(int k)
	{
		if (data[k] < 0) return(k);
		return(data[k] = find(data[k]));
	}

	// データが負のときは、所属集合のサイズ
	// データが0か正のときは、所属集合の代表ノード
	vector< int > data;

};

vector <int> intersection(const vector <int>& sorted_a, const vector <int>& sorted_b)
{
	vector <int> v(SZ(sorted_a) + SZ(sorted_b));
	vector<int>::iterator it = set_intersection(sorted_a.begin(), sorted_a.end(), sorted_b.begin(), sorted_b.end(), v.begin());
	vector<int> ret(v.begin(), it);
	return ret;
}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(nullptr);

	int N, M;
	cin >> N >> M;


	UnionFind uni(N);

	vector <int> p = in(N);
	for (int i = 0; i < SZ(p); ++i)
	{
		p[i]--;
	}

	for (int i = 0; i < M; ++i)
	{
		int x, y;
		cin >> x >> y;
		x--;
		y--;

		uni.unite(x, y);
	}

	vector <int> boss = uni.allBoss();

	map <int, vector <int> > mp;
	for (int i = 0; i < N; ++i)
	{
		mp[boss[i]].push_back(i);
	}

	int ret = 0;
	for (auto s : mp)
	{
		vector <int> perm;
		for (auto i : s.second)
		{
			perm.push_back(p[i]);
		}

		sort(ALL(perm));
		vector <int> x = intersection(perm, s.second);
		ret += SZ(x);
	}

	cout << ret << endl;











/*
	int N, T;
	cin >> N >> T;

	vector <int> a = in(N);


	vector <int> hi(N+1);
	vector <int> numHi(N + 1);

	for (int i=N-1;i>=0;i--)
	{
		if (a[i] > hi[i + 1])
		{
			hi[i] = a[i];
			numHi[i] = 1;
		}
		else if (a[i] == hi[i + 1])
		{
			hi[i] = hi[i + 1];
			numHi[i] = numHi[i+1] + 1;
		}
		else
		{
			hi[i] = hi[i + 1];
			numHi[i] = numHi[i + 1];
		}
	}



	int lo = BIG;
	int numLo = 0;

	int diff = -BIG;
	int numDiff = 0;

	REP(i,N)
	{
		if (lo > a[i])
		{
			lo = a[i];
			numLo = 1;
		}
		else if (lo == a[i])
		{
			numLo++;
		}

		int d = hi[i+1] - lo;

		if (d > diff)
		{
			diff = d;
			numDiff = min(numLo, numHi[i+1]);
		}
		else if (d == diff)
		{
			amax(numDiff, min(numLo, numHi[i + 1]));
		}
	}

	cout << min(T, numDiff) << endl;

	*/


	return 0;
}


Measured memory_bytes: 12544