/*
 * Code by Spiromanul
 */

# include "fstream"
# include "cstring"
# include "vector"
# include "queue"
# include "bitset"
# include "deque"

const char IN [ ] = "team.in" ;
const char OUT [ ] = "team.out" ;
const int MAX = 675 ;
const int MOD = 666013 ;

# define pb push_back
# define mp make_pair
# define FORN( a , b , c ) for ( int a = b ; a <= c ; ++ a )
# define FORNBACK( a , b , c ) for ( int a = b ; a >= c ; -- a )

using namespace std;

ifstream fin ( IN ) ;
ofstream fout ( OUT ) ;

typedef pair < int , int > P ;

class cmp {
public :
    bool operator ( ) ( const P &a , const P &b ) const
    {
        return a.second > b.second ;
    }
};

priority_queue < P , vector < P > , cmp > H ;

int dist [ MAX ] [ MAX ] , n , home [ MAX / 10 ] , p ;

vector < P > gr [ MAX ] ;

int dp [ MAX / 10 ] [ MAX / 10 ] [ MAX / 10 ] ;

void dijkstra ( int nod , int *r )
{
    H.push ( mp ( nod , 0 ) ) ;
    FORN ( i , 1 , n )
        r [ i ] = 0x3f3f3f3f ;
    r [ nod ] = 0 ;
    while ( !H.empty ( ) )
    {
        int fata = H.top ( ).first ;
        int cost = H.top ( ).second ;
        H.pop ( ) ;
        for ( auto x : gr [ fata ] )
            if ( cost + x.second < r [ x.first ] )
            {
                r [ x.first ] = cost + x.second ;
                H.push ( mp ( x.first , r [ x.first ] ) ) ;
            }
    }
}

inline void why_RF_when_we_have_Dijkstra ( )
{
    FORN ( i , 1 , p )
        dijkstra ( home [ i ] , dist [ i ] ) ;
}

/// dp [ i ] [ j ] [ k ] = rezolvam copii i...j, si l lasam acasa pe k
/// dp [ i ] [ j ] [ k ] = min ( dp [ i ] [ k - 1 ] [ u ] + cost [ u ] [ home [ k ] ] )
                      ///+ min ( dp [ k + 1 ] [ j ] [ w ] + cost [ w ] [ home [ k ] ] )

/// sol e dp [ 1 ] [ p ] [ i ] + cost [ i ][ 1 ]

inline void relax ( int &a , int b )
{
    if ( a > b )
        a = b ;
}

inline void dynamic_programming ( int p , int n )
{
    FORN ( lungime , 2 , p )
    {
        FORN ( st , 1 , p )
        {
            int dr = st + lungime - 1 ;
            if ( dr > p )
                break ;
            FORN ( k , st , dr )
            {
                int MINU = 0x3f3f3f3f ;
                int MINW = 0x3f3f3f3f ;
                FORN ( U , st , k - 1 )
                    relax ( MINU , dp [ st ] [ k - 1 ] [ U ] + dist [ U ] [ home [ k ] ] ) ;
                FORN ( W , k + 1 , dr )
                    relax ( MINW , dp [ k + 1 ] [ dr ] [ W ] + dist [ W ] [ home [ k ] ] ) ;
                if ( MINU == 0x3f3f3f3f )
                    MINU = 0 ;
                if ( MINW == 0x3f3f3f3f )
                    MINW = 0 ;
                dp [ st ] [ dr ] [ k ] = MINW + MINU ;
            }
        }
    }
    int CET = 0x3f3f3f3f ;
    FORN ( i , 1 , p )
        relax ( CET , dp [ 1 ] [ p ] [ i ] + dist [ i ] [ 1 ] ) ;

    fout << CET << '\n' ;
}

int main ( void )
{
    int m ;
    fin >> p >> n >> m ;
    FORN ( i , 1 , m )
    {
        int x , y , cost ;
        fin >> x >> y >> cost ;
        gr [ x ].pb ( mp ( y , cost ) ) ;
        gr [ y ].pb ( mp ( x , cost ) ) ;
    }
    FORN ( i , 1 , p )
        fin >> home [ i ] ;
    why_RF_when_we_have_Dijkstra ( ) ;
    dynamic_programming ( p , n ) ;
    return 0;
}