#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define all(p) p.begin(),p.end()

void solve(){
    int N,M,Q;
    cin>>N>>M>>Q;
    struct edge{
        int to;
        ll dist;
    };
    vector<int> r(N);
    rep(i,0,M){
        int a;
        cin>>a;
        r[a-1]=1;
    }
    vector<vector<edge>> G(N);
    rep(i,0,N-1){
        int a,b;
        ll c;
        cin>>a>>b>>c;
        a--,b--;
        G[a].push_back({b,c});
        G[b].push_back({a,c});
    }
    vector<ll> dist(N),dist_red(N),dep(N);
    vector<int> order;
    const int D=19;
    vector pare(D,vector<int>(N,-1));
    pare[0][0]=-2;
    order={0};
    rep(rp,0,N){
        int a=order[rp];
        if(r[a]) dist_red[a]=0;
        for(auto x:G[a]){
            if(pare[0][x.to]==-1){
                pare[0][x.to]=a;
                dist[x.to]=dist[a]+x.dist;
                dist_red[x.to]=dist_red[a]+x.dist;
                dep[x.to]=dep[a]+1;
                order.push_back(x.to);
            }
        }
    }
    rep(i,1,D) rep(j,0,N){
        if(pare[i-1][j]==-2){
            pare[i][j]=-2;
        } else {
            pare[i][j]=pare[i-1][pare[i-1][j]];
        }
    }
    auto lca =[&](int a,int b) -> int {
        if(dep[a]>dep[b]) swap(a,b);
        rep(d,0,D){
            if((dep[b]-dep[a])&(1<<d)){
                b=pare[d][b];
            }
        }
        if(a==b) return a;
        for(int d=D-1;d>=0;d--){
            if(pare[d][a]!=pare[d][b]){
                a=pare[d][a];
                b=pare[d][b];
            }
        }
        return pare[0][a];
    };
    while(Q--){
        int K;
        cin>>K;
        vector<int> v(K);
        rep(i,0,K) cin>>v[i],v[i]--;
        sort(all(v),[&](int l,int r){
            return dist_red[l]>dist_red[r];
        });
        v.push_back(0);
        ll ans=dist_red[v[0]];
        int root=-1;
        ll L=0;
        rep(i,0,K){
            int a=v[i];
            L=max(L,dist[a]);
            if(root==-1){
                root=a;
            }
            else root=lca(root,a);
            ans=min(ans,max(dist_red[v[i+1]],L-dist[root]));
        }
        cout<<ans<<"\n";
    }
}

int main(){
    int T;
    cin>>T;
    while(T--)solve();
}
/*

2
12 2 4
1 9
1 2 1
2 3 4
3 4 3
3 5 2
2 6 2
6 7 1
6 8 2
2 9 5
9 10 2
9 11 3
1 12 10
3 3 7 8
4 4 5 7 8
4 7 8 10 11
3 4 5 12
3 2 3
1 2
1 2 1
1 3 1
1 1
2 1 2
3 1 2 3
*/