// Go in my style.
// Not afraid to dark.

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

clock_t sttime;
#define STCLOCK sttime = clock ();
#define TIMENOW fprintf (stderr, "\nNOW TIME COSSEMED: %0.4lf\n", 1.0 * (clock () - sttime) / CLOCKS_PER_SEC);
#define inline __inline__ __attribute__ ((always_inline))

#define int long long

namespace io {
    int read_pos, read_dt; char read_char;
    inline int read (int &p = read_pos){
        p = 0, read_dt = 1; read_char = getchar ();
        while (! isdigit (read_char)){
            if (read_char == '-')
                read_dt = - 1;
            read_char = getchar ();
        }
        while (isdigit (read_char)){
            p = (p << 1) + (p << 3) + read_char - 48;
            read_char = getchar ();
        }
        return p = p * read_dt;
    }
    int write_sta[65], write_top;
    inline void write (int x){
        if (x < 0)
            putchar ('-'), x = - x;
        write_top = 0;
        do
            write_sta[write_top ++] = x % 10, x /= 10;
        while (x);
        while (write_top)
            putchar (write_sta[-- write_top] + 48);
    }
}

const int N = 3e5;
int n, m, fa[N + 5], x[N + 5], d[N + 5], c[N + 5], a[N + 5];
int dep[N + 5], md[N + 5], ls[N + 5];
vector < int > cm[N + 5], to[N + 5];
map < int , int > cf[N + 5];

void init (int u){
    md[u] = dep[u]; ls[u] = 0;
    for (int v : to[u]){
        dep[v] = dep[u] + 1, init (v);
        if (md[v] > md[u])
            md[u] = md[v], ls[u] = v;
    }
}
void sol (int u, int r){
    if (ls[u]) sol (ls[u], r);
    for (int v : to[u])
        if (v != ls[u]){
            sol (v, v);
            for (auto x : cf[v])
                cf[r][x.first] += x.second;
        }
    cf[r][dep[u]] += a[u];
    for (int o : cm[u]){
        int rd = c[o], del;
        map < int , int > ::iterator it;
        while (rd > 0 && cf[r].begin () != (it = cf[r].upper_bound (dep[u] + d[o]))){
            -- it; del = min (rd, it->second);
            it->second -= del, rd -= del;
            if (it->second == 0) cf[r].erase (it);
        }
    }
}


inline void ARKNIGHTS (){
    io::read (n), io::read (m);
    for (int i = 1;i <= n;++ i) to[i].clear ();
    for (int i = 2;i <= n;++ i) to[io::read (fa[i])].push_back (i);
    for (int i = 1;i <= n;++ i) io::read (a[i]);
    for (int i = 1;i <= n;++ i) cm[i].clear (), cf[i].clear ();
    for (int i = 1;i <= m;++ i){
        io::read (x[i]), io::read (d[i]), io::read (c[i]);
        cm[x[i]].push_back (i);
    }
    dep[1] = 1, init (1);
    sol (1, 1);
    int ans = 0;
    for (auto x : cf[1]) ans += x.second;
    io::write (ans), putchar ('\n');
}

signed main (){
    STCLOCK

    for (int T = io::read ();T --;) ARKNIGHTS ();

    TIMENOW
    return 0;
}