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

#define INF 0x3f3f3f3f
using namespace std;

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

class PriorityQ {
public:
    int node, dist;
};

class Graph {
public:
    int node, road;
};

class cmp {
public:
    inline bool operator ()(PriorityQ a, PriorityQ b) {
        return a.dist > b.dist;
    }
};

vector <Graph> G[2005];
vector <int> frd, bkt_stk;
priority_queue <PriorityQ, vector <PriorityQ>, cmp> prioQ;

int k, n, m, dist[2005][2005], max_sum;

void dijkstra(int st) {
    prioQ.push({st, 0});
    dist[st][st] = 0;

    while(!prioQ.empty()) {
        PriorityQ frn = prioQ.top();
        prioQ.pop();

        for(auto nxt: G[frn.node]) {
            int new_dist = frn.dist + nxt.road;

            if(new_dist > dist[st][nxt.node]) {
                continue;
            }

            dist[st][nxt.node] = new_dist;
            prioQ.push({nxt.node, new_dist});
        }
    }
}

void bkt(int step) {
    if(step > k + 1) {
        int sum = 0;

        if((int) bkt_stk.size() != k + 1) {
            return;
        }

        for(int i = 0; i < (int) bkt_stk.size() - 1; ++i) {
            sum += dist[bkt_stk[i]][bkt_stk[i + 1]];
        }

        max_sum = max(max_sum, sum);
        return;
    }

    bkt(step + 1);
    bkt_stk.push_back(step);
    bkt(step + 1);
    bkt_stk.pop_back();
}

int main() {
    cin >> n >> m >> k;

    for(int i = 1; i <= k; ++i) {
        int x;
        cin >> x;
        frd.push_back(x);
    }

    for(int i = 1; i <= m; ++i) {
        int a, b, d;
        cin >> a >> b >> d;
        G[a].push_back({b, d});
        G[b].push_back({a, d});
    }

    memset(dist, INF, sizeof dist);
    dijkstra(1);

    for(auto it: frd) {
        dijkstra(it);
    }

    bkt_stk.push_back(1);
    bkt(2);
    int to_n = 0;

    for(auto it: frd) {
        to_n = max(to_n, dist[it][n]);
    }

    max_sum += to_n;
    cout << max_sum << '\n';
    return 0;
}