#include "bits/stdc++.h"
using namespace std;

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;


template<class T>
struct RMQ {
	vector<vector<T>> jmp;
	RMQ(const vector<T>& V) : jmp(1, V) {
		for (int pw = 1, k = 1; pw * 2 <= sz(V); pw *= 2, ++k) {
			jmp.emplace_back(sz(V) - pw * 2 + 1);
			rep(j,0,sz(jmp[k]))
				jmp[k][j] = min(jmp[k - 1][j], jmp[k - 1][j + pw]);
		}
	}
	T query(int a, int b) {
		assert(a < b); // or return inf if a == b
		int dep = 31 - __builtin_clz(b - a);
		return min(jmp[dep][a], jmp[dep][b - (1 << dep)]);
	}
};

struct LCA {
	int T = 0;
	vi time, path, ret;
	RMQ<int> rmq;

	LCA(vector<vi>& C) : time(sz(C)), rmq((dfs(C,0,-1), ret)) {}
	void dfs(vector<vi>& C, int v, int par) {
		time[v] = T++;
		for (int y : C[v]) if (y != par) {
			path.push_back(v), ret.push_back(time[v]);
			dfs(C, y, v);
		}
	}

	int lca(int a, int b) {
		if (a == b) return a;
		tie(a, b) = minmax(time[a], time[b]);
		return path[rmq.query(a, b)];
	}
	//dist(a,b){return depth[a] + depth[b] - 2*depth[lca(a,b)];}
};

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);

  int tt;
  cin >> tt;
  while(tt--) {
    int n, m, q;
    cin >> n >> m >> q;
    vector<bool> is_red(n);
    for (int i =0; i < m; i++) {
      int x;
      cin >> x;
      x--;
      is_red[x] = 1;
    }

    vector<vi> lca_g(n);
    vector<vector<pair<int, int>>> g(n);
    rep(i, 1, n) {
      int u, v, w;
      cin >>u  >> v >> w;
      u--, v--;
      lca_g[u].push_back(v);
      lca_g[v].push_back(u);
      g[u].push_back({v, w});
      g[v].push_back({u, w});
    }
    LCA L(lca_g);

    vector<int64_t> cost(n), total_weight(n);
    vi red_parent(n);
    auto cost_dfs = [&](auto& self, int s, int p)->void {
      if (is_red[s]) {
        cost[s] = 0;
        red_parent[s] = s;
      }
      for (auto& [u, w] : g[s]) {
        if (u == p) continue;
        cost[u] = cost[s] + w;
        total_weight[u] = total_weight[s] + w;
        red_parent[u] = red_parent[s];
        self(self, u, s);
      }
    };
    cost_dfs(cost_dfs, 0, 0);

    while(q--) {
      int k;
      cin >> k;
      vi v(k);
      for (auto& x : v) cin >> x, x--;
      sort(all(v), [&](int x, int y)->bool {
        return cost[x] > cost[y];
      });
      if (v.size() == 1) {
        cout << 0 << '\n';
        continue;
      }
      int64_t ans = cost[v[1]];
      int curr_lca = v[0];
      rep(i, 1, k) {
        int new_lca = L.lca(curr_lca, v[i]);
        // THe new LCA is an ancestor of the red parent of the costliest
        // node, so the maximum cost would not change.
        if (L.lca(new_lca, red_parent[v[0]]) == new_lca)
          break;
        int64_t newans = total_weight[v[0]] - total_weight[new_lca];
        if (i+1 < k) {
          newans = max(newans, cost[v[i+1]]);
        }
        ans = min(ans, newans);
        curr_lca = new_lca;
      }
      cout << ans << '\n';
    }
  }
}