#include <bits/stdc++.h>
#define ll long long
#define int long long
using namespace std;

const int maxn = 310000;
const int maxp = maxn*4;
const int inf  = 1e15;

vector<int>E[maxn];
int n,m;

struct segment
{
	int tot;
	int seg[maxp],flag[maxp];
	int lc[maxp],rc[maxp];
	int newnode()
	{
		++tot;
		lc[tot]=rc[tot]=flag[tot]=0;
		seg[tot]=-inf;
		return tot;
	}
	void init()
	{
		tot=0;
	}
	void pushdown(const int x)
	{
		if(flag[x])
		{
			int fl=flag[x]; flag[x]=0;
			
			seg[lc[x]]+=fl; seg[rc[x]]+=fl;
			flag[lc[x]]+=fl; flag[rc[x]]+=fl;
		}
	}
	void build(int &x,const int l,const int r)
	{
		if(!x) x=newnode();
		if(l==r) return;
		int mid=(l+r)>>1;
		build(lc[x],l,mid); build(rc[x],mid+1,r);
	}
	int lx,rx,c;
	void add(const int x,const int l,const int r)
	{
		if(rx<l||r<lx) return;
		if(lx<=l&&r<=rx)
		{
			seg[x]+=c;
			flag[x]+=c;
			return;
		}
		pushdown(x);
		int mid=(l+r)>>1;
		add(lc[x],l,mid); add(rc[x],mid+1,r);
		seg[x]=max( seg[lc[x]],seg[rc[x]] );
	}
	int query(const int x,const int l,const int r)
	{
		if(rx<l||r<lx) return -inf;
		if(lx<=l&&r<=rx) return seg[x];
		pushdown(x);
		int mid=(l+r)>>1;
		return max( query(lc[x],l,mid), query(rc[x],mid+1,r) );
	}
	int loc;
	void upd(const int x,const int l,const int r)
	{
		if(l==r)
		{
			seg[x]=max(seg[x],c);
			return;
		}
		int mid=(l+r)>>1;
		pushdown(x);
		if(loc<=mid) upd(lc[x],l,mid);
		else upd(rc[x],mid+1,r);
		seg[x]=max( seg[lc[x]], seg[rc[x]] );
	}
}seg;

int ai[maxn];
int son[maxn],d[maxn],top[maxn],rt[maxn];
void dfs(const int x)
{
	d[x]=0;
	son[x]=0;
	for(auto y:E[x])
	{
		dfs(y);
		if(d[x]<d[y]+1) 
		{
			d[x]=d[y]+1;
			son[x]=y;
		}
	}
}
void dfs2(const int x,const int tp)
{
	top[x]=tp;
	rt[x]=0;
	if(x==tp)
	{
		seg.build(rt[x],1,1+d[x]);
	}
	
	if(son[x]) dfs2(son[x],tp);
	for(auto y:E[x]) if(y!=son[x])
	{
		dfs2(y,y);
	}
}
vector< pair<int,int> >V[maxn];
void dp(const int x)
{
	for(auto y:E[x])
	{
		dp(y);
	}
	
	int ff=top[x];
	
	//if(son[x])
	{
		seg.lx= 1+d[ff]-d[x]+1, seg.rx=1+d[ff];
		seg.c = max( 0ll, seg.query(rt[ff],1,1+d[ff]) )+ai[x];
		
		seg.loc= 1+d[ff]-d[x];
		seg.upd(rt[ff],1,1+d[ff]);
	}
/*	else
	{
		seg.loc= 1+d[ff]-d[x];
		seg.c=ai[x];
		seg.upd(rt[ff],1,1+d[ff]);
	}*/
	
	for(auto y:E[x]) if(y!=son[x])
	{
		for(int l=0;l<=d[y];l++)
		{
			seg.lx=1+d[ff]-d[x]+l+1, seg.rx=1+d[ff];
			int tc= max( 0ll, seg.query(rt[ff],1,1+d[ff]) );
			
			seg.lx=1+l, seg.rx=1+d[y];
			int cc= max( 0ll, seg.query(rt[y],1,1+d[y]) );
			
			seg.lx=seg.rx= 1+d[ff]-d[x]+l+1;
			seg.c=cc;
			seg.add(rt[ff],1,1+d[ff]);
			
			if(l==0)
			{
				seg.lx=seg.rx= 1+d[ff]-d[x];
				seg.c=cc;
				seg.add(rt[ff],1,1+d[ff]);
			}
			
			seg.c= cc+tc;
			seg.loc= 1+d[ff]-d[x]+l+1;
			seg.upd(rt[ff],1,1+d[ff]);
		}
	}
	for(auto [ki,ci]:V[x])
	{
		seg.lx=1+d[ff]-d[x],seg.rx= min(1+d[ff],seg.lx+ki);
		seg.c=-ci;
		seg.add(rt[ff],1,1+d[ff]);
	}
}

signed main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	
	int Tcase; cin>>Tcase;
	while(Tcase--)
	{
		cin>>n>>m;
		for(int i=1;i<=n;i++)
		{
			vector<int>_;
			E[i].swap(_);
			vector< pair<int,int> >__;
			V[i].swap(__);
		}
		for(int i=2;i<=n;i++)
		{
			int fi; cin>>fi;
			E[fi].emplace_back(i);
		}
		for(int i=1;i<=n;i++) cin>>ai[i];
		for(int i=1;i<=m;i++)
		{
			int xi,ki,ci; cin>>xi>>ki>>ci;
			V[xi].emplace_back(ki,ci);
		}
		
		dfs(1);
		dfs2(1,1);
		seg.init();
		
		dp(1);
		int ans;
		seg.lx=1,seg.rx=1+d[1];
		ans=max( 0ll, seg.query(rt[1],1,1+d[1]) );
		cout<<ans<<'\n';
	}
	
	return 0;	
}