#include <iostream>
#include <fstream>
#include <queue>
#include <cstring>
#define inf 0x3f3f3f3f
#define nmax 2001

using namespace std;

struct Nod {
    int nd;
    int cost;
    Nod *next;
};

Nod *G[nmax];

void addEdge(Nod *&ni,int nj,int cij) {

    Nod *p=new Nod;
    p->next=ni;
    p->nd=nj;
    p->cost=cij;
    ni=p;
}
void getData(Nod *G[nmax],int &n,int &m,int (&fr)[15],int &k) {
    int i,j,c,z;

    ifstream r("ubuntzei.in");
    r>>n>>m;

    r>>k;
    for (z=1;z<=k;z++)
        r>>fr[z];

    for (z=1;z<=m;z++) {
        r>>i>>j>>c;
            addEdge(G[i],j,c);
            addEdge(G[j],i,c);
    }
    r.close();
}

void doBellmanFord(Nod *G[nmax],int (&dmin)[nmax],int n,int source) {
    queue <int> Q;
    bool viz[nmax];

    memset(viz,false,sizeof(viz));
    memset(dmin,inf,sizeof(dmin));

    Q.push(source);
    dmin[source]=0;
    viz[source]=true;
    while (!Q.empty()) {
        int prec=Q.front();
        Q.pop();
        Nod *p=new Nod;
        viz[prec]=false;
        p=G[prec];
        while (p) {
            if (dmin[prec]+p->cost<dmin[p->nd]) {
                dmin[p->nd]=dmin[prec]+p->cost;
                if (!viz[p->nd]) {
                    viz[p->nd]=true;
                    Q.push(p->nd);
                }
            }
            p=p->next;
        }
    }
}

void printCost(int x) {

    ofstream w("ubuntzei.out");
    w<<x<<endl;
    w.close();
}

void solve(Nod *G[nmax],int n,int (&fr)[15],int k) {
    int dmin[nmax],costfinal=0;

    doBellmanFord(G,dmin,n,1);
    if (k==0)
        costfinal=dmin[n];
    else {
        bool used[15],ok=false;

        memset(used,false,sizeof(used));

        while (!ok) {
            int fmin=inf,newsource,pfr;
            ok=true;
            for (int i=1;i<=k;i++)
                if (!used[i] && fmin>dmin[fr[i]]) {
                    fmin=dmin[fr[i]];
                    newsource=fr[i];
                    ok=false;
                    pfr=i;
                }
            used[pfr]=true;
            if (!ok) {
                costfinal+=fmin;
                doBellmanFord(G,dmin,n,newsource);
            }
        }
        costfinal+=dmin[n];
    }
    printCost(costfinal);
}

int main() {
    int fr[15],n,m,k;

    getData(G,n,m,fr,k);
    solve(G,n,fr,k);
}