#include <bits/stdc++.h>

using namespace std;

#define lep(i, l, r) for(int i = (l); i <= (r); i ++)
#define rep(i, l, r) for(int i = (l); i >= (r); i --)

using i64 = long long;

const int N = 1e5 + 5;

int n, m, q;
int isred[N];
vector<pair< int, int> > e[N];
int fa[N][20], lg[N], dep[N], cntred[N];
i64 dis[N];

void clear() {
	for (int i = 1; i <= n; i ++) e[i].clear(), isred[i] = 0, dis[i] = 0;
	for (int i = 1; i <= n; i ++) 
		for (int j = 0; j <= 19; j ++) fa[i][j] = 0;
}

void dfs1(int x, int fx) {
	fa[x][0] = fx;
	dep[x] = dep[fx] + 1;
	cntred[x] = cntred[fx] + isred[x];
	for (int i = 1; i <= lg[dep[x]]; i ++)
		fa[x][i] = fa[fa[x][i - 1]][i - 1];
	for (auto [y, w] : e[x]) if (y != fx) dis[y] = dis[x] + w, dfs1 (y, x);
}

void jump(int &x, i64 lim) {
	i64 disdown = dis[x];
	for (int i = lg[dep[x]]; i >= 0; i --)
		if (fa[x][i] && disdown - dis[fa[x][i]] <= lim)
			x = fa[x][i];
}

int lca(int x, int y) {
	if (dep[x] < dep[y]) swap (x, y);
	while (dep[x] > dep[y]) {
		x = fa[x][lg[dep[x] - dep[y]]];
	}
	if (x == y) return x;
	for (int i = lg[dep[x]]; i >= 0; i --)
		if (fa[x][i] ^ fa[y][i]) x = fa[x][i], y = fa[y][i];
	return fa[x][0];
}

void jumpa(int &x) {
	for (int i = lg[dep[x]]; i >= 0; i --) {
		if (fa[x][i] && (cntred[x] - cntred[fa[x][i]]) == 0 && isred[fa[x][i]] == 0)
			x = fa[x][i]; 	
	}
	if (isred[fa[x][0]]) x = fa[x][0];
}

void solve_one_query() {
	int k;
	cin >> k;
	vector<tuple<int, int, i64> > nodes(k);
	for (auto &[x, y, w] : nodes) {
		cin >> x, y = x, jumpa(y);
		if (isred[y]) w = dis[x] - dis[y];
		else w = 1e18;
	}
	
	vector<tuple<int, int, i64> > nodes_tmp;
	for (auto &[x, y, w] : nodes) {
		if (isred[x] == 0) nodes_tmp.push_back ({x, y, w} );
	}
	
	nodes = nodes_tmp;
	k = nodes_tmp.size();
	
	sort (nodes.begin(), nodes.end(), [&] (auto x, auto y) {
		return std :: get<2> (x) < std :: get<2> (y); 
	} );
	
	vector<int> suf_lca(k);
	vector<i64> suf_max(k);
	for (int i = k - 1; i >= 0; i --) {
		suf_lca[i] = get<0> (nodes[i]);
		suf_max[i] = dis[get<0> (nodes[i])];
		if (i != k - 1) 
			suf_lca[i] = lca (suf_lca[i], suf_lca[i + 1]), 
			suf_max[i] = max (suf_max[i], suf_max[i + 1]);
	}
	
	auto check = [&] (i64 maxlen) -> int {
		for (int i = 0; i <= k - 1; i ++)
			if (get<2> (nodes[i]) > maxlen) {
				if (dis[suf_lca[i]] + maxlen >= suf_max[i])
					return true;
				else
					return false;
			}
		return true;
	} ;
	
	i64 l = 0, r = 1e14, res = 1e14;
	while (l <= r) {
		i64 mid = (l + r) >> 1;
		if (check (mid)) r = mid - 1, res = mid;
		else l = mid + 1;
	}
	
	cout << res << '\n';
	
	/*
	
	auto check = [&] (i64 maxlen) -> int {
		vector<int> upnodes = nodes;
		for (int &x : upnodes) jump(x, maxlen);
		vector<int> limnode;
		
		int lc = -1;
		int deep_y = 1;
		
		for (int i = 0; i < k; i ++) {
			int x = nodes[i], y = upnodes[i];
			if ((cntred[x] - cntred[y]) == 0 && ! isred[y]) {
				// have lim
				if (dis[y] > dis[deep_y]) deep_y = y;
				if (lc == -1) lc = x;
				else lc = lca (lc, x);
			}
			else continue;
		}
		
		if (lc == -1 || dep[lc] >= dep[deep_y]) return true;
		else return false;
	} ;
	
	i64 l = 0, r = 1e14, res = 1e14;
	while (l <= r) {
		i64 mid = (l + r) >> 1;
		if (check (mid)) r = mid - 1, res = mid;
		else l = mid + 1;
	}
	
	cout << res << '\n'; */
}

void solve() {
	clear();
	cin >> n >> m >> q;
	lep (i, 1, m) {
		int x;
		cin >> x;
		isred[x] = 1;
	}
	lep (i, 2, n) {
		int x, y, w;
		cin >> x >> y >> w;
		e[x].push_back ( {y, w} );
		e[y].push_back ( {x, w} );
	}
	lep (i, 2, n) lg[i] = lg[i >> 1] + 1;
	dfs1 (1, 0);
	//q = 1;
	while (q --) solve_one_query();
}

int main() {
	ios :: sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	int Case;
	cin >> Case; //Case = 1;
	while (Case --) solve();
	return 0;
}