#include <fstream>
#include <vector>
#include <queue>
#define nmax 2000+5
#define inf 1 << 30
using namespace std;

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

struct vecin
{
    int distanta, destinatie;
};

vector<vecin> graf[nmax];
int nPrieteni[nmax];
int pas[nmax];
bool ePrieten[nmax];
int n;


struct cmp
{
    bool operator()(const int & a, const int & b)
    {
        return nPrieteni[a] < nPrieteni[b] || nPrieteni[a] == nPrieteni[b] && pas[a] > pas[b];
    }
};

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

void citire()
{
    int m, k;
    int x, y, z;
    vecin v;

    fin >> n >> m;
    fin >> k;

    for (int i = 1; i <= k; i++)
    {
        fin >> x;
        ePrieten[x] = 1;
    }

    for (int i = 1; i <= m; i++)
    {
        fin >> x >> y >> z;
        v.distanta = z;

        v.destinatie = y;
        graf[x].push_back(v);

        v.destinatie = x;
        graf[y].push_back(v);
    }
}

void rezolvare()
{
    int curent;
    vecin v;
    int nPrieteniT, pasT;

    for (int i = 1; i <= n; i++)
    {
        nPrieteni[i] = 0;
        pas[i] = inf;
    }

    heap.push(1);
    nPrieteni[1] = ePrieten[1];
    pas[1] = 0;

    while (!heap.empty())
    {
        curent = heap.top();
        heap.pop();

        for (int i = 0; i < graf[curent].size(); i++)
        {
            v = graf[curent][i];

            nPrieteniT = nPrieteni[curent] + ePrieten[v.destinatie];
            pasT = pas[curent] + v.distanta;

            if (nPrieteniT > nPrieteni[v.destinatie] || nPrieteniT == nPrieteni[v.destinatie] && pasT < pas[v.destinatie])
            {
                ePrieten[v.destinatie] = 0;
                nPrieteni[v.destinatie] = nPrieteniT;
                pas[v.destinatie] = pasT;

                heap.push(v.destinatie);
            }
        }
    }
}

void afisare()
{
    fout << pas[n] << '\n';
}

int main()
{
    citire();
    rezolvare();
    afisare();
    return 0;
}