#include <bits/stdc++.h>

#define pb push_back
#define mp make_pair
#define mt make_tuple
#define ll long long
#define pii pair<int,int>
#define tii tuple <int,int,int>
#define N 2005
#define oo 1000000005
#define X first
#define Y second
#define eps 0.0000000001
#define all(x) x.begin(),x.end()
#define tot(x) x+1,x+n+1

using namespace std;

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

int n, m, i, j, k, l, kk, r[20], x, y, z, dijk[N][N], nod, dp[20][65537], sol = oo;
vector<pii>v[N];
priority_queue<pii, vector<pii>, greater<pii>>q;

int main() {
    fin >> n >> m >> k;

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

    for(; m; m--) {
        fin >> x >> y >> z;
        v[x].pb(mp(y, z));
        v[y].pb(mp(x, z));
    }

    for(j = 1; j <= n; j++)
        dijk[1][j] = oo;

    q.push(mp(0, 1));
    dijk[1][1] = 0;

    while(q.size()) {
        nod = q.top().Y;
        q.pop();

        for(auto it : v[nod]) {
            if(dijk[1][it.X] > dijk[1][nod] + it.Y) {
                dijk[1][it.X] = dijk[1][nod] + it.Y;
                q.push(mp(dijk[1][it.X], it.X));
            }
        }
    }

    if(k == 0) {
        fout << dijk[1][n];
        return 0;
    }

    for(i = 1; i <= k; i++) {
        for(j = 1; j <= n; j++)
            dijk[r[i]][j] = oo;

        dijk[r[i]][r[i]] = 0;
        q.push(mp(0, r[i]));

        while(q.size()) {
            nod = q.top().Y;
            q.pop();

            for(auto it : v[nod]) {
                if(dijk[r[i]][it.X] > dijk[r[i]][nod] + it.Y) {
                    dijk[r[i]][it.X] = dijk[r[i]][nod] + it.Y;
                    q.push(mp(dijk[r[i]][it.X], it.X));
                }
            }
        }
    }

    kk = (1 << k);

    for(i = 1; i <= k; i++)
        for(j = 1; j <= kk; j++)
            dp[i][j] = oo;

    for(i = 1; i <= k; i++)
        dp[i][(1 << (i - 1))] = dijk[1][r[i]];

    for(j = 1; j < kk; j++)
        for(i = 1; i <= k; i++)
            if((j & (1 << (i - 1))))
                for(l = 1; l <= k; l++)
                    if((j & (1 << (l - 1))) && i != l)
                        dp[i][j] = min(dp[i][j], dp[l][j - (1 << (i - 1))] + dijk[r[l]][r[i]]);

    kk--;

    for(i = 1; i <= k; i++)
        sol = min(sol, dp[i][kk] + dijk[r[i]][n]);

    fout << sol;
    return 0;
}