#include<fstream>
#include<vector>
#include<algorithm>
#include<queue>
#define NMAX 2010
#define KMAX 20
#define INF 1000000050
#define CONF_MAX 200000

using namespace std;

ifstream f("ubuntzei.in");
ofstream g("ubuntzei.out");

int n, m, k, c[KMAX], best[NMAX], x[KMAX][KMAX], sol[CONF_MAX][KMAX];

struct muchie
{
    int nod, cost;
};
vector<muchie> a[NMAX];
queue<int> q;

void Preprop()
{
    c[0]=1; c[k+1]=n;
    sort(c+1, c+k+1);
}

void Citeste()
{
    int i, x, y, cst;
    muchie r;

    f>>n>>m>>k;

    for (i=1; i<=k; ++i) f>>c[i];

    Preprop();

    for (i=1; i<=m; ++i)
    {
        f>>x>>y>>cst;
        r.nod=y; r.cost=cst; a[x].push_back(r);
        r.nod=x; a[y].push_back(r);
    }
}

void Initializeaza()
{
    int i;

    for (i=1; i<=n; ++i)
        best[i]=INF;
}

void Bellman_Ford(int sursa)
{
    int i, nod, val;
    muchie r;

    q.push(sursa); best[sursa]=0;

    while (!q.empty())
    {
        nod=q.front(); q.pop();

        for (i=0; i<a[nod].size(); ++i)
        {
            r=a[nod][i];
            val=r.cost+best[nod];

            if (val<best[r.nod])
            {
                q.push(r.nod);
                best[r.nod]=val;
            }
        }
    }
}

void Proceseaza(int nod, int pz)
{
    int i;

    for (i=0; i<=k+1; ++i)
        if (i!=pz && !x[i][pz])
            x[i][pz]=x[pz][i]=best[c[i]];
}

void Compress()
{
    int i;

    for (i=0; i<=k+1; ++i)
    {
        Initializeaza();
        Bellman_Ford(c[i]);
        Proceseaza(c[i], i);
    }
    /*for (i=0; i<=k+1; ++i)
    {
        for (int j=0; j<=k+1; ++j)
            g<<x[i][j]<<" ";
        g<<"\n";
    }*/
}

int recurenta(int conf, int nod)
{
    int confp, mn=INF, i, val;

    if (conf & (1<<nod)!=0)
    {
        confp=conf^(1<<nod);

        for (i=0; i<=k; ++i)
            if (x[i][nod])
            {
                val=sol[confp][i]+x[i][nod];
                mn=min(mn, val);
            }
            return mn;
    }
    else return INF;
}

void Dinamica()
{
    int i, j, m, conf, nod;

    ++k; m=(1<<(k+1));
    for (i=1; i<=m; ++i)
        for (j=0; j<=k; ++j) sol[i][j]=INF;

    sol[1][0]=0;

    for (conf=3; conf<m; ++conf)
        for (nod=0; nod<=k; ++nod)
            sol[conf][nod]=recurenta(conf, nod);
    g<<sol[m-1][k]<<"\n";
}

int main()
{
    Citeste();
    Compress();
    Dinamica();
    f.close();
    g.close();
    return 0;
}