#include <bits/stdc++.h>

using namespace std;

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

const int maxN = 2e3 + 5;
const int INF = 1e9;

vector <pair<int,int>> g[maxN];

int v[20], D[maxN][maxN], dp[100000][20];
int dist[maxN];

void dijkstra (int root, int n) {
    for(int i = 1; i <= n; ++i)
        dist[i] = INF;

    dist[root] = 0;
    set<pair<int,int>> s;
    s.insert({0, root});

    while(s.size()) {
        pair <int,int> x = *(s.begin());
        s.erase(s.begin());

        int node = x.second;
        int distNode = x.first;
        if(distNode > dist[node]) {
            continue;
        }

        for(auto to : g[node]) {
            int next = to.first;
            int cost = to.second;
            if(dist[next] > distNode + cost) {
                dist[next] = distNode + cost;
                s.insert({dist[next], next});
            }
        }
    }

    for(int i = 1; i <= n; ++i)
        D[root][i] = dist[i];
}

int main() {

    int n, m; fin >> n >> m;

    int k; fin >> k;

    for(int i = 0; i < k; ++i)
        fin >> v[i];

    for(int i = 1; i <= m; ++i) {
        int u, v, cost; fin >> u >> v >> cost;

        g[u].push_back({v, cost});
        g[v].push_back({u, cost});

    }

    for(int i = 1; i <= n; ++i)
        dijkstra(i, n);

//    for(int mask = 0; mask < (1 << k); ++mask)
//        for(int i = 0; i < k; ++i)
//            dp[mask][i] = INF;

    for(int i = 0; i < k; ++i)
        dp[1 << i][i] = D[1][v[i]];

    for(int mask = 0; mask < (1 << k); ++mask)
        for(int u = 0; u < k; ++u)
            if(mask & (1 << u)) {
                if((mask ^ (1 << u)) != 0)
                    dp[mask][u] = INF;
                for(int x = 0; x < k; ++x)
                    if((mask & (1 << x)) && u != x) {
                        dp[mask][u] = min(dp[mask][u], dp[(mask ^ (1 << u))][x] + D[v[x]][v[u]]);
                    }
            }


    int minim = INF, ind;
    for(int i = 0; i < k; ++i)
        if(minim > dp[(1 << k)-1][i] + D[v[i]][n])
            minim = dp[(1 << k)-1][i] + D[v[i]][n];

    if(minim == INF)
        fout << D[1][n];
    else
        fout << minim;

    return 0;
}