#include <cstdio>
#include <cstring>

#include <algorithm>
#include <map>
#include <queue>
#include <set>
#include <vector>

using namespace std;

priority_queue<pair<int, int>, vector<pair<int, int> >, 
    greater<pair<int, int> > > pq;

const int INF = 0x3f3f3f3f;
const int MAXN = 2001;
const int MAXK = 16;

bool vis[MAXN];
map<int, vector<int> > dist;

int N, C;
vector<int> G[MAXN];
vector<int> Cst[MAXN];
vector<int> ubun;

map<int, vector<int> > dp;

void dijkstra(int s)
{
    memset(vis, false, sizeof(vis));

    for (int i = 1; i <= N; ++i)
        dist[s][i] = INF;

    pq.push(make_pair(0, s));
    dist[s][s] = 0;
    while (!pq.empty()) {
        int node = pq.top().second;
        int cost = pq.top().first;
        pq.pop();
        
        if (vis[node])
            continue;
        vis[node] = true;

        for (int i = 0; i < G[node].size(); ++i) {
            int next = G[node][i];
            if (cost + Cst[node][i] < dist[s][next]) {
                dist[s][next] = cost + Cst[node][i];
                pq.push(make_pair(dist[s][next], next));
            }
        }
    }
}

int doit(int i, int s)
{
    if (i != N)
        s ^= (1 << i);

    if (s == 0)
        return dist[1][ubun[i]];

    if (i < C && dp[i][s] != -1)
        return dp[i][s];

    int best_sum = INF;
    for (int j = 0; j < C; ++j) {
        if ((s & (1 << j)) != 0) {
            if (i != N)
                best_sum = min(best_sum, doit(j, s) + dist[ubun[i]][ubun[j]]);
            else
                best_sum = min(best_sum, doit(j, s) + dist[N][ubun[j]]);
        }
    }

    if (i < C)
        dp[i][s] = best_sum;
    return best_sum;
}

int main()
{
    freopen("ubuntzei.in", "r", stdin);
    freopen("ubuntzei.out", "w", stdout);

    int M;
    scanf("%d %d", &N, &M);

    scanf("%d", &C);
    for (int i = 0; i < C; ++i) {
        int x;
        scanf("%d", &x);
        ubun.push_back(x);
        dist[x] = vector<int>(N + 1);
        dp[i] = vector<int>((1 << (C + 1)), -1);
    }
    dist[1] = vector<int>(N + 1);
    dist[N] = vector<int>(N + 1);

    for (int i = 0; i < M; ++i) {
        int x, y, c;
        scanf("%d %d %d", &x, &y, &c);
        G[x].push_back(y);
        Cst[x].push_back(c);
        G[y].push_back(x);
        Cst[y].push_back(c);
    }

    dijkstra(1);
    dijkstra(N);
    for (int i = 0; i < C; ++i) 
        dijkstra(ubun[i]);

    printf("%d\n", doit(N, (1 << C) - 1));

    return 0;
}