#include <bits/stdc++.h>
using namespace std;
#define ll long long

struct node {
    int mx;
    int id;
};

struct tree {
    int n;
    vector<node> t;

    tree(int N) : n(N) {
        t.resize(4 * n, {-10000000, 0});
    }
    node merge(node a, node b) {
        if (a.mx > b.mx) return a;
        return b;
    }
    void upd(int v, int l, int r, int pos, int x) {
        if (r - l == 1) {
            t[v] = {x, l};
            return;
        }
        int m = ((r + l)>>1);
        if (pos < m) upd(2 * v + 1, l, m, pos, x);
        else upd(2 * v + 2, m, r, pos, x);
        t[v] = merge(t[2 * v + 1], t[2 * v + 2]);
    }
    node get_ans(int v, int l, int r, int ql, int qr) {
        if (ql <= l && r <= qr) {
            return t[v];
        }
        if (r <= ql || qr <= l) {
            return {-10000000, 0};
        }
        int m = ((r + l)>>1);
        return merge(get_ans(2 * v + 1, l, m, ql, qr), get_ans(2 * v + 2, m, r, ql, qr));
    }
};




void solve() {
    int n, q; cin >> n >> q;
    int k = 0;
    vector<int> b, nac;

    for (int i = 1; i < n; ++i) {
        int x; cin >> x;
        if (x == 1) {
            k++;
            b.push_back(i);
            nac.push_back(i);
        }
    }
    vector<int> c(n);
    vector<pair<int, int>> Q(n, {0,-1});
    vector<int> ans(n);
    for (int i = 0; i < n; ++i) cin >> c[i];

    if (k == 1) {
        while (q--) {
            int x; cin >> x;
            cout << x-1 << '\n';
        }
        return;
    }
    tree tr(k);
    for (int i = 0; i < k; ++i) {
        tr.upd(0, 0, k, i, c[b[i]]);
    }
    for (int i = 1; i < n; ++i) {
        node r = tr.get_ans(0, 0, k, 0, k);
        //cout << r.id << ' ' << b[r.id] << '\n';
        Q[i] = {b[r.id], r.id};
        b[r.id] ++;
        if ((r.id < k-1 && b[r.id] == nac[r.id + 1]) || b[r.id] == n) {
            tr.upd(0, 0, k, r.id, 0);
        } else {
            tr.upd(0, 0, k, r.id, c[b[r.id]]);
        }
        //cout << r.mx << ' ' << r.id << '\n';
    }
    map<int, int> mp;
    pair<int, int> mx1= {0, 0}, mx2 = {0,0};
    for (int i = 1; i < n; ++i) {
        auto [u, v] = Q[i];
        mp[v] ++;
        if (mx1.second == v) {
            mx1.first++;
        } else {
            if (mp[v] > mx2.first) {
                mx2 = {mp[v], v};
            }
            if (mx2.first > mx1.first) {
                swap(mx2, mx1);
            }
        }
        if (mx1.second != v) {
            ans[u] = i - mx1.first;
        } else {
            ans[u] = i - mx2.first;
        }
    }

    while (q--) {
        int x; cin >> x;
        cout << ans[x-1] << '\n';
    }
}

int main()
{

    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int ttt = 1;
    //cin >> ttt;
    while (ttt--) {
        solve();
    }
}




//#include <bits/stdc++.h>
//using namespace std;
//#define ll long long
//#define ld long double
//mt19937 rnd(82739121);
//
//
//struct treap {
//    ll x, y = rnd();
//    treap* l, r;
//    treap(ll x) : x(x) {
//    };
//};
//
//treap* merge(treap* a, treap* b) {
//    if (!a) return b;
//    if (!b) return a;
//    if (a->y > b->y) {
//        a->r = merge(a->r, b);
//        return a;
//    } else {
//        b->l = merge(a, b->l);
//        return b;
//    }
//}
//
//pair<treap*, treap*> split(treap* t, ll k) {
//    if (!t) return {0, 0};
//    if (t->x > k) {
//        auto q = split(t->l, k);
//        t->l = q.second;
//        return {q.first, t};
//    } else {
//        auto q = split(t->r, k);
//        t->r = q.first;
//        return {t, q.second};
//    }
//}
//
//pair<treap*, treap*> splitk(treap* t, ll k) {
//    if (!t) return {0, 0};
//    if (cnt(t->l) >= k) {
//        auto q = splitk(t->l, k);
//        t->l = q.second;
//        return {q.first, t};
//    } else {
//        auto q = splitk(t->r, k - cnt(t->l) - 1);
//        t->r = q.first;
//        return {t, q.second};
//    }
//}
//
//bool search(treap* t, ll x) {
//    auto t1 = split(t, x);
//    auto t2 = split(t1.second, x+1);
//    bool res = t2.first;
//    t = merge(t1.first, merge(t2.first, t2.second));
//    return res;
//}
//
//treap* add(treap* t, ll x) {
//    if (search(t, x)) {
//        return t;
//    }
//    treap *nx = new treap(x);
//    auto q = split(t, x);
//    return merge(q.first, merge(nx, q.second));
//}
//
//void erase(treap* t, ll x) {
//    auto q = split(t, x);
//    auto q1 = split(q.second, x+1);
//    t = merge(q.first, q1.second);
//}
//
//struct tree {
//    int n;
//    vector<node> t;
//    tree(int N, vector<ll> &a) : n(N) {
//        t.resize(4*n);
//        build(0, 0, n, a);
//    }
//    node merge(node a, node b) {
//        ...
//    }
//    void build(int v, int l, int r, vector<ll> &a) {
//        if (r - l == 1) {
//            t[v] = {};
//            return;
//        }
//        int m = ((r + l)>>1);
//        build(2 * v + 1, l, m, a);
//        build(2 * v + 2, m, r, a);
//        t[v] = merge(t[2 * v + 1], t[2 * v + 2]);
//    }
//    void push(int v, int l, int r) {
//        if (t[v] != 0 && r - l > 1) {
//            ll p = t[v].p;
//            t[2 * v + 1].val += p;
//            t[2 * v + 1].p += p;
//            t[2 * v + 2].val += p;
//            t[2 * v + 2].p += p;
//        }
//        t[v].p = 0;
//    }
//    void update(int v, int l, int r, int ql, int qr, ll x) {
//        if (ql <= l && r <= qr) {
//            t[v] = {};
//            return;
//        }
//        if (r <= ql || qr <= l) {
//            return;
//        }
//        push(v, l, r);
//        int m = ((r + l)>>1);
//        update(2 * v + 1, l, m, ql, qr, x);
//        update(2 * v + 2, m, r, ql, qr, x);
//        t[v] = merge(t[2 * v + 1], t[2 * v + 2]);
//    }
//    void upd(int v, int l, int r, int pos, ll x) {
//        if (r - l == 1) {
//            t[v] = {};
//            return;
//        }
//        int m = ((r + l)>>1);
//        if (pos < m) upd(2 * v + 1, l, m, pos, x);
//        else upd(2 * v + 2, m, r, pos, x);
//        t[v] = merge(t[2 * v + 1], t[2 * v + 2]);
//    }
//    node get_ans(int v, int l, int r, int ql, int qr) {
//        if (ql <= l && r <= qr) {
//            return t[v];
//        }
//        if (r <= ql || qr <= l) {
//            return {};
//        }
//        push(v, l, r);
//        int m = ((r + l)>>1);
//        return merge(get_ans(2 * v + 1, l, m, ql, qr), get_ans(2 * v + 2, m, r, ql, qr));
//    }
//};
//
//struct sparce_table {
//    int n;
//    int LOG = 17;
//    vector<vector<int>> st;
//    sparce_table(int N, vector<int> &a) : n(N) {
//        st.resize(LOG, vector<int> (n));
//        build(a);
//    }
//    void build(vector<int> &a) {
//        for (int i = 0; i < n; ++i) st[0][i] = a[i];
//
//        for (int i = 1; i < LOG; ++i) {
//            for (int j = 0; j <= n - (1 << i); ++j) {
//                st[i][j] = min(st[i-1][j], st[i-1][j + (1 << (i-1))]);
//            }
//        }
//    }
//
//    int get_ans(int l, int r) {
//        l--; r--;
//        int lg = find_log(r - l + 1);
//        return min(st[lg][l], st[lg][r - (1 << lg) + 1]);
//    }
//};




//#include <bits/stdc++.h>
//using namespace std;
//#define ll long long
//#define ld long double
//
//int N, n, M, m, k, q;
//ll mod = 1000000007;
//ll p = 1601;
//vector<ll> P;
//
//ll get_hash(int l, int r, vector<ll> &h) {
//    ll ans = h[r] - (h[l] * P[r - l]) % mod;
//    if (ans < 0) ans += mod;
//    return ans;
//}
//
//void solve() {
//    cin >> N >> n >> M >> m >> k >> q;
//    vector<ll> a, b;
//    P.resize(max(N, M) + 1, 1);
//    for (int i = 1; i <= max(N, M); ++i) {
//        P[i] = (P[i-1] * p) % mod;
//    }
//
//    for (int i = 0; i < n; ++i) {
//        int l, v; cin >> l >> v;
//        for (int j = 0; j < l; ++j) {
//            a.push_back(v);
//        }
//    }
//    vector<ll> ha(N + 1);
//    for (int i = 1; i <= N; ++i) {
//        ha[i] = (ha[i-1] * p) % mod + (a[i-1]);
//        if (ha[i] >= mod) ha[i]-=mod;
//    }
//
//    for (int i = 0; i < m; ++i) {
//        int l, v; cin >> l >> v;
//        for (int j = 0; j < l; ++j) {
//            b.push_back(v);
//        }
//    }
//    vector<ll> hb(M + 1);
//    for (int i = 1; i <= M; ++i) {
//        hb[i] = (hb[i-1] * p)%mod + (b[i-1]);
//        if (hb[i] >= mod) hb[i]-=mod;
//    }
//
//    while (q--) {
//        int x1, x2; cin >> x1 >> x2;
//        int l = 0, r = min(N - x1, M - x2) + 1, mid;
//        while (r - l > 1) {
//            mid = ((r + l)>>1);
//            if (get_hash(x1, x1 + mid, ha) == get_hash(x2, x2 + mid, hb)) l = mid;
//            else r = mid;
//        }
//        cout << l << '\n';
//        if (l % 2 == 1) cout << "Yes\n";
//        else cout << "No\n";
//    }
//}
//
//int main()
//{
//
//    ios_base::sync_with_stdio(false);
//    cin.tie(0);
//    cout.tie(0);
//
//    int ttt = 1;
//    //cin >> ttt;
//    while (ttt--) {
//        solve();
//    }
//}
