#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,bitset<16>>
#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");
struct cmp {
    bool operator()(pair<int, bitset<16>> a, pair<int, bitset<16>> b) const {
        if(a.X == b.X)
            return a.Y.to_ulong() < b.Y.to_ulong();

        return a.X < b.X;
    }
};
struct cmp1 {
    bool operator()(pair < int, pair<int, bitset<16>>> a, pair < int, pair<int, bitset<16>>> b) const {
        return a.X > b.X;
    }
};
int n, m, i, x, z, y, nn, k, j, nod, vec, cost;
priority_queue<pair<int, pair<int, bitset<16>>>, vector<pair<int, pair<int, bitset<16>>>>,  cmp1>q;

unordered_map<int, int>r;
bitset<16>B, b, bb, bc;
vector < tuple<int, int, bitset<16>>> v[2016];
map<pair<int, bitset<16>>, int , cmp> d, inq;
vector<bitset<16>>vb;
int main() {
    fin >> n >> m >> k;

    for(i = 1; i <= k; i++) {
        fin >> x;
        r[x] = i ;
        B[r[x]] = 1;
    }

    for(; m; m--) {
        fin >> x >> y >> z;
        b = 0;

        if(B[r[x]])
            b[r[x]] = 1;

        v[x].pb(mt(y, z, b));
        b = 0;

        if(B[r[y]])
            b[r[y]] = 1;

        v[y].pb(mt(x, z, b));
    }

    nn = (1 << k);

    for(i = 0; i < nn; i++) {
        b = 0;
        x = i;
        j = 1;

        while(x) {
            b[j++] = x % 2;
            x /= 2;
        }

        vb.pb(b);
    }

    for(i = 1; i <= n; i++)
        for(j = 0; j < nn; j++)
            d[mp(i, vb[j])] = oo;

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

    while(q.size()) {
        nod = q.top().Y.X;
        b = q.top().Y.Y;
        q.pop();
        inq[mp(nod, b)] = 0;

        for(auto it : v[nod]) {
            tie(vec, cost, bb) = it;
            bc = 0;
            bc = (bb | b);

            if(d[mp(nod, b)] + cost < d[mp(vec, bc)]) {
                d[mp(vec, bc)] = d[mp(nod, b)] + cost;

                if(!inq[mp(vec, bc)]) {
                    inq[mp(vec, bc)] = 1;
                    q.push(mp(d[mp(vec, bc)], mp(vec, bc)));
                }
            }
        }
    }

    fout << d[mp(n, B)];
    return 0;
}