#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <random>
#include <cstdlib>
#include <cassert>
#include <algorithm>
#include <cmath>
#include <set>
#include <iomanip>
#include <deque>
#include <bitset>
#include <map>

using namespace std;

const int N = 1e5 + 7, MOD = 1e9 + 7;
const int A = 26, C = 2;

int n,m, qr;

mt19937 rnd;
int a[N], ans[N];
vector<int> e[N];

struct Node {
    int sum, x, y;
    Node* l, *r;
    Node(int val) {
        y = rnd();
        x = val;
        l = nullptr;
        r = nullptr;
        sum = 1;
    }
};

void recalc(Node* v) {
    if (v == nullptr) {
        return;
    }
    v->sum = 1;
    if (v->l != nullptr) {
        v->sum += v->l->sum;
    }
    if (v->r != nullptr) {
        v->sum += v->r->sum;
    }
}

pair<Node*, Node*> split(Node* v, int x) {
    if (v == nullptr) {
        return { nullptr, nullptr };
    }
    if (v->x > x) {
        auto res = split(v->l, x);
        v->l = res.second;
        recalc(v->l);
        recalc(v);
        return { res.first, v };
    }
    else {
        auto res = split(v->r, x);
        v->r = res.first;
        recalc(v->r);
        recalc(v);
        return { v, res.second };
    }
}

Node* merge(Node* l, Node* r) {
    if (l == nullptr || r == nullptr) {
        return l == nullptr ? r : l;
    }
    if (l->y > r->y) {
        l->r = merge(l->r, r);
        recalc(l);
        recalc(l->r);
        return l;
    }
    else {
        r->l = merge(l, r->l);
        recalc(r);
        recalc(r->l);
        return r;
    }
}

int sz(Node* v) {
    if (v == nullptr) {
        return 0;
    }
    return v->sum;
}

Node* insert(Node* root, Node* v) {
    auto res = split(root, v->x);
    return merge(merge(res.first, v), res.second);
}

Node* sliv(Node* root, Node* v) {
    if (v == nullptr) {
        return root;
    }
    root = sliv(root, v->l);
    recalc(root);
    root = sliv(root, v->r);
    recalc(root);
    v->l = nullptr;
    v->r = nullptr;
    root = insert(root, v);
    recalc(root);
    return root;
}

Node* Merge(Node* u, Node* v) {
    if (sz(u) < sz(v)) {
        return sliv(v, u);
    }
    else {
        return sliv(u, v);
    }
}

Node* dfs(int v) {
    Node* root = new Node(a[v]);
    for (auto u : e[v]) {
        Node* g = dfs(u);
        root = Merge(g, root);
    }
    if (v == 1) {
        cout << "";
    }
    auto res = split(root, a[v]);
    if (res.second != nullptr)
        ans[v] = res.second->sum;
    return merge(res.first, res.second);
}

signed main() {
#ifdef _DEBUG
   freopen("input.txt", "r", stdin);
#else
    ios::sync_with_stdio(false);
    cin.tie(0);
#endif
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    for (int i = 2; i <= n; i++) {
        int p;
        cin >> p;
        e[p].push_back(i);
    }
    dfs(1);
    for (int i = 1; i <= n; i++) {
        cout << ans[i] << "\n";
    }
}