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

using namespace std;

struct p {
    int nod;
    int cost;
    bool operator<(const p& P) const {
        return cost > P.cost;
    }
};

const int N = 2001;
const int INF = 1 << 30;

vector<p> gr_init[N], gr_fin[N];
priority_queue<p> pq;
int d[N], loc[N];
bool viz[N];


void dijkstra(vector<p> gr[N], int src, int n) {
    for (int i = 1; i <= n; ++i) {
        d[i] = INF;
        //viz[i] = false;
    }
    d[src] = 0;
    pq.push({ src, 0 });

    while (!pq.empty()) {
        p crt = pq.top();
        pq.pop();
        //viz[crt.nod] = true;

        for (auto vec : gr[crt.nod])
            if (/*!viz[vec.nod] && */crt.cost + vec.cost < d[vec.nod]) {
                d[vec.nod] = crt.cost + vec.cost;
                pq.push({ vec.nod, d[vec.nod] });
            }
    }
}

int main() {
    ifstream in("ubuntzei.in");
    ofstream out("ubuntzei.out");

    int n, m, k;
    in >> n >> m >> k;
    for (int i = 0; i < k; ++i)
        in >> loc[i];
    int x, y, cost;
    while (m--) {
        in >> x >> y >> cost;
        gr_init[x].push_back({ y, cost });
        gr_init[y].push_back({ x, cost });
    }

    for (int i = 0; i < k; ++i) {
        dijkstra(gr_init, loc[i], n);
        for (int j = 1; j <= n; ++j) {
            gr_fin[loc[i]].push_back({ j, d[j] });
            gr_fin[j].push_back({ loc[i], d[j] });
        }
    }
    
    int rez;
    dijkstra(gr_fin, 1, n);
    rez = d[n];
    dijkstra(gr_fin, n, 1);
    rez = min(d[1], rez);

    out << rez;

    in.close();
    out.close();
    return 0;
}