#include<fstream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
#define abs(x) ((x>0)?(x):(-(x)))
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))
using namespace std;
ifstream in("ubuntzei.in");
ofstream out("ubuntzei.out");
const int Nmax = 2001;
const int INF = 0x3f3f3f3f;
vector<int> G[Nmax],C[Nmax];
struct state{
    int node,cost;
    state(){}
    state(int _x,int _y){node=_x,cost=_y;}
};
struct cmp{
    inline bool operator () (const state &a,const state &b) const {
        return a.cost > b.cost;
    }
};
priority_queue<state,vector<state>,cmp> q;
int f[18],D[18][1<<18];
int dk[Nmax],d[18][18];
int N,M,K;
int main(){
    in>>N>>M>>K;
    for(int i=1;i<=K;i++) in>>f[i];
    f[++K]=1,f[++K]=N;
    sort(f+1,f+K+1);
    for(int i=1;i<=M;i++){
        int x,y,c;
        in>>x>>y>>c;
        G[x].push_back(y);
        G[y].push_back(x);
        C[x].push_back(c);
        C[y].push_back(c);
    }
    for(int i=1;i<=K;i++){
        memset(dk,INF,sizeof(dk));
        dk[f[i]]=0;
        q.push(state(f[i],0));
        while(!q.empty()){
            state p=q.top(); q.pop();
            for(int i=0;i<G[p.node].size();i++){
                if( C[p.node][i] + p.cost < dk[G[p.node][i]] ){
                    dk[G[p.node][i]]=C[p.node][i] + p.cost;
                    q.push(state(G[p.node][i],dk[G[p.node][i]]));
                }
            }
        }
        for(int j=1;j<=K;j++) d[i][j]=dk[f[j]];
    }
    memset(D,INF,sizeof(D));
    D[1][1]=0;
    for(int p=0;p<(1<<K);p++){
        for(int k=0;k<K;k++) if((1<<k)&p){
            int prev=p^(1<<k);
            for(int j=0;j<K;j++) if(((1<<j)&prev)){
                D[k+1][p]=min( D[k+1][p] , D[j+1][prev] + d[k+1][j+1] );
            }
        }
    }
    out<<D[K][(1<<K)-1]<<'\n';
    return 0;
}