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

constexpr int N = 300009, inf = 1e9 + 200309;

vector<int> e[N];

int fa[N], dep[N], sz[N], son[N], top[N], dfn[N], rk[N], cnt;

int a[N];

struct V {
    ll val;
    int id;
} v[N];

bool cmp(V x, V y) {
    if (x.val == y.val) {
        return x.id < y.id;
    }
    return x.val > y.val;
}

vector<int> ans;

struct Node {
    int l, r;
    int add;
    int mn;
} tree[N << 2];

void pushup(int x) { tree[x].mn = min(tree[x << 1].mn, tree[x << 1 | 1].mn); }

void pushdown(int x) {
    if (tree[x].add) {
        tree[x << 1].mn += tree[x].add;
        tree[x << 1 | 1].mn += tree[x].add;
        tree[x << 1].add += tree[x].add;
        tree[x << 1 | 1].add += tree[x].add;
        tree[x].add = 0;
    }
}

void build(int l, int r, int x) {
    tree[x].l = l, tree[x].r = r;
    tree[x].add = 0;
    if (l == r) {
        tree[x].mn = a[rk[l]];
        return;
    }
    int mid = (l + r) >> 1;
    build(l, mid, x << 1);
    build(mid + 1, r, x << 1 | 1);
    pushup(x);
}

void update(int l, int r, int x, int val) {
    if (l <= tree[x].l && r >= tree[x].r) {
        tree[x].mn += val;
        tree[x].add += val;
        return;
    }
    pushdown(x);
    int mid = (tree[x].l + tree[x].r) >> 1;
    if (l <= mid) {
        update(l, r, x << 1, val);
    }
    if (r > mid) {
        update(l, r, x << 1 | 1, val);
    }
    pushup(x);
}

int query(int l, int r, int x) {
    if (l <= tree[x].l && r >= tree[x].r) {
        return tree[x].mn;
    }
    pushdown(x);
    int mid = (tree[x].l + tree[x].r) >> 1;
    int ret = inf;
    if (l <= mid) {
        ret = min(query(l, r, x << 1), ret);
    }
    if (r > mid) {
        ret = min(query(l, r, x << 1 | 1), ret);
    }
    return ret;
}

void dfs1(int x) {
    son[x] = -1;
    sz[x] = 1;
    for (auto it : e[x]) {
        dep[it] = dep[x] + 1;
        dfs1(it);
        sz[x] += sz[it];
        if (son[x] == -1 || sz[it] > sz[son[x]])
            son[x] = it;
    }
}

void dfs2(int x, int t) {
    top[x] = t;
    ++cnt;
    dfn[x] = cnt;
    rk[cnt] = x;
    if (son[x] == -1)
        return;
    dfs2(son[x], t);
    for (auto it : e[x]) {
        if (it != son[x]) {
            dfs2(it, it);
        }
    }
}

int querymn(int x, int y) {
    int ret = inf, fx = top[x], fy = top[y];
    while (fx != fy) {
        if (dep[fx] >= dep[fy]) {
            ret = min(ret, query(dfn[fx], dfn[x], 1)), x = fa[fx];
        } else {
            ret = min(ret, query(dfn[fy], dfn[y], 1)), y = fa[fy];
        }
        fx = top[x];
        fy = top[y];
    }
    if (dfn[x] < dfn[y]) {
        ret = min(ret, query(dfn[x], dfn[y], 1));
    } else {
        ret = min(ret, query(dfn[y], dfn[x], 1));
    }
    return ret;
}

void updatemn(int x, int y) {
    int fx = top[x], fy = top[y];
    while (fx != fy) {
        if (dep[fx] >= dep[fy]) {
            update(dfn[fx], dfn[x], 1, -1), x = fa[fx];
        } else {
            update(dfn[fy], dfn[y], 1, -1), y = fa[fy];
        }
        fx = top[x];
        fy = top[y];
    }
    if (dfn[x] < dfn[y]) {
        update(dfn[x], dfn[y], 1, -1);
    } else {
        update(dfn[y], dfn[x], 1, -1);
    }
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    int n;
    cin >> n;
    fa[1] = 0;
    for (int i = 2; i <= n; ++i) {
        cin >> fa[i];
        e[fa[i]].push_back(i);
    }
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }
    for (int i = 1; i <= n; ++i) {
        cin >> v[i].val;
        v[i].id = i;
    }
    sort(v + 1, v + n + 1, cmp);
    dfs1(1);
    dfs2(1, 1);
    build(1, n, 1);
    ll sum = 0;
    for (int i = 1; i <= n; ++i) {
        if (querymn(1, 1) <= 0)
            break;
        if (querymn(1, v[i].id) > 0) {
            sum += v[i].val;
            ans.push_back(v[i].id);
            updatemn(1, v[i].id);
        }
    }
    cout << sum << '\n';
    cout << ans.size();
    sort(ans.begin(), ans.end());
    for (auto it : ans) {
        cout << " " << it;
    }
    cout << '\n';
    return 0;
}