#include <fstream>
#include <vector>
#include <queue>
#include <climits>

using namespace std;

struct nod
{
    int index;
    int cost;
    int nrk;

    nod(int index, int cost, int nrk)
    {
        this->index = index;
        this->cost = cost;
        this->nrk = nrk;
    }

    bool operator >(const nod &arg) const
    {
        if (this->cost > arg.cost)
        {
            return true;
        }
        return false;
    }
};

const int NMAX = 2000;

vector<pair<int ,int>> graf[1 + NMAX];
bool prieten[1 + NMAX];
int dp[1 + NMAX][1 + NMAX];

priority_queue<nod, vector<nod>, greater<nod>> q;

void dijkstra()
{
    dp[1][0] = 0;
    q.push(nod(1, 0, 0));

    while (!q.empty())
    {
        int nod_ = q.top().index;
        int cost = q.top().cost;
        int nrK = q.top().nrk;
        q.pop();

        if (cost > dp[nod_][nrK]) continue;

        for (int i = 0; i < graf[nod_].size(); i++)
        {
            int vecin = graf[nod_][i].second;
            int cost_ = graf[nod_][i].first;

            if (prieten[vecin])
            {
                if (cost + cost_ < dp[vecin][nrK + 1])
                {
                    dp[vecin][nrK + 1] = cost + cost_;
                    q.push(nod(vecin, dp[vecin][nrK + 1], nrK + 1));
                }
            }
            else
            {
                if (cost + cost_ < dp[vecin][nrK])
                {
                    dp[vecin][nrK] = cost + cost_;
                    q.push(nod(vecin, dp[vecin][nrK], nrK));
                }
            }
        }
    }
}

int main()
{
    ifstream in("ubuntzei.in");
    ofstream out("ubuntzei.out");
    int n, m, k, x;
    int a, b, c;

    in >> n >> m >> k;
    for (int i = 1; i <= k; i++)
    {
        in >> x;
        prieten[x] = true;
    }
    for (int i = 1; i <= m; i++)
    {
        in >> a >> b >> c;
        graf[a].push_back(make_pair(c, b));
        graf[b].push_back(make_pair(c, a));
    }

    for (int i = 1; i <= n; i++)
    {
        for (int j = 0; j <= k; j++)
        {
            dp[i][j] = INT_MAX;
        }
    }

    dijkstra();

    out << dp[n][k] << '\n';

    return 0;
}