#include<iostream>
#include<vector>
#include<algorithm>
#include<cassert>

using namespace std;

const long long int MAXN = 50010;
long long int test1, n, P[MAXN], C[MAXN], Visited[MAXN], Parent[MAXN], u, v, DP1[MAXN], DP2[MAXN];
vector<long long int> E[MAXN];

void dfs(long long int u)
{
  assert(Visited[u] == 0);
  Visited[u] = 1;
  //cout<<"Visiting: "<<u<<"\n";
  
  for(int i=0;i<E[u].size();i++)
  {
    long long int v = E[u][i];
    if(Parent[u] == v)
      continue;
    Parent[v] = u;
    dfs(v);
  }
  
  //DP1[u] = Ans for subtree rooted at u.
  //DP2[u] = Ans for subtree rooted at u, but knowing that Parent of u can be captured even if u isn't.
  
  vector<long long int> Children;
  long long int dp2sum=0;
  
  for(int i=0;i<E[u].size();i++)
  {
    if(E[u][i]==Parent[u])
      continue;
    dp2sum+=DP2[E[u][i]];
    Children.push_back(DP1[E[u][i]] - DP2[E[u][i]]);
  }
  sort(Children.begin(), Children.end());
  
  
  if(C[u]<=Children.size())
  {
    DP1[u] = dp2sum;
    for(int i=0;i<C[u];i++)
      DP1[u]+=Children[i];
  }
  else
  {
    DP1[u] = P[u] + dp2sum;
  }
  
  DP1[u] = min (DP1[u], (P[u] + dp2sum));
  
  DP2[u] = dp2sum;
  for(int i=0;i<(C[u]-1);i++)
    DP2[u]+=Children[i];
  
  DP2[u] = min(DP2[u], DP1[u]);
  return;
}


int main()
{
  cin>>test1;
  
  for(int qq=1;qq<=test1;qq++)
  { 
    cin>>n;
    
    for(int i=1;i<=n;i++)
    {
      E[i].clear();
      Parent[i] = -2;
      Visited[i] = 0;
    }
    
    for(int i=1;i<n;i++)
    {
      cin>>u>>v;
      E[u].push_back(v);
      E[v].push_back(u);
    }
    
    for(int i=1;i<=n;i++)
      cin>>P[i];
    
    for(int i=1;i<=n;i++)
    {
      cin>>C[i];
      assert( (1<=C[i]) && (C[i]<=E[i].size()) );
    }
    
    Parent[1] = -1;
    dfs(1);
    
    cout<<DP1[1]<<"\n";
    
//     for(int i=1;i<=n;i++)
//       cout<<i<<" "<<DP1[i]<<" "<<DP2[i]<<"\n";
  }
}