#include <bits/stdc++.h>

#define int long long

void solve() {
  int n, m, q;
  std::cin >> n >> m >> q;
  std::vector<std::vector<std::pair<int, int>>> adj(n + 1);
  std::vector<bool> red(n + 1, false);
  for (int i = 1, x; i <= m; ++i) { std::cin >> x; red[x] = true; }
  for (int i = 1, u, v, w; i <= n - 1; ++i) {
    std::cin >> u >> v >> w;
    adj[u].emplace_back(v, w);
    adj[v].emplace_back(u, w);
  }
  std::vector<int> depth(n + 1), cost(n + 1), lg(n + 1), dis(n + 1);
  std::vector<std::array<int, 30>> Fa(n + 1);
  for (int i = 1; i <= n; ++i) lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
  auto dfs = [&] (auto self, int u, int fa) -> void {
    depth[u] = depth[fa] + 1, Fa[u][0] = fa;
    for (int i = 1; i <= lg[depth[u]]; ++i) Fa[u][i] = Fa[Fa[u][i - 1]][i - 1];
    for (auto x : adj[u]) {
      if (x.first == fa) continue;
      dis[x.first] = dis[u] + x.second;
      self(self, x.first, u);
    }
  };
  auto dfs1 = [&] (auto self, int u, int fa, int now) -> void {
    if (red[u]) now = std::max(now, dis[u]);
    cost[u] = dis[u] - now;
    for (auto x : adj[u]) {
      if (x.first == fa) continue;
      self(self, x.first, u, now);
    }
  };
  auto LCA = [&] (int x, int y) {
    if (depth[x] < depth[y]) std::swap(x, y);
    while (depth[x] > depth[y]) x = Fa[x][lg[depth[x] - depth[y]] - 1];
    if (x == y) return x;
    for (int k = lg[depth[x]] - 1; ~k; --k) {
      if (Fa[x][k] != Fa[y][k]) {
        x = Fa[x][k], y = Fa[y][k];
      }
    }
    return Fa[x][0];
  };
  dfs(dfs, 1, 0);
  dfs1(dfs1, 1, 0, 0);
  while (q --) {
    int k;
    std::cin >> k;
    std::vector<std::pair<int, int>> a(k + 1);
    for (int i = 1; i <= k; ++i) {
      std::cin >> a[i].second;
      a[i].first = cost[a[i].second];
    }
    if (k == 1) {
      std::cout << 0 << '\n';
      continue;
    }
    std::sort(a.begin() + 1, a.end());
    int ans = a.back().first;
    int lca = a.back().second;
    int mxdepth = dis[lca];
    for (int i = k; i >= 1; --i) {
      mxdepth = std::max(mxdepth, dis[a[i].second]);
      ans = std::min(ans, std::max(a[i - 1].first, mxdepth - dis[lca]));
      lca = LCA(lca, a[i - 1].second);
    }
    std::cout << ans << '\n';
  }
}

signed main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(0);
  int _(1);
  std::cin >> _;
  while (_ --) solve();
  return 0;
}