#include <fstream>
#include <queue>
#include <vector>
#include <algorithm>

using namespace std;

const int NMax = 2048, MMax = 10010, KMax = 20, INF = 2000000000;
int ans;
int dp[16][(1<<15) + 10];
bool in_queue[NMax];
int d1[NMax], dn[NMax];
int d[16][NMax];
int C[KMax];
int n, m, K;
struct NOD
{
    int node, cost;
    NOD() {node = cost = 0;}
    NOD(const int node, const int cost)
    {
        this -> node = node;
        this -> cost = cost;
    }
};
vector <NOD> G[NMax];

void Read()
{
    ifstream f("ubuntzei.in");
    f>>n>>m;
    f>>K;
    for (int i = 0; i < K; ++i)
        f>>C[i];
    for (int i = 1; i <= m; ++i)
    {
        int x, y, cost; f>>x>>y>>cost;
        G[x].push_back(NOD(y, cost));
        G[y].push_back(NOD(x, cost));
    }
    f.close();
}

void BFS(const int &start, int *d)
{
    for (int i = 1; i<=n; ++i)
        d[i] = INF, in_queue[i] = false;
    queue <int> Q;
    Q.push(start);
    in_queue[start] = true;
    d[start] = 0;
    while (!Q.empty())
    {
        int node = Q.front(); Q.pop();
        in_queue[node] = false;
        for (vector <NOD> :: iterator it = G[node].begin(); it != G[node].end(); ++it)
        {
            NOD aux = *it;
            if (d[aux.node] > d[node] + aux.cost)
            {
                d[aux.node] = d[node] + aux.cost;
                if (!in_queue[aux.node])
                {
                    in_queue[aux.node] = true;
                    Q.push(aux.node);
                }
            }
        }
    }
}

void Solve()
{
    BFS(1, d1);
    BFS(n, dn);
    for (int i = 0; i < K; ++i)
        BFS(C[i], d[i]);
    for (int i = 0; i<=K; ++i)
        for (int conf = 0, limit = (1<<K); conf <= limit; ++ conf)
            dp[i][conf] = INF;
/// dp[i][conf] = costul minim de a pleca din nodul 1, si a ajunge in nodul C[i] avand deja vizitate orasele corespunzatoare lui conf
    for (int i = 0; i < K; ++i)
        dp[i][1<<i] = d1[C[i]];
    for (int conf = 0, limit = (1<<K); conf < limit; ++ conf)
    {
        for (int i = 0; i < K; ++i)
            if (d[i][conf] != INF)
            if (conf & (1<<i)) /// daca am in conf pe al i-lea oras de vizitat
                for (int j = 0; j < K; ++j)
                    if (i!=j && (conf & (i << j))) /// daca am in conf al j - lea oras vizitat, si j != i
                        dp[i][conf] = min(dp[i][conf], dp[j][conf - (1<<i)] + d[j][C[i]]);
    }
    ans = INF;
    for (int i = 0; i < K; ++i)
        ans = min(ans, dp[i][(1<<K) - 1] + dn[C[i]]);
    if (K == 0)
        ans = d1[n];
}

void Write()
{
    ofstream g("ubuntzei.out");
    g<<ans<<"\n";
    g.close();
}

int main()
{
    Read();
    Solve();
    Write();
    return 0;
}