#include <bits/stdc++.h>
using namespace std;
struct sparse_table_lca{
  vector<long long> D;
  vector<vector<int>> ST;
  int dmin(int u, int v){
    if (D[u] < D[v]){
      return u;
    } else {
      return v;
    }
  }
  sparse_table_lca(int N, vector<int> A, vector<long long> D): D(D){
    int M = A.size();
    int LOG = 32 - __builtin_clz(M);
    ST = vector<vector<int>>(LOG, vector<int>(M));
    for (int i = 0; i < M; i++){
      ST[0][i] = A[i];
    }
    for (int i = 0; i < LOG - 1; i++){
      for (int j = 0; j < M - (1 << i); j++){
        ST[i + 1][j] = dmin(ST[i][j], ST[i][j + (1 << i)]);
      }
    }
  }
  int query(int L, int R){
    int d = 31 - __builtin_clz(R - L);
    return dmin(ST[d][L], ST[d][R - (1 << d)]);
  }
};
int main(){
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  int T;
  cin >> T;
  for (int i = 0; i < T; i++){
    int n, m, q;
    cin >> n >> m >> q;
    vector<int> r(m);
    for (int j = 0; j < m; j++){
      cin >> r[j];
      r[j]--;
    }
    vector<bool> red(n, false);
    for (int j = 0; j < m; j++){
      red[r[j]] = true;
    }
    vector<vector<pair<int, int>>> E(n);
    for (int j = 0; j < n - 1; j++){
      int u, v, w;
      cin >> u >> v >> w;
      u--;
      v--;
      E[u].push_back(make_pair(w, v));
      E[v].push_back(make_pair(w, u));
    }
    vector<int> p(n, -1);
    vector<vector<int>> c(n);
    vector<long long> d(n, 0);
    vector<long long> dp(n, 0);
    queue<int> Q;
    Q.push(0);
    while (!Q.empty()){
      int v = Q.front();
      Q.pop();
      for (pair<int, int> e : E[v]){
        int w = e.second;
        if (w != p[v]){
          p[w] = v;
          c[v].push_back(w);
          d[w] = d[v] + e.first;
          dp[w] = dp[v] + e.first;
          if (red[w]){
            dp[w] = 0;
          }
          Q.push(w);
        }
      }
    }
    vector<int> dv;
    vector<int> in(n);
    auto dfs = [&](auto dfs, int v) -> void {
      in[v] = dv.size();
      dv.push_back(v);
      for (int w : c[v]){
        dfs(dfs, w);
        dv.push_back(v);
      }
    };
    dfs(dfs, 0);
    sparse_table_lca ST(n, dv, d);
    auto lca = [&](int u, int v){
      if (in[u] > in[v]){
        swap(u, v);
      }
      return ST.query(in[u], in[v] + 1);
    };
    for (int j = 0; j < q; j++){
      int k;
      cin >> k;
      vector<int> v(k);
      for (int l = 0; l < k; l++){
        cin >> v[l];
        v[l]--;
      }
      sort(v.begin(), v.end(), [&](int x, int y){
        return dp[x] < dp[y];
      });
      vector<long long> cdp(k);
      for (int l = 0; l < k; l++){
        cdp[l] = dp[v[l]];
      }
      vector<int> S(k);
      S[k - 1] = v[k - 1];
      for (int l = k - 2; l >= 0; l--){
        S[l] = lca(v[l], S[l + 1]);
      }
      vector<long long> M(k);
      M[k - 1] = d[v[k - 1]];
      for (int l = k - 2; l >= 0; l--){
        M[l] = max(d[v[l]], M[l + 1]);
      }
      long long tv = cdp[k - 1], fv = -1;
      while (tv - fv > 1){
        long long mid = (tv + fv) / 2;
        int t = upper_bound(cdp.begin(), cdp.end(), mid) - cdp.begin();
        if (M[t] - d[S[t]] <= mid){
          tv = mid;
        } else {
          fv = mid;
        }
      }
      cout << tv << '\n';
    }
  }
}