#include <vector>
#include<iostream>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <fstream>
#include <string>
#include <set>
#include <deque>
#include <queue>
#include <map>
#include <bitset>
#include <random>
#include <cassert>
#include <unordered_map>
#include <unordered_set>
using namespace std;
typedef long long             ll;
typedef unsigned long long     ull;
typedef long double            ld;
#define endl              "\n"
#define all(a)            a.begin(), a.end()
#define allr(a)           a.rbegin(), a.rend()
#define pb                push_back
#define F                 first
#define S             second
const ll inf = 1e18;
struct big_v{
    ll num;
    unordered_map <ll, ll> version;
};
signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    ll t = 1;
    //cin >> t;
    while (t--) {
        ll n, m;
        cin >> n >> m;
        vector<vector<ll>>gr(n);
        vector<ll>v(n);
        for (ll i = 0; i < n; i++) {
            cin >> v[i];
        }
        for (ll i = 0; i < m; i++) {
            ll u, v;
            cin >> u >> v;
            u--, v--;
            gr[u].push_back(v);
            gr[v].push_back(u);
        }
        ll c = 660;
        /*
        auto cmp = [&](ll lht, ll rht) {
            return gr[lht].size() < gr[rht].size();
        };
        for (ll i = 0; i < n; i++) {
            sort(all(gr[i]), cmp);
        }
        auto cmp2 = [&](vector<ll> lht, vector<ll> rht) {
            return lht.size() < rht.size();
        };
        sort(all(gr), cmp2);
        */
        vector<big_v> vertex(n);
        vector<bool>  big_vert(n, false);
        vector<vector<ll>>gr_sqrt(n);
        for (ll i = 0; i < n; i++) {
            if (gr[i].size() >= c) {
                big_vert[i] = true;
                big_v in;
                in.num = i;
                unordered_map<ll, ll> sub;
                in.version = sub;
                vertex[i] = in;
                for (ll& j : gr[i]) {
                    if (gr[j].size() >= c) {
                        gr_sqrt[i].push_back(j);
                    }
                }
            }
        }
        ll ans = 0;
        for (ll i = 0; i < n; i++) {
            for (ll& j : gr[i]) {
                ans += v[i] == v[j];
            }
        }
        ans /= 2;
        for (ll i = 0; i < n; i++) {
            if (big_vert[i]) {
                ll cur_v = vertex[i].num;
                for (ll j = 0; j < gr[cur_v].size(); j++) {
                        vertex[i].version[v[gr[cur_v][j]]]++;
                }
            }
        }
        ll q;
        cin >> q;
        for (ll i = 0; i < q; i++) {
            ll vert, swop;
            cin >> vert >> swop;
            vert--;
            ll last_color = v[vert];
            v[vert] = swop;
            if (big_vert[vert]) {
                ans -= vertex[vert].version[last_color];
                ans += vertex[vert].version[swop];
                for (ll& to : gr_sqrt[vert]) {
                    vertex[to].version[last_color]--;
                    vertex[to].version[swop]++;
                }
            }
            else {
                for (ll& to : gr[vert]) {
                    if (v[to] == last_color) {
                        ans--;
                    }
                    if (v[to] == swop) {
                        ans++;
                    }
                    if (gr[to].size() >= c) {
                        vertex[to].version[last_color]--;
                        vertex[to].version[swop]++;
                    }
                }
            }
            cout << m-ans << endl;
        }
    }
}