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

using namespace std;

ifstream ka("ubuntzei.in");
ofstream ki("ubuntzei.out");

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

int n, m, k, opriri[K_MAX + 3];
int distante[K_MAX + 3][K_MAX + 3], sume[K_MAX+1][1 << (K_MAX+1)];
int dijdist[N_MAX + 1];
bool solved[N_MAX + 1], incoada[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 configuratie, int terminatie)
{
    if(numar_nr == 1)
        return distante[1][terminatie+2];
    if(!sume[terminatie][configuratie])
    {
        int s = 0x7fffffff;
            for(int j = 0; j < (k+1); j++)
                if((configuratie - (1<< terminatie)) &  (1 << j))
                    s = min(s, suma(numar_nr - 1, configuratie - (1 << terminatie), j) + distante[terminatie+2][j+2]);
        sume[terminatie][configuratie] = s;
    }
    return sume[terminatie][configuratie];
}

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

    }
}

int main()
{
    ka >> n >> m >> k;
    opriri[++opriri[0]] = 1;
    for(int i = 1; i <= k; i++)
        ka >> opriri[++opriri[0]];
    opriri[++opriri[0]] = n;
    int x, y, z;
    for(int i = 1; i <= m; i++)
    {
        ka >> 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++)
            distante[i][j] = dijdist[opriri[j]];
    }
    ki << suma(k+1, (1 << (k+1)) -1, k);
    return 0;
}