#include <bits/stdc++.h>
#define inf 1000000

using namespace std;

struct dijkstra
{
    int nod, cost;
    bool operator<(const dijkstra &a) const
    {
        return cost > a.cost;
    }
};
int f[2001], prieteni[2001], d[16][16], dp[16][32769];
vector<dijkstra> ad[2001];
priority_queue<dijkstra> pq;
void dik()
{
    int i;
    dijkstra a, aux;
    while (!pq.empty())
    {
        a.nod = pq.top().nod, a.cost = pq.top().cost;
        pq.pop();
        if (a.cost == f[a.nod])
        {
            for (i = 0; i < ad[a.nod].size(); i++)
            {
                if (f[ad[a.nod][i].nod] > a.cost + ad[a.nod][i].cost)
                {
                    aux.cost = a.cost + ad[a.nod][i].cost, aux.nod = ad[a.nod][i].nod;
                    f[aux.nod] = aux.cost;
                    pq.push(aux);
                }
            }
        }
    }
}

int main()
{
    ifstream cin("ubuntzei.in");
    ofstream cout("ubuntzei.out");
    int n, m, k, i, j, l, a, b, c, minn = inf;
    dijkstra aux;
    cin >> n >> m >> k;
    for (i = 1; i <= k; i++)
        cin >> prieteni[i];
    for (i = 0; i < m; i++)
    {
        cin >> a >> b >> c;
        aux.cost = c;
        aux.nod = b, ad[a].push_back(aux);
        aux.nod = a, ad[b].push_back(aux);
    }
    for (i = 1; i <= k; i++)
    {
        for (j = 1; j <= n; j++)
            f[j] = inf;
        aux.cost = 0, aux.nod = prieteni[i], f[prieteni[i]] = 0;
        pq.push(aux);
        dik();
        for (j = 1; j <= k; j++)
            d[i][j] = d[j][i] = f[prieteni[j]];
        d[1][i] = f[1], d[i][1] = f[1];
        d[i][n] = f[n], d[n][i] = f[n];
    }
    for (l = 1; l <= k; l++)
        for (j = 0; j < (1 << (k - 1)); j++)
            dp[l][j] = inf;
    for (j = 1; j <= k; j++)
        dp[j][0] = d[j][1];
    for (l = 1; l <= k; l++)
    {
        for (i = 0; i <= (1 << (k - 1)) - 1; i++)
        {
            if (((1 << l) & i) || i == 0)
            {
                for (j = 0; j < k; j++)
                    if (!(i & (1 << j)))
                    {
                        dp[j + 1][(i | (1 << j))] = min(dp[j + 1][(i | (1 << j))], dp[l][i] + d[l][j]);
                    }
            }
        }
    }
    for (j = 1; j <= k; j++)
        if (dp[j][(1 << (k - 1)) - 1] + d[j][n] < minn)
            minn = dp[j][(1 << (k - 1)) - 1] + d[j][n];
    cout << minn;
    return 0;
}