#include <fstream>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std;

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

struct Pair {
    int dist, nod;

    bool operator < (const Pair& p) const
    {
        return dist > p.dist;
    }
};

using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;

const int Inf = 0x3f3f3f3f;
VI C, d;     // d - Dijkstra din nodul sursa, C - orasele speciale
VVI D, dp;   // D[i] - dist minima de la C[i] la restul nodurilor
             // dp[i][j] - dist minima a unui drum care porneste din 1 si se termina cu j,
             //            daca drumul contine o submultime i de noduri din cele speciale, si j e inclus in i
int n, m, K;
vector<vector<PII>> G;

void Read();
void Dijkstra(int S, VI& d);

int main()
{
    Read();
    Dijkstra(1, d);

    if (K == 0)
    {
        fout << d[n] << '\n';

        fout.close();
        return 0;
    }

    for (int i = 0; i < K; ++i)
        Dijkstra(C[i], D[i]);

    // initializare
    for (int j = 0; j < K; ++j)
        dp[1 << j][j] = d[C[j]];          // dp[1 << j][j] - dist minima de la 1 la C[j], daca trec obligatoriu numai prin nodul C[j]

    // dinamica
    for (int i = 1; i < (1 << K); ++i)    // pt fiecare submultime i de pozitii din sirul nodurilor {C[0], ..., C[K - 1] }
        for (int j = 0; j < K; ++j)
            if (i & (1 << j))             // masca i contine bitul j
                for (int k = 0; k < K; ++k)
                    if ( !(i & (1 << k)) ) // si masca i NU contine bitul k
                        dp[i | (1 << k)][k] = min(dp[i | (1 << k)][k], dp[i][j] + D[j][C[k]]);

    int res(Inf);
    for (int i = 0; i < K; ++i)
        res = min(res, dp[(1 << K) - 1][i] + D[i][n]);

    fout << res << '\n';

    fout.close();
}

void Dijkstra(int S, VI& d)
{
    priority_queue<Pair> Q;
    d = VI(n + 1, Inf);
    d[S] = 0; Q.push({0, S});

    for (int x, dx, y, w; !Q.empty(); Q.pop())
    {
        x = Q.top().nod; dx = Q.top().dist;

        if ( d[x] < dx )
            continue;
        for (const auto& e : G[x])
        {
            y = e.first; w = e.second;

            if ( d[y] > d[x] + w )
            {
                d[y] = d[x] + w;
                Q.push({d[y], y});
            }
        }
    }
}

void Read()
{
    fin >> n >> m >> K;
    G = vector<vector<PII>>(n + 1);
    C = VI(K);  D = VVI(K);
    dp = VVI(1 << K, VI(K, Inf));

    for (int i = 0; i < K; ++i)
        fin >> C[i];

    for (int i = 1, x, y, w; i <= m; ++i)
    {
        fin >> x >> y >> w;
        G[x].push_back({y, w});
        G[y].push_back({x, w});
    }
    fin.close();
}