//Слава Україні, Героям слава

#include <bits/stdc++.h>

using namespace std;

template <class T = int>
class Dinic {
public:
    struct Edge {
        Edge(int a, T b) { to = a;cap = b; }
        int to;
        T cap;
    };

    Dinic(int _n) : n(_n) {
        edges.resize(n);
    }

    T maxFlow(int src, int sink) {
        T ans = 0;
        while (bfs(src, sink)) {
            // maybe random shuffle edges against bad cases?
            T flow;
            pt = std::vector<int>(n, 0);
            while ((flow = dfs(src, sink))) {
                ans += flow;
            }
        }
        return ans;
    }

    void addEdge(int from, int to, T cap, T other = 0) {
        edges[from].push_back(list.size());
        list.push_back(Edge(to, cap));
        edges[to].push_back(list.size());
        list.push_back(Edge(from, other));
    }

    bool inCut(int u) const { return h[u] < n; }
    int size() const { return n; }
    int find(int s) {
        int st = s;
        bool ok = true;
        while(ok) {
            ok = false;
            for(auto e : edges[s]) {
                if(list[e].to == s + 1 and list[e].cap == 0) {
                    s++;
                    ok = true;
                }
            }
        }
        return s - st;
    }
private:
    int n;
    std::vector<std::vector<int> > edges;
    std::vector<Edge> list;
    std::vector<int> h, pt;

    T dfs(int on, int sink, T flow = 1e9) {
        if (flow == 0) {
            return 0;
        } if (on == sink) {
            return flow;
        }
        for (; pt[on] < (int)edges[on].size(); pt[on]++) {
            int cur = edges[on][pt[on]];
            if (h[on] + 1 != h[list[cur].to]) {
                continue;
            }
            T got = dfs(list[cur].to, sink, std::min(flow, list[cur].cap));
            if (got) {
                list[cur].cap -= got;
                list[cur ^ 1].cap += got;
                return got;
            }
        }
        return 0;
    }

    bool bfs(int src, int sink) {
        h = std::vector<int>(n, n);
        h[src] = 0;
        std::queue<int> q;
        q.push(src);
        while (!q.empty()) {
            int on = q.front();
            q.pop();
            for (auto a : edges[on]) {
                if (list[a].cap == 0) {
                    continue;
                }
                int to = list[a].to;
                if (h[to] > h[on] + 1) {
                    h[to] = h[on] + 1;
                    q.push(to);
                }
            }
        }
        return h[sink] < n;
    }
};

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m;
    cin >> n >> m;
    vector<int> p(n), c(n);
    set<int> s;
    for(int i = 0; i < n; i++) {
        s.insert(i);
    }
    for(int i = 0; i < n; i++) {
        cin >> p[i];
    }
    for(int i = 0; i < n; i++) {
        cin >> c[i];
    }
    int q;
    cin >> q;
    vector<int> qq(q), ans(q);
    for(int i = 0; i < q; i++) {
        cin >> qq[i];
        qq[i]--;
        s.erase(qq[i]);
    }
    int id = 0;
    vector<int> ic(m + 1), in(n + 1), out(n + 1);
    for(int i = 1; i <= m; i++) {
        ic[i] = id++;
    }
    for(int i = 0; i <= n; i++) {
        in[i] = id++;
    }
    for(int i = 0; i <= n; i++) {
        out[i] = id++;
    }
    int src = id++;
    int sink = id++;
    Dinic<int> dinic(sink + 1);
    for(int i = 1; i <= m; i++) {
        dinic.addEdge(src, ic[i], 1);
    }
    for(int i = 0; i < n; i++) {
        dinic.addEdge(out[i], out[i + 1], i + 1);
    }
    for(int i = 0; i <= n; i++) {
        dinic.addEdge(in[i], out[i], 1);
    }
    dinic.addEdge(out[n], sink, n + 1);
    for(auto e : s) {
        dinic.addEdge(ic[c[e]], in[p[e]], 1);
    }
    auto res = dinic;
    int sz = s.size(), curans = 0;
    for(int i = q - 1; i >= 0; i--) {
        while(res.maxFlow(src, out[curans]) == curans) {
            curans++;
        }
        ans[i] = curans;
        dinic.addEdge(ic[c[qq[i]]], in[p[qq[i]]], 1);
        res = dinic;
    }
    for(int i = 0; i < q; i++) {
        cout << ans[i] << "\n";
    }
    return 0;
}