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

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;
}

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

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

    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 < M; ++i) {
        int x, y, z; cin >> x >> y >> z;
        --x; --y;
        dist[y][x] = min(dist[x][y], z);
        dist[x][y] = dist[y][x];
    }

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

    for (int i = 0; i < P; ++i) {
        vector<bool> used(N, 0);

        for (int j = 0; j < N; ++j) {
            int whom = -1;
            for (int k = 0; k < N; ++k)
                if (!used[k])
                    if (whom == -1 || dist[D[i]][k] < dist[D[i]][whom])
                        whom = k;
            used[whom] = true;
            for (int k = 0; k < N; ++k)
                dist[D[i]][k] = min(dist[D[i]][k], dist[D[i]][whom] + dist[whom][k]);
        }
    }

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