#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#define all(arr) (arr).begin(), (arr).end()
#define ll long long
#define ld long double
#define pb push_back
#define sz(x) (int)(x).size()
#define fi first
#define se second
#define endl '\n'

const int N = 1e5 + 20, LOG = 20;
const ll INF = 1e18;

vector<pair<int, ll>> g[N], ng[N];
ll val[N];
int par[N][LOG], tin[N], tout[N], timer, pidx[N], sidx[N];
ll prefdist[N];
bool red[N], marked[N];

void dfs1(int v, int p, ll dist){
  par[v][0] = p;
  for (int i = 1; i < LOG; i++) par[v][i] = par[par[v][i - 1]][i - 1];
  val[v] = (red[v]? 0 : dist);
  dist = val[v];
  tin[v] = timer++;
  for (auto [u, w] : g[v]){
    if (u == p) continue;
    prefdist[u] = prefdist[v] + w;
    dfs1(u, v, dist + w);
  }
  tout[v] = timer++;
}

bool is_anc(int u, int v){
  return tin[u] <= tin[v] && tin[v] <= tout[u];
}

int lca(int u, int v){
  if (is_anc(u, v)) return u;
  if (is_anc(v, u)) return v;
  for (int i = LOG - 1; i >= 0; i--){
    if (!is_anc(par[u][i], v)) u = par[u][i];
  }
  return par[u][0];
}

ll dist(int u, int v){
  return prefdist[u] + prefdist[v] - 2 * prefdist[lca(u, v)];
}

vector<ll> prefmax, suffmax;
vector<int> allnodes;
ll curans;
ll maxdist[N], maxcompleted[N];

void dfs2(int v){
  maxdist[v] = (marked[v] && !red[v]? 0 : -INF), maxcompleted[v] = 0;
  for (auto [u, w] : ng[v]){
    dfs2(u);
    if (red[v]) maxcompleted[v] = max({maxcompleted[v], maxcompleted[u], maxdist[u] + w});
    else maxdist[v] = max(maxdist[v], maxdist[u] + w), maxcompleted[v] = max(maxcompleted[v], maxcompleted[u]);
  }
  if (red[v]) return;
  curans = min(curans, 
  max({maxcompleted[v], maxdist[v],
  pidx[v]? prefmax[pidx[v] - 1] : 0,
  sidx[v] == sz(suffmax) - 1? 0 : suffmax[sidx[v] + 1]}));
}

ll subsolve(vector<int> nodes){
  for (auto i : nodes) marked[i] = 1;
  int n = sz(nodes);
  sort(all(nodes), [&] (int i, int j){
    return tin[i] < tin[j];
  });
  for (int i = 1; i < n; i++){
    nodes.pb(lca(nodes[i], nodes[i - 1]));
  }
  nodes.pb(1);
  sort(all(nodes), [&] (int i, int j){
    return tin[i] < tin[j];
  });
  nodes.erase(unique(all(nodes)), nodes.end());

  vector<int> stk{1};
  for (int i = 1; i < sz(nodes); i++){
    int v = nodes[i];
    while (!is_anc(stk.back(), v)) stk.pop_back();
    ng[stk.back()].pb({v, dist(v, stk.back())});
    stk.pb(v);
  }

  allnodes = nodes;
  n = sz(nodes);
  prefmax = suffmax = vector<ll>(n);

  for (int i = 0; i < n; i++){
    ll cur = (marked[nodes[i]]? val[nodes[i]] : 0);
    if (i) prefmax[i] = prefmax[i - 1];
    prefmax[i] = max(prefmax[i], cur);

    pidx[nodes[i]] = i;
  }

  sort(all(nodes), [&] (int i, int j){
    return tout[i] < tout[j];
  });

  for (int i = n - 1; i >= 0; i--){
    ll cur = (marked[nodes[i]]? val[nodes[i]] : 0);
    if (i + 1 < n) suffmax[i] = suffmax[i + 1];
    suffmax[i] = max(suffmax[i], cur);

    sidx[nodes[i]] = i;
  }

  curans = 0;
  for (auto v : nodes) if (marked[v]) curans += val[v];
  dfs2(1);

  for (auto v : nodes){
    marked[v] = 0;
    ng[v].clear();
  }

  return curans;
}

void solve(){
  int n, m, q;
  cin >> n >> m >> q;
  for (int i = 0; i <= n; i++){
    g[i].clear();
    ng[i].clear();
    red[i] = 0;
  }
  while (m--){
    int x;
    cin >> x;
    red[x] = 1;
  }
  for (int i = 1; i < n; i++){
    int u, v, w;
    cin >> u >> v >> w;
    g[u].pb({v, w});
    g[v].pb({u, w});
  }
  timer = 0;
  dfs1(1, 1, 0);
  while (q--){
    int k;
    cin >> k;
    vector<int> nodes(k);
    for (auto &i : nodes) cin >> i;
    cout << subsolve(nodes) << endl;
  }
}

signed main(){
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  // cout.precision(20);
  int t;
  cin >> t;
  while (t--){
    solve();
  }
}