#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <limits>
#include <set>

using namespace std;

int solve(int node, int from, int to, const vector< vector<int> > &dist, const vector<int> &D, vector< vector< vector<int> > > &dp) {
    if (from == to)
        return 0;

    if (dp[node][from][to]  >= 0)
        return dp[node][from][to];

    int answer = numeric_limits<int>::max();
    for (int i = from; i < to; ++i)
        answer = min(answer, solve(D[i], from, i, dist, D, dp) + solve(D[i], i + 1, to, dist, D, dp) + dist[D[i]][node]);
    dp[node][from][to] = answer;
    return answer;
}

inline int min(int a, int b) {
    return a < b ? a : b;
}

int main() {
    ifstream cin("team.in");
    ofstream cout("team.out");

    int P, N, M; cin >> P >> N >> M;

    vector< vector< pair<int, int> > > edge(N);
    for (int i = 0; i < M; ++i) {
        int x, y, z; cin >> x >> y >> z;
        --x; --y;
        edge[x].emplace_back(y, z);
        edge[y].emplace_back(x, z);
    }

    vector<int> D(P);
    for (int i = 0; i < P; ++i) {
        cin >> D[i];
        --D[i];
    }

    vector< vector<int> > dist(N, vector<int>(N, numeric_limits<int>::max() / N));
    for (int i = 0; i < N; ++i)
        dist[i][i] = 0;


    for (int i = 0; i < P; ++i) {
        set< pair<int, int> > S;
        for (int j = 0; j < N; ++j)
            S.emplace(dist[D[i]][j], j);

        for (int j = 0; j < N; ++j) {
            int distance, node;
            tie(distance, node) = *S.begin();
            S.erase(S.begin());
            for (auto &e : edge[node])
                if (dist[D[i]][e.first] > distance + e.second) {
                    S.erase(make_pair(dist[D[i]][e.first], e.first));
                    dist[D[i]][e.first] = distance + e.second;
                    S.insert(make_pair(dist[D[i]][e.first], e.first));
                }
        }
    }

    vector< vector< vector<int> > > dp(N, vector< vector<int> >(P, vector<int>(P + 1, -1)));
    cout << solve(0, 0, P, dist, D, dp) << "\n";
}