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

using namespace std;

#define infinite 2 << 25

ifstream fin ( "ubuntzei.in" );
ofstream fout ( "ubuntzei.out" );

vector < pair<int, int> > edge[2005];

int n, m, k, C[16], drMin[2005][2005], sol;

int sNod;
struct compare {

    bool operator() ( int nod1, int nod2 ) {
        if ( drMin[ sNod ][nod1] > drMin[ sNod ][nod2] )
            return true;
        return false;
    }
};

priority_queue <int, vector<int>, compare> heap;

void dijkstra () {

    heap.push( sNod );
    drMin[ sNod ][ sNod ] = 0;

    while ( !heap.empty() ) {

        int nod = heap.top();
        heap.pop();

        for ( unsigned int l = 0; l < edge[nod].size() ; ++l ) {
            int cost = edge[nod][l].second;
            int node = edge[nod][l].first;

            if ( drMin[ sNod ][ nod ] + cost < drMin[ sNod ][ node ] ) {
                drMin[ sNod ][node] = drMin[ sNod ][nod] + cost;
                heap.push( node );
            }
        }
    }
}

bool ap[2005]; int perm[16];
void checkUp() {

    int len = 0;
    for ( int i = 1; i <= k; i++ )
        len += drMin[ perm[i-1] ][ perm[i] ];
    len += drMin[ perm[k] ][n];

    if ( len < sol )
        sol = len;
}

void bruteForce ( int l ) {

    if ( l > k ) {
        checkUp();
        return;
    }

    for ( int i = 1; i <= k; i++ ) {
        if ( !ap[ C[i] ] ) {
            ap[ C[i] ] = true;
            perm[l] = C[i];
            bruteForce( l+1 );
            ap[ C[i] ] = false;
        }
    }
}

void init() {

    sol = infinite;
    perm[0] = 1;

    for ( int i = 1; i <= n; i++ ) {
        for ( int j = 1; j <= n; j++ )
            drMin[i][j] = infinite;
    }
}

void solve () {
    init();

    for ( int i = 1; i <= n; i++ ) {
        sNod = i;
        dijkstra();
    }

    bruteForce( 1 );
}

void read () {
    fin >> n >> m >> k;

    for ( int i = 1; i <= k; i++ )
        fin >> C[i];

    for ( int i = 1; i <= m; i++ ) {
        int x, y, c;
        fin >> x >> y >> c;
        edge[x].push_back( make_pair(y, c) );
        edge[y].push_back( make_pair(x, c) );
    }
}

int main()
{
    read ();
    solve();
    fout << sol;
    return 0;
}