#include <bits/stdc++.h>

using namespace std;
using ll = long long;
const int N = 3e5 + 5;
array<int, N> p, tin, tout, s, posney;
vector<int> g[N];
vector<int> eyler, ney;
int T = 0;

void dfs1(int v) {
    tin[v] = T++;
    eyler.push_back(v);
    for (auto to: g[v]) {
        dfs1(to);
    }
    tout[v] = T;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, q;
    cin >> n >> q;
    for (int i = 2; i <= n; i++) {
        int x;
        cin >> x;
        p[i] = x;
        g[x].push_back(i);
    }
    dfs1(1);
    for (int i = 1; i <= n; i++) {
        cin >> s[i];
    }
    set<pair<int, int>> st = {{s[1], 1}};
    while (!st.empty()) {
        auto it = prev(st.end());
        auto [val, v] = *it;
        st.erase(it);
        ney.push_back(v);
        for (auto to: g[v]) {
            st.insert({s[to], to});
        }
    }

    vector<int> qr(q), ans(q);
    for (int i = 0; i < ney.size(); i++) {
        posney[ney[i]] = i;
    }
    for (int id = 0; id < q; id++) {
        cin >> qr[id];
        int v = p[qr[id]];
        vector<tuple<int, int, int, int>> quer;
        while (v != 0) {
            for (auto to: g[v]) {
                if (tin[to] <= tin[qr[id]] && tout[to] >= tout[qr[id]])continue;
                quer.emplace_back(tin[to], tout[to]-1, posney[qr[id]], quer.size());
            }
            v = p[v];
        }
        vector<int> qans(quer.size());
        vector<tuple<int, int, int, int>> scamline;
        //          l/r1  type r2 qid
        for (int i = 1; i <= n; i++) {
            scamline.emplace_back(tin[i], 0, posney[i], 1);
        }
        for (auto [l1, r1, r2, qid]: quer) {
            scamline.emplace_back(l1, -1, r2, qid);
            scamline.emplace_back(r1, 1, r2, qid);
        }
        std::sort(scamline.begin(), scamline.end());
        vector<int> t(2 * n + 1);
        auto add = [&](int i, int x) {
            i += n;
            t[i] += x;
            while (i > 1) {
                i >>= 1;
                t[i] = t[i << 1] + t[(i << 1) | 1];
            }
        };
        auto gsum = [&](int r) {
            int l = n;
            r += n;
            int ret = 0;
            while (l < r) {
                if (l & 1) {
                    ret += t[l++];
                }
                if (r & 1)
                    ret += t[--r];
                l >>= 1;
                r >>= 1;
            }
            return ret;
        };
        for (auto [x, type, r2, qid]: scamline) {
            if (type == 0) {
                add(r2, qid);
                continue;
            }
            if (type == 1) {
                qans[qid] += gsum(r2);
            } else {
                qans[qid] -= gsum(r2);
            }
        }
        if (!qans.empty())
            ans[id] = posney[qr[id]] - *std::max_element(qans.begin(), qans.end());
        cout << ans[id] << ' ';
    }

    return 0;
}
/*
1. эйлеров обход
2. обход который в задаче ney
    поддерживаем сет вершин берем макс из сета и добавляем его детей в сет

3. пробуем удалять поддеревья
 для какой-то вершины v
 тогда ответ изменится на 1кол-во вершин одновременно лежащих в поддереве и в обходе до v
    3.1
        кол-во точек в прямоугольнике - это кол-во в прямоугольниуке тоут - тин-1


        5 4
1 2 2 1
3 5 1 2 4
3 1 4 5
 */