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

using namespace std;

struct dijkstra
{
    int nod, cost;
    bool operator<(const dijkstra &a) const
    {
        return cost > a.cost;
    }
};
int f[2001], prieteni[2001], d[20][20], dp[17][65536], gen[20], minn = inf;
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, aparn = 0;
    dijkstra aux;
    cin >> n >> m >> k;
    for (i = 1; i <= k; i++)
    {
        cin >> prieteni[i];
        if (prieteni[i] == n)
            aparn = 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 (j = 1; j <= n; j++)
        f[j] = inf;
    aux.cost = 0, aux.nod = 1, f[1] = 0;
    pq.push(aux);
    dik();
    d[0][k + 1] = f[n];
    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[0][i] = f[1], d[i][0] = f[1];
        d[i][k + 1] = f[n], d[k + 1][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][(1 << (j - 1))] = d[j][0];
    for (i = 1; i <= (1 << k) - 1; i++)
    {
        for (l = 1; l <= k; l++)
        {
            if (((1 << (l - 1)) & i) || i == 0)
            {
                for (j = 0; j < k; j++)
                    if (!(i & (1 << j)) && j + 1 != aparn)
                    {
                        dp[j + 1][(i | (1 << j))] = min(dp[j + 1][(i | (1 << j))], dp[l][i] + d[l][j + 1]);
                    }
            }
        }
    }
    for (j = 1; j <= k; j++)
    {
        if (dp[j][(1 << k) - 1] + d[j][k + 1] < minn)
            minn = dp[j][(1 << k) - 1] + d[j][k + 1];
    }
    if (minn != inf)
        cout << minn;
    else
        cout << d[0][k + 1];
    return 0;
}