#include <bits/stdc++.h>

using namespace std;
ifstream fin("ubuntzei.in");
ofstream fout("ubuntzei.out");
int d[2005];
vector < pair <int, int> > G[2005];
set < pair <int, int> > s;
int c[15][15];
int ub[15];
long long dp[(1 << 15)][15];
int n,k;
bitset <2005> viz;
void dijkstra(int e){
    viz.reset();
    int start = ub[e];
    memset(d, 0x3f, sizeof d);
    s.clear();
    s.insert({0, start});
    d[start] = 0;
    while(!s.empty()){
        auto it = s.begin();
        int nod = it->second;
        s.erase(it);
        if(viz[nod]) continue;
        viz[nod] = 1;
        for(auto x : G[nod]){
            if(d[nod] + x.first < d[x.second]){
                d[x.second] = d[nod] + x.first;
                s.insert({d[x.second], x.second});
            }
        }
    }
    for(int i = 0; i < k; i++){
        if(i == e) continue;
        c[e][i] = min(c[e][i], d[i]);
        c[i][e] = min(c[i][e], d[i]);
    }
}
void dijkstra_2(int start){
    viz.reset();
    memset(d, 0x3f, sizeof d);
    s.clear();
    s.insert({0, start});
    d[start] = 0;
    while(!s.empty()){
        auto it = s.begin();
        int nod = it->second;
        s.erase(it);
        if(viz[nod]) continue;
        viz[nod] = 1;
        for(auto x : G[nod]){
            if(d[nod] + x.first < d[x.second]){
                d[x.second] = d[nod] + x.first;
                s.insert({d[x.second], x.second});
            }
        }
    }
}
int main()
{
    int i,m,u,v,e,j;
    fin >> n >> m;
    fin >> k;
    for(i = 0; i < k; i++) fin >> ub[i];
    for(i = 1; i <= m; i++){
        fin >> u >> v >> e;
        G[u].push_back({e,v});
        G[v].push_back({e,u});
    }
    memset(dp, 0x3f, sizeof dp);
    memset(c, 0x3f, sizeof c);
    for(i = 0; i < k; i++)
        dijkstra(i);
    dijkstra_2(1);
    if(!k){
        fout << d[n];
        return 0;
    }
    for(i = 0; i < k; i++){
        dp[(1 << i)][i] = d[ub[i]];
    }
    for(int k2 = 1; k2 < (1 << k); k2++){
        for(i = 0; i < k; i++) if(k2 & (1 << i)){
            for(j = 0; j < k; j++) if(j != i && (1 << j) & k2){
                dp[k2][i] = min(dp[k2][i], dp[k2 ^ (1 << i)][j] + c[j][i]);
            }
        }
    }
    dijkstra_2(n);
    long long rez = 2000000000000000;
    for(i = 0; i < k; i++){
        rez = min(rez, dp[(1 << k) - 1][i] + d[ub[i]]);
    }
    fout << rez;
    return 0;
}