#include<fstream>
#include<queue>
#include<unordered_map>

using namespace std;
typedef int64_t var;

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


#define INF (1LL<<55)
#define MAXK 19
#define MAXN 2001

var n, k;
var INTERES[MAXK];

struct Edge {
    var n, c;
    Edge(var a, var b) {
        n = a;
        c = b;
    }
};
vector<Edge> G[MAXN], Gr[MAXN];

var D[MAXN];
bool INQ[MAXN];
queue<var> Q;
void bellman(var start) {
    for(var i=1; i<=n; i++) {
        D[i] = INF;
        INQ[i] = 0;
    }
    D[start] = 0;
    Q.push(start);

    while(!Q.empty()) {
        var node = Q.front();
        Q.pop();
        INQ[node] = 0;
        for(auto e : G[node]) {
            if(D[e.n] > D[node] + e.c) {
                D[e.n] = D[node] + e.c;
                if(!INQ[e.n])
                    Q.push(e.n);
                INQ[e.n] = 1;
            }
        }
    }
}


var SOL[(1<<MAXK)][MAXK];
bool COMP[(1<<MAXK)][MAXK];

var sol(var conf, var last) {
    if(COMP[conf][last])
        return SOL[conf][last];

    SOL[conf][last] = INF;
    for(auto e : Gr[last]) {
        var vec = e.n, cost = e.c;
        if(conf & (1 << (vec-1)))
            SOL[conf][last] = min(SOL[conf][last], sol(conf ^ (1<<(last-1)), vec) + e.c);
    }
    COMP[conf][last] = 1;
    return SOL[conf][last];
}



int main() {
    var m, a, b, c;
    fin>>n>>m>>k;

    INTERES[1] = 1;
    k++;
    for(var i=2; i<=k; i++) {
        fin>>INTERES[i];
    }
    INTERES[++k] = n;

    while(m--) {
        fin>>a>>b>>c;
        G[a].push_back(Edge(b, c));
        G[b].push_back(Edge(a, c));
    }

    for(var i=1; i<=k; i++) {
        bellman(INTERES[i]);
        for(var j=1; j<=k; j++) {
            if(j == i) continue;
            Gr[i].push_back(Edge(j, D[INTERES[j]]));
        }
    }

    COMP[1][1] = 1;
    fout<<sol((1<<k)-1, k);
}