#include<stdio.h>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;

#define ITERATOR vector <NODE>::iterator
const int NMAX = 2010, KMAX = 20, CONF = 1 << 18, INF = 2e9;

struct NODE {
    int node, cost;

    NODE (int node = 0, int cost = 0) {
        this->node = node;
        this->cost = cost;
    }

    const bool operator < (const NODE &other) const{
        return cost > other.cost;
    }
};

vector <NODE> pre[NMAX], post[NMAX];
int n, k, dmin[NMAX], c[NMAX], d[KMAX][CONF], dist[KMAX][KMAX];
bool vis[NMAX];
priority_queue <NODE> heap;

void initDijkstra() {
    for(int i = 1; i <= n; ++ i) {
        dmin[i] = INF;
        vis[i] = 0;
    }
}

void initDinamica () {
    for(int i = 0; i <= k + 1; ++ i)
        for(int j = 0; j < (1 << (k + 2)); ++ j)
            d[i][j] = INF;
    d[0][0] = 0;
}

void updateDmin (int node) {
    for(ITERATOR it = pre[node].begin(); it != pre[node].end(); ++ it)
        if(dmin[node] + it->cost < dmin[it->node]) {
            dmin[it->node] = dmin[node] + it->cost;
            heap.push(NODE(it->node, dmin[it->node]));
        }
}

void dijkstra (int start, int ind) {
    ITERATOR it;
    int node, i;
    initDijkstra();

    dmin[start] = 0;
    updateDmin(start);
    while(!heap.empty()) {
        node = heap.top().node;
        heap.pop();
        if(vis[node])
            continue;

        updateDmin(node);
        vis[node] = 1;
    }

    for(i = 0; i <= k + 1; ++ i)
        dist[ind][i] = dist[i][ind] = dmin[c[i]];
}

void dinamica() {
    int node, conf, add;

    initDinamica();

    for(conf = 0; conf < (1 << k); ++ conf)
        for(node = 0; node <= k; ++ node)
            if(d[node][conf] != INF)
                for(add = 1; add <= k; ++ add)
                    if((conf & (1 << (add - 1))) == 0)
                        d[add][conf | (1 << (add - 1))] = min(d[add][conf | (1 << (add - 1))], d[node][conf] + dist[node][add]);
}

int main() {
    freopen("ubuntzei.in", "r", stdin);
    freopen("ubuntzei.out", "w", stdout);
    int m, i, x, y, cost;

    scanf("%d%d%d", &n, &m, &k);
    for(i = 1; i <= k; ++ i)
        scanf("%d", &c[i]);
    c[0] = 1;
    c[k + 1] = n;

    for(i = 1; i <= m; ++ i) {
        scanf("%d%d%d", &x, &y, &cost);

        pre[x].push_back(NODE(y, cost));
        pre[y].push_back(NODE(x, cost));
    }

    for(i = 0; i <= k + 1; ++ i)
        dijkstra(c[i], i);

    dinamica();

    cost = INF;
    for(i = 1; i <= k; ++ i)
        cost = min(cost, d[i][(1 << k) - 1] + dist[i][k + 1]);
    if(k == 0)
        cost = dist[0][1];
    printf("%d\n", cost);
    return 0;
}