#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

inline ll rd() {
	ll x = 0;
	bool f = 0;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) f |= (c == '-');
	for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
	return f ? -x : x;
}

#define eb emplace_back
#define all(s) (s).begin(), (s).end()
#define per(i, a, b) for (int i = (a); i >= (b); --i)
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)

#define N 100007

vector<pii> e[N];

bool red[N];

int tot, lg[N], dfn[N], st[17][N];

ll dep[N], ans[N];

int getpre(int u, int v) {return dfn[u] < dfn[v] ? u : v;}

void dfs(int u, int fa, ll mxd) {
	if (red[u]) mxd = dep[u];
	ans[u] = dep[u] - mxd;
	st[0][dfn[u] = ++tot] = fa;
	for (auto [v, w] : e[u]) if (v != fa) {
		dep[v] = dep[u] + w; dfs(v, u, mxd);
	}
}

int lca(int u, int v) {
	if (u == v) return u;
	if ((u = dfn[u]) > (v = dfn[v])) swap(u, v);
	int k = lg[v - u++];
	return getpre(st[k][u], st[k][v - (1 << k) + 1]);
}

vector<int> s;

vector<pii> tmp;

inline void work() {
	tot = 0;
	int n = rd(), m = rd(), q = rd();
	rep(i, 1, n) e[i].clear(), red[i] = false;
	rep(i, 1, m) red[rd()] = true;
	rep(i, 1, n - 1) {
		int u = rd(), v = rd(), w = rd();
		e[u].eb(v, w); e[v].eb(u, w);
	}
	dfs(1, 1, 0);
	rep(i, 1, lg[n])
		rep(u, 1, n - (1 << i) + 1) 
			st[i][u] = getpre(st[i - 1][u], st[i - 1][u + (1 << i - 1)]);
	rep(i, 1, q) {
		s.clear(); tmp.clear();
		int u = 0;
		per(t, rd(), 1) {
			int x = rd(); s.eb(x);
			if (u == 0 || ans[x] > ans[u]) u = x;
		}
		if (s.size() == 1) {puts("0"); continue;}

		ll lim = 0, redu = dep[u] - ans[u];
		for (auto x : s) {
			int anc = lca(u, x);
			if (ans[x] <= dep[x] - dep[anc] || dep[anc] <= redu) lim = max(lim, ans[x]);
			else tmp.eb(lca(u, x), x); 
		}
		if (lim == ans[u]) {printf("%lld\n", lim); continue;}
		
		ll res = 1e18;
		sort(all(tmp), [&](pii a, pii b){return dep[a.first] < dep[b.first];});
		for (auto [anc, x] : tmp) {
			res = min(res, max(lim, dep[u] - dep[anc]));
			lim = max(lim, ans[x]);
		}
		printf("%lld\n", res);
	}
}

int main() {
	rep(i, 2, N - 1) lg[i] = lg[i >> 1] + 1;
	per(t, rd(), 1) work();
	return 0;
}