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

// ===================================================================== RAQ & RMQ
struct Node {
    long long val, idx;
};

Node operator+(Node &a1, Node &a2) {
    return Node{a1.val + a2.val, a1.idx + a2.idx};
}

bool operator<(const Node &a1, const Node &a2) {
    if (a1.val < a2.val) return true;
    if (a1.val > a2.val) return false;
    if (a1.idx < a2.idx) return true;
    return false;
}

class SegmentTree {
public:
    int size_ = 1;
    vector<Node> dat;
    vector<Node> laz;

    void init(int sz) {
        while (size_ <= sz) size_ *= 2;
        dat.resize(size_ * 2, Node{(1LL << 60), 0LL});
        laz.resize(size_ * 2, Node{0LL, 0LL});
    }

    void refresh(int pos) {
        if (pos < size_) {
            laz[pos * 2 + 0] = laz[pos * 2 + 0] + laz[pos];
            laz[pos * 2 + 1] = laz[pos * 2 + 1] + laz[pos];
            laz[pos] = Node{0LL, 0LL};
            dat[pos] = min(dat[pos * 2 + 0] + laz[pos * 2 + 0], dat[pos * 2 + 1] + laz[pos * 2 + 1]);
        }
        else {
            dat[pos] = dat[pos] + laz[pos];
            laz[pos] = Node{0LL, 0LL};
        }
    }

    void add_(int l, int r, Node x, int a, int b, int u) {
        if (l <= a && b <= r) { laz[u] = laz[u] + x; return; }
        if (r <= a || b <= l) return;
        add_(l, r, x, a, (a + b) / 2, u * 2);
        add_(l, r, x, (a + b) / 2, b, u * 2 + 1);
        refresh(u);
    }

    void add(int l, int r, Node x) {
        add_(l, r, x, 0, size_, 1);
    }

    Node query_(int l, int r, int a, int b, int u) {
        if (l <= a && b <= r) return dat[u] + laz[u];
        if (r <= a || b <= l) return Node{(1LL << 60), -1LL};
        refresh(u);
        Node v1 = query_(l, r, a, (a + b) / 2, u * 2);
        Node v2 = query_(l, r, (a + b) / 2, b, u * 2 + 1);
        refresh(u);
        return min(v1, v2);
    }

    Node query(int l, int r) {
        return query_(l, r, 0, size_, 1);
    }
};


// ===================================================================== Main Part
long long N;
long long P[500009];
long long F[500009];
long long Count[500009];
set<int> G[500009];

// HLD Part
long long dp[500009];
long long Max_[500009];
long long Root[500009];
long long Indx[500009];
SegmentTree Z[500009];
SegmentTree All;
vector<int> Temp;

void Initialize() {
    for (int i = 0; i <= 200; i++) P[i] = 0;
    for (int i = 0; i <= 200; i++) F[i] = 0;
    for (int i = 0; i <= 200; i++) Count[i] = 0;
    for (int i = 0; i <= 200; i++) G[i].clear();
    for (int i = 0; i <= 200; i++) dp[i] = 0;
    for (int i = 0; i <= 200; i++) Max_[i] = 0;
    for (int i = 0; i <= 200; i++) Root[i] = 0;
    for (int i = 0; i <= 200; i++) Indx[i] = 0;
    for (int i = 0; i <= 200; i++) {
        Z[i].size_ = 1;
        Z[i].dat.clear();
        Z[i].laz.clear();
    }
    for (int i = 0; i <= 200; i++) {
        All.size_ = 1;
        All.dat.clear();
        All.laz.clear();
    }
    Temp.clear();
}

void dfs1(int pos) {
    dp[pos] = 1;
    for (int idx : G[pos]) {
        dfs1(idx);
        dp[pos] += dp[idx];
    }
}

void dfs2(int pos, int r, int c) {
    Root[pos] = r;
    Indx[pos] = c;
    Max_[r] = max(Max_[r], 1LL * c);
    pair<long long, int> maxn = make_pair(-1, -1);
    for (int idx : G[pos]) maxn = max(maxn, make_pair(dp[idx], idx));

    // Recursion
    for (int idx : G[pos]) {
        if (maxn.second == idx) {
            dfs2(idx, r, c + 1);
        }
        else {
            dfs2(idx, idx, 1);
        }
    }
}

void Delete(int pos) {
    All.add(pos, pos + 1, Node{(1LL << 60), 0});
    Z[Root[pos]].add(Indx[pos], Indx[pos] + 1, Node{(1LL << 60), 0});
    Temp.push_back(pos);
    for (int idx : G[pos]) Delete(idx);
}

void Search(int pos) {
    while (true) {
        Z[Root[pos]].add(1, Indx[pos] + 1, Node{-1LL, 0LL});
        while (true) {
            Node minv = Z[Root[pos]].query(0, Z[Root[pos]].size_);
            if (minv.val <= 0) {
                Temp.clear();
                Delete(minv.idx);
                for (int idx : Temp) {
                    if (idx != 1) G[P[idx]].erase(idx);
                }
            }
            else break;
        }
        if (Root[pos] == 1) break;
        pos = P[Root[pos]];
    }
}

// ============================================================================= Output Function
long long Solve_Outp() {
    for (int i = 2; i <= N; i++) G[P[i]].insert(i);

    // Step 2. Initialize
    dfs1(1);
    dfs2(1, 1, 1);
    All.init(N + 2);
    for (int i = 1; i <= N; i++) Z[i].init(Max_[i]);
    for (int i = 1; i <= N; i++) Z[Root[i]].add(Indx[i], Indx[i] + 1, Node{dp[i] - (1LL << 60), 1LL * i});
    for (int i = 1; i <= N; i++) {
        All.add(i, i + 1, Node{F[i] - (1LL << 60), 1LL * i});
    }

    // Step 3. Simulation
    long long Answer = 0;
    for (int loops = 1; loops <= N; loops++) {
        Node incr = All.query(0, All.size_);
        Answer += incr.val;
        Count[incr.idx] += 1;
        All.add(incr.idx, incr.idx + 1, Node{2LL * F[incr.idx], 0LL});
        Search(incr.idx);
    }
    return Answer;
}


// ============================================================================= Output Function
long long dfs4(int pos, vector<long long> c) {
    if (pos == N + 1) {
        long long sum = 0;
        for (int i = 1; i <= N; i++) sum += F[i] * c[i] * c[i];
        return sum;
    }
    int cx = pos; long long ret = (1LL << 60);
    while (true) {
        vector<long long> r = c;
        r[cx] += 1;
        ret = min(ret, dfs4(pos + 1, r));
        if (cx == 1) break;
        cx = P[cx];
    }
    return ret;
}

long long Solve_Jury() {
    return dfs4(1, vector<long long>(N + 1, 0));
}


int main() {
    int DEBUG = 1;
    if (DEBUG == 1) {
        scanf("%lld", &N);
        for (int i = 2; i <= N; i++) scanf("%lld", &P[i]);
        for (int i = 1; i <= N; i++) scanf("%lld", &F[i]);
        cout << Solve_Outp() << endl;
    }
    else {
        for (int t = 1; t <= 100000; t++) {
            Initialize();
            N = rand() % 7 + 2;
            for (int i = 2; i <= N; i++) P[i] = rand() % (i - 1) + 1;
            for (int i = 1; i <= N; i++) F[i] = rand() % 9 + 1;

            // Check
            long long J1 = Solve_Jury();
            long long J2 = Solve_Outp();
            if (t % 1 == 0) cout << t << " " << J1 << " " << J2 << endl;
            if (J1 != J2) {
                cout << "Wrong Answer on Test #" << t << endl;
                cout << "Jury = " << J1 << ", Output = " << J2 << endl;
                cout << N << endl;
                for (int i = 2; i <= N; i++) cout << P[i] << " "; cout << endl;
                for (int i = 1; i <= N; i++) cout << F[i] << " "; cout << endl;
                return 0;
            }
        }
        cout << "AC" << endl;
    }
    return 0;
}