#include <bits/stdc++.h>

#ifdef CKISEKI
#define safe cerr<<__PRETTY_FUNCTION__<<" line "<<__LINE__<<" safe\n"
#define debug(a...) qwerty(#a, a)
#define orange(a...) dvorak(#a, a)
using std::cerr;
template <typename ...T>
void qwerty(const char *s, T ...a) {
    cerr << "\e[1;32m(" << s << ") = (";
    int cnt = sizeof...(T);
    (..., (cerr << a << (--cnt ? ", " : ")\e[0m\n")));
}
template <typename Iter>
void dvorak(const char *s, Iter L, Iter R) {
    cerr << "\e[1;32m[ " << s << " ] = [ ";
    for (int f = 0; L != R; ++L)
        cerr << (f++ ? ", " : "") << *L;
    cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) ((void)0)
#define orange(...) ((void)0)
#endif
#define all(v) begin(v),end(v)

using namespace std;

struct L {
    mutable int64_t a, b, p;
    bool operator<(const L &r) const { return a < r.a; }
    bool operator<(int64_t x) const { return p < x; }
};

struct DynamicHull : multiset<L, less<>> {
    static const int64_t kInf = 1e18;
    bool Isect(iterator x, iterator y) {
        auto Div = [](int64_t a, int64_t b) {
            return a / b - ((a ^ b) < 0 && a % b);
        };
        if (y == end()) { x -> p = kInf; return false; }
        if (x->a == y->a) x->p = x->b > y->b ? kInf : -kInf;
        else x->p = Div(y->b - x->b, x->a - y->a);
        return x->p >= y->p;
    }
    void Insert(int64_t a, int64_t b) {
        auto z = insert({ a, b, 0 }), y = z++, x = y;
        while (Isect(y, z)) z = erase(z);
        if (x != begin() && Isect(--x, y)) Isect(x, y = erase(y));
        while ((y = x) != begin() && (--x)->p >= y->p)
            Isect(x, erase(y));
    }
    int64_t Query(int64_t x) {
        auto l = *lower_bound(x);
        return l.a * x + l.b;
    }
};

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    int N;
    cin >> N;
    vector<vector<int>> g(N + 1);
    vector<int> C(N + 1);

    for (int i = 2; i <= N; i++) {
        int P;
        cin >> P;
        g[P].emplace_back(i);
    }

    for (int i = 1; i <= N; i++)
        cin >> C[i];

    if (N == 1) {
        cout << 0 << '\n';
        return 0;
    }

    vector<DynamicHull> cv(N + 1);
    vector<int64_t> tag(N + 1);

    for (int i = 1; i <= N; i++) {
        if (g[i].size() == 0) {
            cv[i].Insert(-C[i], 0);
        }
    }

    vector<int64_t> tmp(N + 1);

    const auto dfs = [&](auto self, int i) -> void {
        debug(i);
        if (g[i].size() == 0) {
            return;
        }

        for (int j: g[i]) {
            self(self, j);
        }
        debug(i, "mid");

        int mxs = -1;
        for (int j: g[i]) {
            if (mxs == -1 || cv[mxs].size() < cv[j].size()) {
                mxs = j;
            }
        }
        debug(mxs);

        int64_t tot = 0;
        for (int j: g[i]) {
            tmp[j] = cv[j].Query(C[i]) + tag[j];
            tot += tmp[j];
        }
        for (int j: g[i]) {
            tag[j] += tot - tmp[j];

            //DynamicHull dn;
            //for (auto [a, b, p]: cv[j]) {
            //    dn.Insert(a, tot-tmp[j]+b);
            //}
            //cv[j] = dn;
        }

        swap(cv[i], cv[mxs]);
        // cv[i] = cv[mxs];
        tag[i] = tag[mxs];
        cv[mxs].clear();

        debug(tag[i]);
        for (int j: g[i]) {
            if (j != mxs) {
                for (auto [a, b, p]: cv[j]) {
                    cv[i].Insert(a, b + (tag[j] - tag[i]));
                }
                cv[j].clear();
            }
        }
        debug(i, "out");

    };

    int root = 1;
    dfs(dfs, root);

    debug(tag[root]);
    debug(cv[root].Query(C[root]));
    cout << -(cv[root].Query(C[root]) + tag[root]) << '\n';
    return 0;
}