#include <bits/stdc++.h>

#define PII pair < int , int >
#define F first
#define S second

using namespace std;

const int Nmax = 2000 + 10;
const int Kmax = 15 + 2;
const int inf = 0x3f3f3f3f;

int n , m , k , i;
int d[Kmax][Kmax] , dp[1<<Kmax][Kmax];
int bst[Nmax] , v[Kmax];

bool marked[Nmax];

vector < PII > g[Nmax];
vector < PII > :: iterator it;
priority_queue < PII , vector < PII > , greater < PII > > q;

void dijkstra(int node , int p)
{
    memset(bst , inf , sizeof(bst));
    memset(marked , 0 , sizeof(marked));

    int Node = node;

    for (q.push({0,node}),bst[node]=0; !q.empty(); )
    {
        node = q.top().second; q.pop();
        if (marked[node]) continue;
        marked[node] = 1;

        for (it = g[node].begin(); it != g[node].end(); ++it)
        {
            int newN = it->F; int cost = it->S;

            if (bst[newN] > bst[node] + cost)
            {
                bst[newN] = bst[node] + cost;
                q.push({bst[newN] , newN});
            }
        }
    }

    node = Node;
    for (int i = 0; i <= k; ++i)
        d[p][i] = d[i][p] = min(d[p][i] , bst[v[i]]);
}

void dinamica()
{
    dp[1][0] = 0;
    for (int x = 1; x < (1 << (k+1)); ++x)
    {
        for (int j = 0; j <= k; ++j)
            if ((x >> j) & 1)
            {
                int y = x ^ (1 << j);
                for (int b = 0; b <= k; ++b)
                    if ((y >> b) & 1)
                        dp[x][j] = min(dp[x][j] , dp[y][b] + d[b][j]);
            }
    }
}

int main()
{
    freopen("ubuntzei.in","r",stdin);
    freopen("ubuntzei.out","w",stdout);

    scanf("%d %d", &n, &m);

    scanf("%d", &k);
    for (i = 1; i <= k; ++i)
        scanf("%d", v + i);
    v[0] = 1; v[++k] = n;

    for (i = 1; i <= m; ++i)
    {
        int node1 , node2 , cost;
        scanf("%d %d %d", &node1, &node2, &cost);

        g[node1].push_back({node2 , cost});
        g[node2].push_back({node1 , cost});
    }

    memset(d , inf , sizeof(d));
    for (i = 0; i <= k; ++i)
        dijkstra(v[i] , i);

    memset(dp , inf , sizeof(dp));
    dinamica();
    printf("%d\n", dp[(1<<(k+1))-1][k]);

    return 0;
}