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

#define pb push_back
#define eb emplace_back
#define all(x) x.begin(), x.end()
#define srt(x) sort(all(x))
#define uni(x) sort(all(x)), x.erase(unique(all(x)), x.end())
#define msv(x, v) memset((x), (v), sizeof(x))
#define ms(x) memset(x, 0, sizeof(x))
#define dbg(x) cerr << #x " = " << (x) << endl

typedef long long ll;
typedef long double ld;
typedef unsigned int uint;
typedef unsigned long long ull;

typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<int, ll> pil;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vpii;
typedef vector<pil> vpil;
typedef vector<pli> vpli;
typedef vector<pll> vpll;

const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos(-1.0);
const double EPS = 1e-9;
const int MOD = 1000000007;
//const int MOD = 998244353;

struct Scanner {

    bool hasNext = 1;
    bool hasRead = 1;

    int nextInt() {
        hasRead = 0;
        int res = 0;
        char flag = 1, ch = getchar();
        while(ch != EOF && !isdigit(ch)) {
            hasRead = 1;
            flag = (ch == '-') ? -flag : flag;
            ch = getchar();
        }
        while(ch != EOF && isdigit(ch)) {
            hasRead = 1;
            res = res * 10 + (ch - '0');
            ch = getchar();
        }
        if(ch == EOF)
            hasNext = 0;
        return res * flag;
    }

    ll nextLL() {
        hasRead = 0;
        ll res = 0;
        char flag = 1, ch = getchar();
        while(ch != EOF && !isdigit(ch)) {
            hasRead = 1;
            flag = (ch == '-') ? -flag : flag;
            ch = getchar();
        }
        while(ch != EOF && isdigit(ch)) {
            hasRead = 1;
            res = res * 10 + (ch - '0');
            ch = getchar();
        }
        if(ch == EOF)
            hasNext = 0;
        return res * flag;
    }

    char nextChar() {
        hasRead = 0;
        char ch = getchar();
        while(ch != EOF && isspace(ch)) {
            hasRead = 1;
            ch = getchar();
        }
        if(ch == EOF)
            hasNext = 0;
        return ch;
    }

    int nextString(char *str) {
        hasRead = 0;
        int len = 0;
        char ch = getchar();
        while(ch != EOF && isspace(ch)) {
            hasRead = 1;
            ch = getchar();
        }
        while(ch != EOF && !isspace(ch)) {
            hasRead = 1;
            str[++len] = ch;
            ch = getchar();
        }
        str[len + 1] = 0;
        if(ch == EOF)
            hasNext = 0;
        return len;
    }

} sc;

ll rd() {
    ll x = sc.nextLL();
    return x;
}

void rd(int &x) {
    x = sc.nextInt();
}

void rd(ll &x) {
    x = sc.nextLL();
}

void rd(char &x) {
    x = sc.nextChar();
}

void rd(char* x) {
    sc.nextString(x);
}

template<typename T1, typename T2>
void rd(pair<T1, T2> &x) {
    rd(x.first);
    rd(x.second);
}

template<typename T>
void rd(T *x, int n) {
    for(int i = 1; i <= n; ++i)
        rd(x[i]);
}

void printInt(int x) {
    if(x < 0) {
        putchar('-');
        x = -x;
    }
    if(x >= 10)
        printInt(x / 10);
    putchar('0' + x % 10);
}

void printLL(ll x) {
    if(x < 0) {
        putchar('-');
        x = -x;
    }
    if(x >= 10)
        printLL(x / 10);
    putchar('0' + x % 10);
}

void pr(int x, char ch = '\n') {
    printInt(x);
    putchar(ch);
}

void pr(ll x, char ch = '\n') {
    printLL(x);
    putchar(ch);
}

template<typename T1, typename T2>
void pr(pair<T1, T2> x, char ch = '\n') {
#ifdef LOCAL
    putchar('<');
    pr(x.first, ' ');
    pr(x.second, '>');
    putchar(ch);
    return;
#endif // LOCAL
    pr(x.first, ' ');
    pr(x.second, ch);
}

template<typename T>
void pr(T *x, int n) {
    for(int i = 1; i <= n; ++i)
        pr(x[i], " \n"[i == n]);
}

template<typename T>
void pr(vector<T> &x) {
    int n = x.size();
    for(int i = 1; i <= n; ++i)
        pr(x[i - 1], " \n"[i == n]);
}

template<typename T>
void cmin(T &x, T y) {
    if(y < x)
        x = y;
}

template<typename T>
void cmax(T &x, T y) {
    if(y > x)
        x = y;
}

/* begin */

int n;
vector<int> G[200005];
int a[200005];
int d[200005];
ll dp[200005];
int vis[200005];
vector<ll> dpm[200005];
vector<ll> dpp[200005];
vector<ll> dpa[200005];

queue<int> Q;
void bfs() {
    for(int i = 1; i <= n; ++i) {
        vis[i] = -1;
        dp[i] = 0;
        dpm[i].clear();
        dpp[i].clear();
        dpa[i].clear();
    }
    int curd = 0;
    d[1] = 1;
    dp[1] = 0;
    dpm[1].eb(-a[1]);
    dpp[1].eb(+a[1]);
    dpa[1].eb(a[1]);
    vis[1] = 0;
    Q.push(1);
    while(!Q.empty()) {
        int u = Q.front();
        Q.pop();
        if(d[u] > curd) {
            curd = d[u];
            srt(dpm[curd]);
            srt(dpp[curd]);
            srt(dpa[curd]);
        }
        int p = vis[u];
        cmax(dp[u], dp[p] - a[u] + dpa[curd].back());
        cmax(dp[u], dp[p] + a[u] - dpa[curd][0]);
        cmax(dp[u], dpm[curd].back() + a[u]);
        cmax(dp[u], dpp[curd].back() - a[u]);
        for(int v : G[u]) {
            if(v == p)
                continue;
            d[v] = d[u] + 1;
            dpm[d[v]].eb(dp[u] - a[v]);
            dpp[d[v]].eb(dp[u] + a[v]);
            dpa[d[v]].eb(a[v]);
            vis[v] = u;
            Q.push(v);
        }
    }

}

struct Solver {

    void InitOnce() {
    }

    void Read() {
        rd(n);
        for(int i = 1; i <= n; ++i)
            G[i].clear();
        for(int i = 2; i <= n; ++i) {
            int v;
            rd(v);
            G[i].eb(v);
            G[v].eb(i);
        }
        for(int i = 2; i <= n; ++i)
            rd(a[i]);
    }

    void Solve() {
        bfs();
        ll ans = *max_element(dp + 1, dp + 1 + n);
        pr(ans);
    }

} solver;

/* end */

int main() {
#ifdef LOCAL
    freopen("A.in", "r", stdin);
#endif // LOCAL
    solver.InitOnce();
    int t = INF;
    t = sc.nextInt();
    for(int i = 1; i <= t; ++i) {
        solver.Read();
        if(!sc.hasRead)
            break;
        solver.Solve();
        if(!sc.hasNext)
            break;
    }
    return 0;
}
