#include <fstream>
#include <algorithm>
#include <vector>
#include <string.h>
#include <climits>
#define INF 1000000000000000
using namespace std;
ifstream fin("ubuntzei.in");
ofstream fout("ubuntzei.out");

int i, n, m, T, air, k, start, ending, cost, friend_location[20], j, no_friends;
long long  dist[100010], stack[100010];
int isFriend[100010];
bool isNode[100010];
long long C[132000][18];
long long Cost[20][20];
vector<int> nodes;
vector<pair<int, int>> bigGraph[100001];

void dijkstra2(int start) {
    long long st = 0, dr = 0;
    for (unsigned int i = 0; i < nodes.size(); i++) {
        dist[nodes[i]] = INF;
    }
    stack[st] = start;
    dist[start] = 0;
    while (st <= dr) {
        long long current_node = stack[st];
        for (auto node : bigGraph[current_node]) {
            if (dist[node.first] > dist[current_node] + node.second) {
                dist[node.first] = dist[current_node] + node.second;
                stack[++dr] = node.first;
            }
        }
        st++;
    }
}



void HamiltonianCicle2() {
    no_friends += 2;
    long long pow2 = 1 << no_friends;

    for (int i = 0; i < pow2; ++i) {
        for (int j = 0; j < no_friends; ++j) {
            C[i][j] = INF;
        }
    }
    C[1][0] = 0;
    for (int i = 0; i < pow2; i++) {
        for (int j = 0; j < no_friends; j++) {
            if (i & (1 << j)) {
                for (int k = 0; k <= no_friends; k++) {
                    C[i][j] = min(C[i][j], C[i - (1 << j-1)][k] + Cost[k][j]);
                }
            }
        }
    }
}

int main() {
    fin >> n >> m;

    fin >> no_friends;
    for (i = 1; i <= no_friends; i++) {
        fin >> friend_location[i];
    }
    friend_location[0] = 1;
    friend_location[no_friends + 1] = n;
    for (i = 0; i < m; i++) {
        fin >> start >> ending >> cost;
        bigGraph[start].push_back(make_pair(ending, cost));
        bigGraph[ending].push_back(make_pair(start, cost));
        if (!isNode[start])
            nodes.push_back(start), isNode[start] = 1;
        if (!isNode[ending])
            nodes.push_back(ending), isNode[ending] = 1;
    }
    for (i = 0; i <= n; i++)
        for (j = 0; j <= n; j++)
            Cost[i][j] = INF;
    for (i = 0; i <= no_friends + 1; i++) {
        dijkstra2(friend_location[i]);
        for (int j = 0; j <= no_friends + 1; j++) {
            Cost[i][j] = dist[friend_location[j]];
        }
    }
    HamiltonianCicle2();
    long long solution = 1000000000;
    /*for (int i = 0; i < no_friends; i++) {
        solution = min(solution, C[(1 << no_friends) - 1][i] + Cost[i][no_friends -1]);
    }*/
    fout << C[(1<<no_friends)-1][no_friends - 1];
}