#include <fstream>
#include <queue>

using namespace std;

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

typedef long long i64;

const int nmax= 2000;
const int kmax= 15;
const int inf= 1<<30;
const i64 i64inf= ((i64)1<<60);

int n, m, k;
int ub[kmax], d[kmax+1][nmax+1];
i64 a[1<<(kmax+1)][kmax+1];

/*struct str {
    int x, y;
};

struct str_cmp {
    bool operator () ( const str &x, const str &y ) {
        return x.y<y.y;
    }
};*/

#define mp make_pair
#define x first
#define y second

typedef pair <int, int> str;

priority_queue <str, vector <str>, greater <str> > q;

vector <str> g[nmax+1];

/*inline str mp( int x, int y ) {
    str sol;
    sol.x= x, sol.y= y;

    return sol;
}*/

void dijkstra( int x, int nr ) {
    for ( int i= 1; i<=n; ++i ) {
        d[nr][i]= inf;
    }
    d[nr][x]= 0;

    for ( q.push(mp(x, 0)); !q.empty(); ) {
        int y;
        x= (q.top()).x, y= (q.top()).y;
        q.pop();

        for ( vector <str>::iterator it= g[x].begin(); it!=g[x].end() && d[nr][x]==y; ++it ) {
            if ( d[nr][x]+(*it).y<d[nr][(*it).x] ) {
                d[nr][(*it).x]= d[nr][x]+(*it).y;
                q.push(mp((*it).x, d[nr][(*it).x]));
            }
        }
    }
}

int main(  ) {
    fin>>n>>m>>k;
    for ( int i= 0; i<=k-1; ++i ) {
        fin>>ub[i];
    }
    for ( int i= 1, x, y, z; i<=m; ++i ) {
        fin>>x>>y>>z;
        g[x].push_back(mp(y, z));
        g[y].push_back(mp(x, z));
    }

    dijkstra(1, kmax);
    if ( k==0 ) {
        fout<<d[kmax][n]<<"\n";
        return 0;
    }

    for ( int i= 0; i<=k-1; ++i ) {
        dijkstra(ub[i], i);
    }

    for ( int i= 0; i<=(1<<k)-1; ++i ) {
        for ( int j= 0; j<=k-1; ++j ) {
            a[i][j]= i64inf;
        }
    }
    for ( int i= 0; i<=k-1; ++i ) {
        a[(1<<i)][i]= d[kmax][ub[i]];
    }

    for ( int i= 1; i<=(1<<k)-1; ++i ) {
        for ( int j1= 0; j1<=k-1; ++j1 ) {
            if ( (i&(1<<j1))>0 ) {
                for ( int j2= 0; j2<=k-1; ++j2 ) {
                    if ( (i&(1<<j2))==0 ) {
                        a[i+(1<<j2)][j2]= min(a[i+(1<<j2)][j2], (i64)a[i][j1]+d[j1][ub[j2]]);
                    }
                }
            }
        }
    }

    i64 sol= i64inf;
    for ( int i= 0; i<=k-1; ++i ) {
        sol= min(sol, a[(1<<k)-1][i]+d[i][n]);
    }

    fout<<sol<<"\n";

    return 0;
}