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

struct Segt {
	struct P {
		ll mx, tag;
		P() : mx(0), tag(0) {}
		void add(ll val) {
			mx += val, tag += val;
		}
	};
	int n;
	vector<P> t;
	Segt(int _n) : n(_n), t(n << 2 | 1) {}
	void add(int al, int ar, ll val) {
		add(al, ar, val, 1, 0, n - 1);
	}
	ll getmx(int ql, int qr) {
		return getmx(ql, qr, 1, 0, n - 1);
	}
	void print() {
		print(0, 1, 0, n - 1);
		cout << endl;
	}
	#define mid ((l + r) >> 1)
	#define ls (v << 1)
	#define rs (v << 1 | 1)
	void add(int al, int ar, ll val, int v, int l, int r) {
		if (ar < l || al > r) {
			return;
		}
		if (al <= l && ar >= r) {
			t[v].add(val);
		} else {
			add(al, ar, val, ls, l, mid);
			add(al, ar, val, rs, mid + 1, r);
			t[v].mx = max(t[ls].mx, t[rs].mx) + t[v].tag;
		}
	}
	ll getmx(int ql, int qr, int v, int l, int r) {
		if (qr < l || ql > r) {
			return -lnf;
		}
		if (ql <= l && qr >= r) {
			return t[v].mx;
		}
		return max(getmx(ql, qr, ls, l, mid), getmx(ql, qr, rs, mid + 1, r)) + t[v].tag;
	}
	void print(ll d, int v, int l, int r) {
		d += t[v].tag;
		if (l == r) {
			cout << d << ' ';
		} else {
			print(d, ls, l, mid);
			print(d, rs, mid + 1, r);
		}
	}
	#undef rs
	#undef ls
	#undef mid
};

struct Tree {
	int n;
	vector<vector<int>> son;
	vector<int> a;
	vector<vector<pair<int, int>>> p;
	vector<int> wson, top, dep;
	Tree(int _n, int m) : n(_n), son(n + 1), a(n + 1), p(n + 1), wson(n + 1), top(n + 1), dep(n + 1) {
		for (int i = 2; i <= n; i++) {
			int f;
			cin >> f;
			son[f].emplace_back(i);
		}
		for (int i = 1; i <= n; i++) {
			cin >> a[i];
		}
		for (int i = 1; i <= m; i++) {
			int x, k, c;
			cin >> x >> k >> c;
			p[x].emplace_back(k, c);
		}
		init(1);
		gettop(1, 1);
	}
	void init(int v) {
		dep[v] = 1;
		for (auto u : son[v]) {
			init(u);
			if (dep[u] + 1 > dep[v]) {
				dep[v] = dep[u] + 1;
				wson[v] = u;
			}
		}
	}
	void gettop(int v, int t) {
		top[v] = t;
		if (wson[v]) {
			gettop(wson[v], t);
		}
		for (auto u : son[v]) {
			if (u != wson[v]) {
				gettop(u, u);
			}
		}
	}
	ll solve() {
		Segt tr(dep[1]);
		solve(1, tr);
		return max(0ll, tr.getmx(0, n + 1));
	}
	void solve(int v, Segt &tr) {
		if (wson[v]) {
			solve(wson[v], tr);
		}
		int l = dep[top[v]] - dep[v];
		tr.add(l, l, a[v] + max(0ll, tr.getmx(l + 1, n + 1)));
		for (auto u : son[v]) {
			if (u != wson[v]) {
				Segt tx(dep[u]);
				solve(u, tx);
				//cout << u << ": ";
				//tx.print();
				for (int i = 0; i < dep[u]; i++) {
					ll vx = tx.getmx(i, i) + max(0ll, tr.getmx(l + i + 1, n + 1));
					ll vold = tr.getmx(l + i + 1, l + i + 1);
					ll vr = vold + max(0ll, tx.getmx(i, n + 1));
					tr.add(l + i + 1, l + i + 1, max(vx, vr) - vold);
				}
				tr.add(l, l, max(0ll, tx.getmx(0, n + 1)));
			}
		}
		for (auto [k, c] : p[v]) {
			tr.add(l, l + k, -c);
		}
	}
};

void solve() {
	int n, m;
	cin >> n >> m;
	Tree tr(n, m);
	cout << tr.solve() << '\n';
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr), cout.tie(nullptr);
	int T;
	cin >> T;
	while (T--) {
		solve();
	}
	return 0;
}