#include <iostream>
#include <fstream>
#include <vector>
#include <queue>

using namespace std;

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

const int N_MAX = 2000;
const int K_MAX = 15;

int n, m, k, opriri[K_MAX + 3];
int d[K_MAX + 3][K_MAX + 3], sume[K_MAX+1][1 << (K_MAX+1)];
int dijdist[N_MAX + 1];
bool solved[N_MAX + 1], irolat[N_MAX + 1];

struct varf
{
    int index;
    int cost;
};

vector <vector <varf> >dij(N_MAX + 1);

queue <int> coada;

int suma(int numar_nr, int config, int finish)
{
if(numar_nr == 1)
    return d[1][finish+2];

if(!sume[finish][config])
{
    int s = 0x7fffffff;
    for(int j = 0; j < (k+1); j++)
        if((config - (1<< finish)) &  (1 << j))
            s = min(s, suma(numar_nr - 1, config - (1 << finish), j) + d[finish+2][j+2]);
    sume[finish][config] = s;
}
return sume[finish][config];
}


void dijkstra(int t)
{
    coada.push(t);
    while(!coada.empty())
    {
        int Q = coada.front();
        coada.pop();
        irolat[Q] = false;
            for(int i = 0; i < dij[Q].size(); i++)
            {
                if(dijdist[Q] + dij[Q][i].cost < dijdist[dij[Q][i].index])
                {
                    dijdist[dij[Q][i].index] = dijdist[Q] + dij[Q][i].cost;
                    if(!irolat[dij[Q][i].index])
                    {
                        coada.push(dij[Q][i].index);
                        irolat[dij[Q][i].index] = true;
                    }
                }
            }

    }
}

int main()
{
    f >> n >> m >> k;
    opriri[++opriri[0]] = 1;
    for(int i = 1; i <= k; i++)
        f >> opriri[++opriri[0]];
    opriri[++opriri[0]] = n;
    int x, y, z;
    for(int i = 1; i <= m; i++)
    {
        f >> x >> y >> z;
        varf v;
        v.index = y;
        v.cost = z;
        dij[x].push_back(v);
        v.index = x;
        dij[y].push_back(v);
    }
    for(int i = 1; i <= opriri[0]; i++)
    {
        for(int j = 1; j <= n; j++)
        {
            dijdist[j] = 0x7fffffff;
            solved[j] = false;
        }
        dijdist[opriri[i]] = 0;
        dijkstra(opriri[i]);
        for(int j = 1; j <= opriri[0]; j++)
            d[i][j] = dijdist[opriri[j]];
    }
    g << suma(k+1, (1 << (k+1)) -1, k);
    return 0;
}