#include <iostream>
#include <fstream>
#include <queue>
#include <vector>

using namespace std;

ifstream f("ubuntzei.in");
ofstream g("ubuntzei.out");

const int NMAX = 2001,
          INF = 999999999,
          FMAX = 17;

int d[NMAX], N, M, K, Friend[FMAX];
bool viz[NMAX];
int Cost[FMAX][FMAX];

class Comp
{
public:
    operator()(const int &a, const int &b)
    {
        return d[a] > d[b];
    }
};

priority_queue<int, vector<int>, Comp> Q;
vector<pair<int, int> > L[NMAX];

void citire()
{
    f >> N >> M >> K;
    for(int i = 1; i <= K; ++i)
        f >> Friend[i];
    for(int i = 1; i <= M; ++i)
    {
        int x, y, c;
        f >> x >> y >> c;
        L[x].push_back({y, c});
        L[y].push_back({x, c});
    }
}

void Dijkstra(int p)
{
    for(int i = 1; i <= N; ++i)
        d[i] = INF;
    Q.push(p);
    d[p] = 0;
    viz[p] = 1;
    while(!Q.empty())
    {
        int vf = Q.top();
        Q.pop();
        viz[vf] = 0;
        for(auto i : L[vf])
        {
            int nod  = i.first,
                cost = i.second;
            if(d[nod] > cost + d[vf])
            {
                d[nod] = cost + d[vf];
                if(!viz[nod])
                {
                    viz[nod] = 1;
                    Q.push(nod);
                }
            }
        }

    }
}

int x[17], VIZ[17];
int mini = 999999999;

void test()
{
    int S = Cost[0][x[1]];
    for(int i = 1; i < K; ++i)
        S += Cost[x[i]][x[i + 1]];
    S += Cost[x[K]][K + 1];
    if(S < mini)mini = S;
}

void bt(int k)
{
    for(int i = 1; i <= K; ++i)
        if(!VIZ[i])
        {
            VIZ[i] = 1;
            x[k] = i;
            if(k < K)
                bt(k + 1);
            else
                test();
            VIZ[i] = 0;
        }
}

int main()
{
    citire();
    Friend[0] = 1;
    Friend[K + 1] = N;
    for(int i = 0; i <= K + 1; ++i)
    {
        Dijkstra(Friend[i]);

        for(int j = 0; j <= K + 1; ++j)
            Cost[i][j] = d[Friend[j]];
    }
    if(K == 0)
    {
        g << Cost[0][1];
        return 0;
    }
    bt(1);
    g << mini;
    return 0;
}