#include <fstream>
#include <math.h>
#include <set>
#include <queue>

using namespace std;

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

int dist[36001], n, f[36001], minim, m, k, sef[36001], oras[2001], a[2001][2001], permutare[2001], rez[2001];

vector <pair <int, int>> l[50001];
priority_queue<pair<int, int> > dist_min;

//void dijkstra()
//{
//    int cost, i, nod1, nod2;
//    
//    while (dist_min.size() > 0)
//    {
//        nod1 = dist_min.top().second;
//        dist_min.pop();
//        if(f[nod1] == 0)
//        {
//            f[nod1] = 1;
//            for (i = 0; i < l[nod1].size(); i++)
//            {
//                nod2 = l[nod1][i].first;
//                cost = l[nod1][i].second;
//                if (dist[nod1] + cost < dist[nod2])
//                {
//                    dist[nod2] = dist[nod1] + cost;
//                    dist_min.push({-dist[nod2], nod2});
//                }
//            }
//        }
//    }
//}

//int Bellman_Ford(int nod)
//{
//    int i, p, u, ok = 1, x, coada;
//    for (i = 1; i<= n; i++)
//        if(i!= nod)
//            dist[i]= 1e9;
//    p = 1;
//    u = 1;
//    coada[p] = nod;
//    while (p <= u && ok == 1)
//    {
//        x = coada[p];
//        f[x]++;
//        if(f[x] >= n)
//            ok = 0;
//        else
//        {
//            for (i = 1; i<= n; i++)
//                if(dist[i] > dist[x] + a[x][i])
//                {
//                    dist[i] = dist[x] + a[x][i];
//                    u++;
//                    coada[u] = i;
//                }
//        }
//        p++;
//    }
//    return ok;
//}

void floyd()
{
    int i, j, k;
    for (k = 1; k<= n; k++)
        for (i = 1; i<= n; i++)
            for (j = 1; j<= n; j++)
                if(a[i][j] > a[i][k] + a[k][j])
                    a[i][j] = a[i][k] + a[k][j];
}

int ok(int k)//verifica daca nu se repeta
{
    int i;
    for (i = 1; i<= k-1; i++)
        if(permutare[i] == permutare[k])
            return 0;
    return 1;
}


void calc_dist_totala(int k)
{
    int i, suma=0;
    for(i = 2; i<= n; i++)
        suma += a[permutare[i-1]][permutare[i]];
    if(suma < minim)
        minim = suma;
}


void bkt(int k) {
    int i;
    if(k == n+1)
        calc_dist_totala(k-1);
    else {
        for(i=1; i<=n; i++)
        {
            permutare[k] = i;
            if(f[permutare[i]]==0)
            {
                f[permutare[i]]=1;
                bkt(k+1);
                f[permutare[i]]=0;
            }
        }
    }
}


int main()
{
    int C, i, j, x, y;
    fin >> n >> m >> k;
    
    
    for (i = 1; i<= k ;i++)
        fin >> oras[i];
    
    for (i = 1; i<= m; i++)
    {
        fin >> x >> y >> C;
        a[x][y] = a[y][x] = C;
    }
    for (i = 1; i<= n; i++)
        for (j = 1; j<= n; j++)
            if(i != j && a[i][j] == 0)
                a[i][j] = 10001;
    
    floyd();
    
    minim = 1e9;
    bkt(1);
    
    fout << minim+1;
    
    return 0;
}