#include<bits/stdc++.h>
using namespace std ;
typedef long long ll ;
typedef unsigned long long ull ;
typedef pair < int , int > pii ;
typedef vector < int > vi ;
#define fi first
#define se second
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());

#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()

const int MAXN = 1e5 + 7 ;
const int LOG = 20 ;
const ll inf = 1e18 ;

int n , m , q ;
vector < pii > v[ MAXN ] ;
bool spec[ MAXN ] ;
int st[ MAXN ] , en[ MAXN ] , tp ;
ll pref[ MAXN ] ;
int lvl[ MAXN ] , LCA[ MAXN ][ LOG ] ;
int anc[ MAXN ] ;

void dfs ( int x , int prv , int lst ) {
    st[ x ] = ++ tp ;
    anc[ x ] = lst ;
    for ( int i = 1 ; i < LOG ; ++ i ) {
        LCA[ x ][ i ] = LCA[ LCA[ x ][ i - 1 ] ][ i - 1 ] ;
    }
    for ( auto [ y , len ] : v[ x ] ) {
        if ( y == prv ) { continue ; }
        pref[ y ] = pref[ x ] + len ; 
        lvl[ y ] = lvl[ x ] + 1 ;
        LCA[ y ][ 0 ] = x ;
        if ( spec[ y ] == true ) { dfs ( y , x , y ) ; }
        else { dfs ( y , x , lst ) ; }
    }
    en[ x ] = tp ;
}

int get_lca ( int x , int y ) {
    for ( int i = LOG - 1 ; i >= 0 ; -- i ) {
        if ( lvl[ x ] - ( 1 << i ) >= lvl[ y ] ) {
            x = LCA[ x ][ i ] ;
        }
        if ( lvl[ y ] - ( 1 << i ) >= lvl[ x ] ) {
            y = LCA[ y ][ i ] ;
        }
    }
    for ( int i = LOG - 1 ; i >= 0 ; -- i ) {
        if ( LCA[ x ][ i ] != LCA[ y ][ i ] ) {
            x = LCA[ x ][ i ] , y = LCA[ y ][ i ] ;
        }
    }
    if ( x != y ) { x = LCA[ x ][ 0 ] ; }
    return x ;
}

class Tree {
public :
    ll mx_ans[ 4 * MAXN ] , mx_pref[ 4 * MAXN ] ;
    void init ( int w , int l , int r ) {
        mx_ans[ w ] = mx_pref[ w ] ;
        if ( l == r ) { return ; }
        int mid = ( l + r ) / 2 ;
        init ( 2 * w , l , mid ) ;
        init ( 2 * w + 1 , mid + 1 , r ) ;
    }
    void update ( int w , int l , int r , int pos , ll nw_ans , ll nw_pref ) {
        if ( l == r ) {
            if ( nw_ans < 0 ) { mx_ans[ w ] = mx_pref[ w ] = 0 ; }
            else { mx_ans[ w ] = nw_ans , mx_pref[ w ] = nw_pref ; }
            return ;
        }
        int mid = ( l + r ) / 2 ;
        if ( pos <= mid ) { update ( 2 * w , l , mid , pos , nw_ans , nw_pref ) ; }
        else { update ( 2 * w + 1 , mid + 1 , r , pos , nw_ans , nw_pref ) ; }
        mx_ans[ w ] = max ( mx_ans[ 2 * w ] , mx_ans[ 2 * w + 1 ] ) ;
        mx_pref[ w ] = max ( mx_pref[ 2 * w ] , mx_pref[ 2 * w + 1 ] ) ;
    }
    ll qret ;
    void query_ans_rec ( int w , int l , int r , int st , int en ) {
        if ( mx_ans[ w ] == 0 ) { return ; }
        if ( l > r || st > en ) { return ; }
        if ( r < st || en < l ) { return ; }
        if ( st <= l && r <= en ) {
            qret = max ( qret , mx_ans[ w ] ) ;
            return ;
        }
        int mid = ( l + r ) / 2 ;
        query_ans_rec ( 2 * w , l , mid , st , en ) ;
        query_ans_rec ( 2 * w + 1 , mid + 1 , r , st , en ) ;
    }
    void query_pref_rec ( int w , int l , int r , int st , int en ) {
        if ( mx_pref[ w ] == 0 ) { return ; }
        if ( l > r || st > en ) { return ; }
        if ( r < st || en < l ) { return ; }
        if ( st <= l && r <= en ) {
            qret = max ( qret , mx_pref[ w ] ) ;
            return ;
        }
        int mid = ( l + r ) / 2 ;
        query_pref_rec ( 2 * w , l , mid , st , en ) ;
        query_pref_rec ( 2 * w + 1 , mid + 1 , r , st , en ) ;
    }
    ll query_ans ( int w , int l , int r , int st , int en ) {
        qret = 0 ;
        query_ans_rec ( w , l , r , st , en ) ;
        return qret ;
    }
    ll query_pref ( int w , int l , int r , int st , int en ) {
        qret = 0 ;
        query_pref_rec ( w , l , r , st , en ) ;
        return qret ;        
    }
};
Tree w ;


int k ;
int vals[ MAXN ] ;
int pos[ MAXN ] , neg[ MAXN ] , cands[ 2 * MAXN ] ;

void solve ( ) {
    cin >> n >> m >> q ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        v[ i ].clear ( ) ;
        spec[ i ] = false ;
    }
    for ( int i = 1 , x ; i <= m ; ++ i ) {
        cin >> x ;
        spec[ x ] = true ;
    }
    for ( int i = 1 , x , y , z ; i < n ; ++ i ) {
        cin >> x >> y >> z ;
        v[ x ].push_back ( { y , z } ) ;
        v[ y ].push_back ( { x , z } ) ;
    }
    tp = 0 ; 
    dfs ( 1 , -1 , 1 ) ;
    w.init ( 1 , 1 , n ) ;
    auto cmp_ord = [ & ] ( int x , int y ) {
        return ( st[ x ] < st[ y ] ) ;
    };
    auto cmp_lvl = [ & ] ( int x , int y ) {
        return ( lvl[ x ] > lvl[ y ] ) ;
    };
    auto cmp_anc_lvl = [ & ] ( int x , int y ) {
        return ( lvl[ anc[ x ] ] > lvl[ anc[ y ] ] ) ;
    };
    while ( q -- ) {
        cin >> k ;
        map < ll , int > aux ;
        for ( int i = 1 ; i <= k ; ++ i ) {
            cin >> vals[ i ] ;
            pos[ i ] = neg[ i ] = vals[ i ] ;
            cands[ i ] = vals[ i ] ;
            aux[ pref[ vals[ i ] ] - pref[ anc[ vals[ i ] ] ] ] ++ ;
        }
        sort ( vals + 1 , vals + k + 1 , cmp_ord ) ;
        sort ( pos + 1 , pos + k + 1 , cmp_lvl ) ;
        sort ( neg + 1 , neg + k + 1 , cmp_anc_lvl ) ;

        for ( int i = 0 ; i + 1 < k ; ++ i ) {
            cands[ k + i + 1 ] = get_lca ( vals[ i + 1 ] , vals[ i + 2 ] ) ;
        }
        sort ( cands + 1 , cands + 2 * k - 1 + 1 , cmp_lvl ) ;
        int tp_vert = 0 , tp_anc = 0 ;
        ll ans = inf ;
        for ( int ctr = 1 ; ctr <= 2 * k - 1 ; ++ ctr ) {
            int x = cands[ ctr ] ;
            while ( tp_vert < k && lvl[ pos[ tp_vert + 1 ] ] >= lvl[ x ] ) {
                int y = pos[ ++ tp_vert ] , sr = pref[ y ] - pref[ anc[ y ] ] ;
                -- aux[ sr ] ;
                if ( aux[ sr ] == 0 ) { aux.erase ( sr ) ; }
                w.update ( 1 , 1 , n , st[ y ] , pref[ y ] - pref[ anc[ y ] ] , pref[ y ] ) ;
            }
            while ( tp_anc < k && lvl[ anc[ neg[ tp_anc + 1 ] ] ] >= lvl[ x ] ) {
                int y = neg[ ++ tp_anc ] , sr = pref[ y ] - pref[ anc[ y ] ] ;
                ++ aux[ sr ] ;
                w.update ( 1 , 1 , n , st[ y ] , -1 , -1 ) ;
            }
            ll cand = 0 ;
            if ( aux.empty ( ) == false ) { cand = (*aux.rbegin ( )).fi ; }
            cand = max ( { cand , w.query_ans ( 1 , 1 , n , 1 , st[ x ] - 1 ) , w.query_ans ( 1 , 1 , n , en[ x ] + 1 , n ) } ) ;
            cand = max ( cand , w.query_pref ( 1 , 1 , n , st[ x ] , en[ x ] ) - pref[ x ] ) ;
            // printf ( "%d --> %lld\n" , x , cand ) ;
            ans = min ( ans , cand ) ;
        }
        while ( tp_anc < k ) {
            int y = neg[ ++ tp_anc ] , sr = pref[ y ] - pref[ anc[ y ] ] ;
            w.update ( 1 , 1 , n , st[ y ] , -1 , -1 ) ;
        }
        cout << ans << "\n" ;
    }
}

int main ( ) {
    ios_base :: sync_with_stdio ( false ) ;
    cin.tie ( NULL ) ;
    int t = 1 ; cin >> t ; 
    while ( t -- ) { solve ( ) ; }
    return 0 ;
}