#include <iostream>
#include <fstream>
#include <vector>
#include <queue>

using namespace std;

const int Nmax = 2001;
const int Kmax = 20;
const int inf = 1000000000;

vector < pair<int,int> > G[Nmax];
priority_queue <pair <int, int>, vector <pair <int, int> >, greater <pair <int, int> > > Heap;
int dist[Nmax], v[Kmax];
int dp[1 << Kmax][Kmax], A[Kmax][Kmax];

int N, M, K;

void Dijkstra()
{
    while ( Heap.size() )
    {
        int nod = Heap.top().second;
        int cost = Heap.top().first;

        Heap.pop();

        ///if ( dist[nod] != cost ) continue;

        for ( auto x: G[nod] )
        {
            if ( dist[x.first] > dist[nod] + x.second )
            {
                dist[x.first] = dist[nod] + x.second;
                Heap.push( make_pair( dist[x.first], x.first ) );
            }
        }
    }
}

void compute_dist()
{
    for ( int j = 1; j <= N; ++j )
                dist[j] = inf;

    for ( int i = 0; i < K; ++i )
    {
        Heap.push( make_pair( 0, v[i] ) );

        dist[ v[i] ] = 0;

        Dijkstra();

        A[0][i + 1] = A[i + 1][0] = dist[1];

        for ( int j = 0; j < i; ++j )
                A[i + 1][j + 1] = A[j + 1][i + 1] = dist[ v[j] ];

        A[K + 1][i + 1] = A[i + 1][K + 1] = dist[N];

        for ( int j = 1; j <= N; ++j )
                dist[j] = inf;
    }
}

int memo( int state, int nod )
{
    if ( state && !nod )
            return inf;

    if ( dp[state][nod] != inf )
            return dp[state][nod];

    int sol = inf;

    for ( int i = 0, j = 1; j <= state; i++, j <<= 1 )
            if ( state & j )
                    sol = min( sol, memo( state ^ j, i ) + A[nod][i] );

    return dp[state][nod] = sol;
}

int DP()
{
    for ( int i = 0; i < ( 1 << K + 1 ); ++i )
            for ( int j = 0; j <= K + 1; ++j )
                    dp[i][j] = inf;

    dp[0][0] = 0;

    return memo( ( 1 << ( K + 1 ) ) - 1, K + 1 );
}

int main()
{
    ifstream f("ubuntzei.in");
    ofstream g("ubuntzei.out");

    f >> N >> M >> K;

    for ( int i = 0; i < K; ++i )
    {
        f >> v[i];
    }

    for ( int i = 1, a, b, c; i <= M; ++i )
    {
        f >> a >> b >> c;

        G[a].push_back( make_pair( b, c ) );
        G[b].push_back( make_pair( a, c ) );
    }

    if ( K == 0 )
    {
        Heap.push( make_pair( 0, 1 ) );
        dist[1] = 0;
        Dijkstra();
        g << dist[N] << "\n";
        return 0;
    }

    compute_dist();
    g << DP();

    return 0;
}