#include <iostream>
#include <cmath>
#include <vector>
#include <map>
#include <unordered_map>
#include <algorithm>
#include <array>
#include <queue>
#include <memory.h>
#include <tuple>
#include <set>
#include <unordered_set>
#include <bitset>
#include <chrono>
#include <assert.h>
#include <numeric>
#include <ranges>
using namespace std;
using ll=long long;
using ull=unsigned long long;
class Tree{
private:
	int n , M ;
	void Init(int now , int d , int fa) {
		dep[now] = d;
		for(int i = 1 ; i < M ; ++i) tr[now][i] = tr[tr[now][i - 1]][i - 1];
		for(auto [it , _] : G[now]) {
			if(it == fa) continue;
			tr[it][0] = now;
			dis[it] = dis[now] + _;
			Init(it , d + 1 , now);
		}
	}
public:
	vector<int> dep;
	vector<vector<pair<int , int> > > G;
	vector<vector<int> > tr;
	vector<ll> dis;
	vector<bool> red;
	vector<int> rfa;
	Tree(int x) : n(x) , G(x + 1) , M(__lg(x) + 2) , dep(x + 1) {
		tr = vector<vector<int> > (n + 1 , vector<int>(M) );
		dis.resize(n + 1);
		red.resize(n + 1 , false);
		rfa.resize(n + 1 , 0);
	}
	
	void add(int u , int v , int w = 0) {
		G[u].emplace_back(v , w);
		G[v].emplace_back(u , w);
	}
	
	void LCAInit(int root) {
		Init(root , 0 , -1);
	}
	
	void dfs(int now , int fa , int re) {
		if(!red[now]) rfa[now] = re;
		else rfa[now] = now;
		for(auto [x , y] : G[now]) {
			if(x == fa) continue;
			dfs(x , now , (red[now] ? now : re));
		}
	}
	
	int lca(int u , int v) {
		if(dep[u] < dep[v]) std::swap(u , v);
		int t = dep[u] - dep[v];
		while(t) {
			u = tr[u][std::__lg(t)];
			t = dep[u] - dep[v];
		}
		if(u == v) return u;
		for(int i = M - 1 ; i >= 0 ; --i) {
			if(tr[u][i] != tr[v][i]) {
				u = tr[u][i];
				v = tr[v][i];
			}
		}
		return tr[u][0];
	}
	
	int lca(int u , int v , int rt) {
		return lca(u , rt) ^ lca(v , rt) ^ lca(u , v);
	}
};
void solve() {
	int n , m , q;
	cin >> n >> m >> q;
	Tree tr(n);
	//cerr << "W" << endl;
	for(int i = 1 ; i <= m ; ++i) {
		int x;
		cin >> x;
		tr.red[x] = true;
	}
	for(int i = 1 ; i <= n - 1 ; ++i) {
		int u , v , w;
		cin >> u >> v >> w;
		tr.add(u , v , w);
	}
	tr.LCAInit(1);
	//cerr << "fawfw" << endl;
	tr.dfs(1 , -1 , -1);
	vector<ll> &dis = tr.dis;
	vector<int> &rfa = tr.rfa;
	constexpr int MXX = 1e8;
	auto path = [&](int now) {
		if(now == MXX) return (ll)0;
		return dis[now] - dis[rfa[now]];
	};
	while(q--) {
		int k;
		cin >> k;
		vector<int> v(k);
		for(auto &it : v) cin >> it;
		sort(v.begin() , v.end() , [&](auto a , auto b) {
			return path(a) > path(b);
		});
		ll ans = path(v[0]); 
		if(k == 1) ans = 0;
		else ans = path(v[1]);
		int lca = v[0];
		v.emplace_back(MXX);
		
		ll mx1 = 0 , mx2 = 0 , mx = 0;
		for(int i = 1 ; i < k ; ++i) {
			auto it = v[i];
			int x = tr.lca(lca , it);
			if(tr.dep[x] < tr.dep[lca]) {
				mx += dis[lca] - dis[x];
			}
			mx = max(mx , min(path(it) , dis[it] - dis[x]));
			ans = min(ans , max(mx , path(v[i + 1])));
			lca = x;
		}
		cout << ans << '\n';
	}
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	int t;
	cin >> t;
	while(t--) solve();
}