#pragma GCC optimize ("O2")

#include <fstream>
#include <set>
#include <vector>

using namespace std;

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

const int MAXN = 2001;
const int MAXK = 16;

struct Edge {
    int to, weight;
};

int n, m, k, fr[MAXK], dd[MAXK][MAXK], dp[MAXK][1 << (MAXK - 1)];
vector<Edge> g[MAXN];

void read() {
    fin >> n >> m >> k;
    for(int i = 1; i <= k; ++i)
        fin >> fr[i];
    for(int i = 1, x, y, w; i <= m; ++i) {
        fin >> x >> y >> w;
        g[x].push_back({y, w});
        g[y].push_back({x, w});
    }
}

int dist(int A, int B) {
    vector<int> d(MAXN, 1e9);
    d[A] = 0;
    set<pair<int, int>> s;
    s.insert({0, A});
    while(!s.empty()) {
        int node = s.begin()->second;
        int dist = s.begin()->first;
        s.erase(s.begin());
        for(auto k : g[node])
            if(d[k.to] > dist + k.weight) {
                if(d[k.to] != 1e9)
                    s.erase(s.find({d[k.to], k.to}));
                d[k.to] = dist + k.weight;
                s.insert({d[k.to], k.to});
            }
    }
    return d[B];
}

int main() {
    ios::sync_with_stdio(0);
    fin.tie(0);
    fout.tie(0);

    read();

    for(int i = 1; i <= k; ++i)
        for(int j = 1; j <= k; ++j) {
            int d = dist(fr[i], fr[j]);
            dd[i][j] = dd[j][i] = d;
        }


    if(k == 0) {
        fout << dist(1, n);
        return 0;
    }

    for(int i = 0; i < k; ++i)
        dp[i + 1][1 << i] = dist(1, fr[i + 1]);

    for(int i = 1; i < (1 << k); ++i)
        for(int x = 0; x < k; ++x)
            if((i & (1 << x)))
                for(int j = 0; j < k; ++j)
                    if(i & (1 << j) && x != j) {
                        int old = (i ^ (1 << j));
                        if(dp[j + 1][i] == 0) dp[j + 1][i] = 1e9;
                        dp[j + 1][i] = min(dp[j + 1][i], dp[x + 1][old] + dd[x + 1][j + 1]);
                    }

    int sol = 1e9;

    for(int i = 1; i <= k; ++i) {
        if(dp[i][(1 << k) - 1] == 0) dp[i][(1 << k) - 1] = 1e9;
        sol = min(sol, dp[i][(1 << k) - 1] + dist(fr[i], n));
    }

    fout << sol;

    return 0;
}