#pragma GCC optimize("O3")

#include <bits/extc++.h>

#define int long long

using namespace std;

struct fenwick {
    vector<int> t;
    int n;
    void init(int nn) {
        n = nn;
        t.assign(n, 0);
    }
    void upd(int i, int x) {
        while (i < n) {
            t[i] += x;
            i |= i + 1;
        }
    }
    int get(int i) {
        int s = 0;
        while (i >= 0) {
            s += t[i];
            --(i &= i + 1);
        }
        return s;
    }
    int get(int i, int j) {
        return get(j) - get(i - 1);
    }
};

struct sgt {
    vector<int> t, lazy;
    void init(int n) {
        t.assign(n << 2, 0);
        lazy.assign(n << 2, 0);
    }
    void push(int v, int tl, int tr) {
        if (lazy[v] == 0) {
            return;
        }
        t[v] += lazy[v];
        if (tl + 1 < tr) {
            lazy[2 * v + 1] += lazy[v];
            lazy[2 * v + 2] += lazy[v];
        }
        lazy[v] = 0;
    }
    void upd(int v, int tl, int tr, int l, int r, int x) {
        push(v, tl, tr);
        if (tr <= l || r <= tl) {
            return;
        }
        if (l <= tl && tr <= r) {
            lazy[v] = x;
            push(v, tl, tr);
            return;
        }
        int tm = (tl + tr) >> 1;
        upd(2 * v + 1, tl, tm, l, r, x);
        upd(2 * v + 2, tm, tr, l, r, x);
        t[v] = max(t[2 * v + 1], t[2 * v + 2]);
    }
    int get(int v, int tl, int tr, int l, int r) {
        push(v, tl, tr);
        if (tr <= l || r <= tl) {
            return -1e9;
        }
        if (l <= tl && tr <= r) {
            return t[v];
        }
        int tm = (tl + tr) >> 1;
        return max(get(2 * v + 1, tl, tm, l, r), get(2 * v + 2, tm, tr, l, r));
    }
};

vector<vector<int>> g;
vector<int> tin, tout, sz, up;
int timer = 0;

void dfs(int v, int p) {
    up[v] = p;
    sz[v] = 1;
    for (int u : g[v]) {
        dfs(u, v);
        sz[v] += sz[u];
    }
}

vector<int> head;

void dfs2(int v) {
    tin[v] = timer++;
    for (int u : g[v]) {
        if (u == g[v][0]) {
            head[u] = head[v];
        } else {
            head[u] = u;
        }
        dfs2(u);
    }
    tout[v] = timer;
}

constexpr int INF = 1e9;

vector<int> ans;
sgt t;
fenwick zz;
int TT = -1, n;

void upd(int v, int x) {
    while (true) {
        int u = head[v];
        t.upd(0, 0, n, tin[u], tin[v] + 1, x);
        if (u == 0) {
            return;
        }
        v = up[u];
    }
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    int q;
    cin >> n >> q;
    g.resize(n);
    tin.resize(n);
    tout.resize(n);
    up.resize(n);
    sz.resize(n);
    head.resize(n);
    vector<int> p(n), h(n);
    for (int i = 1; i < n; i++) {
        cin >> p[i], p[i]--;
    }
    vector<int> s(n);
    for (int i = 0; i < n; i++) {
        cin >> s[i];
    }
    for (int i = 1; i < n; i++) {
        h[i] = h[p[i]] + 1;
        g[p[i]].push_back(i);
    }
    dfs(0, 0);
    for (int i = 0; i < n; i++) {
        sort(g[i].begin(), g[i].end(), [&](int a, int b) {
            return sz[a] > sz[b];
        });
    }

    dfs2(0);
    ans.resize(n);
    vector<int> ask(n);
    vector<int> qs(q);
    for (int i = 0; i < q; i++) {
        cin >> qs[i], qs[i]--;
        ask[qs[i]] = 1;
    }
    t.init(n);
    zz.init(n);

    set<pair<int, int>> lol;
    for (int u : g[0]) {
        lol.emplace(s[u], u);
    }
    TT = 0;
    while (!lol.empty()) {
//        cerr << "!!!!\n";
        TT++;
        auto [_, v] = *lol.rbegin();
        lol.erase(--lol.end());
        upd(v, -INF);
        ans[v] = TT - t.get(0, 0, n, 0, n);
        ans[v] = min(ans[v], TT);
        upd(v, INF + 1);
        //t.upd(0, 0, n, tin[v], tin[v] + 1, zz.get(tin[v], tout[v] - 1));
        for (int u : g[v]) {
            lol.emplace(s[u], u);
        }
    }

//    while (!lol.empty()) {
//        auto [_, v] = *lol.rbegin();
//        lol.erase(--lol.end());
//        T++;
//        f.upd(tin[v], 1);
//        if (ask[v]) {
//            ans[v] = T;
//            int u = v;
//            while (u != 0) {
//                for (int b : g[p[u]]) {
//                    if (b != u) {
//                        ans[v] = min(ans[v], T - f.get(tin[b], tout[b] - 1));
//                    }
//                }
//                u = p[u];
//            }
//        }
//        for (int u : g[v]) {
//            lol.emplace(s[u], u);
//        }
//    }
    ans[0] = 0;
    for (int v : qs) {
        cout << ans[v] << ' ';
    }
    return 0;
}
/*

5 4
1 2 2 1
3 5 1 2 4
5 3 1 4

 */