#include <fstream>
#include <vector>
#include <queue>
#include <algorithm>
#define inf 2000000000

using namespace std;

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

const int Nmax = 2005;

vector<int> dist(Nmax);
vector<pair<int, int> > A[Nmax];

struct cmp
{
    bool operator()(int x, int y)
    {
        return dist[x] < dist[y];
    }
};

priority_queue<int, vector<int>, cmp> Q;

bool verif (int cnt, vector<int>&q)
{
    for (int i = 1; i <= cnt; i++)
        if (q[i] == q[cnt + 1])
            return false;
    return true;
}

void aranjamente (int nr, int k, int n, int&sol, vector<int>&v, vector<int>&q, vector<vector<int> >&drum)
{
    if (nr == k + 1)
    {
        int rez = drum[1][v[q[1]]];
        for (int i = 1; i < k; i++)
            rez = rez + drum[v[q[i]]][v[q[i + 1]]];
        rez = rez + drum[v[q[k]]][n];
        sol = min(sol, rez);
        return;
    }

    for (int i = 1; i <= k; i++)
    {
        q[nr] = i;
        if (verif(nr - 1, q))
            aranjamente(nr + 1, k, n, sol, v, q, drum);
    }
}

void Dijkstra (int start, int n, vector<bool>&OK)
{
    for (int i = 2; i <= n; i++)
        dist[i] = inf;

    Q.push(start);
    while (!Q.empty())
    {
        int nod = Q.top();
        OK[nod] = 0;
        Q.pop();

        for (auto i = 0; i < A[nod].size(); i++)
        {
            int nod_curent = A[nod][i].first;
            int cost_curent = A[nod][i].second;

            if (dist[nod_curent] > dist[nod] + cost_curent)
            {
                dist[nod_curent] = dist[nod] + cost_curent;

                if (OK[nod_curent] == 0)
                {
                    OK[nod_curent] = 1;
                    Q.push(nod_curent);
                }
            }
        }
    }
}

int main()
{
    int n, m, k, nr = 1, sol = inf;

    in.sync_with_stdio(false);
    in >> n >> m >> k;

    vector<int> v(k + 1);
    vector<int> q(k + 1);
    vector<bool> OK(n + 1);
    vector<vector<int> > drum(n + 1, vector<int>(n + 1));

    for (int i = 1; i <= k; i++)
        in >> v[i];

    for (int i = 1; i <= m; i++)
    {
        int x, y, c;
        in >> x >> y >> c;

        drum[x][y] = c;
        drum[y][x] = c;

        A[x].push_back(make_pair(y, c));
        A[y].push_back(make_pair(x, c));
    }

    if (k == 0)
    {
        Dijkstra(1, n, OK);
        out << dist[n];
        return 0;
    }

    for (int w = 1; w <= n; w++)
        for (int i = 1; i < n; i++)
            for (int j = i + 1; j <= n; j++)
                if (i != j && drum[i][w] && drum[j][w])
                    if (drum[i][j] > drum[i][w] + drum[w][j] || drum[i][j] == 0)
                        drum[i][j] = drum[j][i] = drum[i][w] + drum[w][j];

    if (k == 0)
    {
        out << drum[1][n];
        return 0;
    }

    aranjamente(nr, k, n, sol, v, q, drum);

    out << sol;
    return 0;
}