#include <bits/stdc++.h>
#define INF 0x3f3f3f3f

using namespace std;
using PA = pair<int, int>;

ifstream fin("team.in");
ofstream fout("team.out");

int p, n, m;
int dest[55];
vector<PA> G[505];
int dp[55][55][505];
priority_queue<PA, vector<PA>, greater<PA>> Q;

void dijkstra(int i, int j) {
    while(!Q.empty()) {
        int cost = Q.top().first;
        int u = Q.top().second;
        Q.pop();
        if(cost > dp[i][j][u]) {
            continue;
        }
        for(auto edge : G[u]) {
            int vecin = edge.first;
            int w = edge.second;
            if(dp[i][j][u] + w < dp[i][j][vecin]) {
                dp[i][j][vecin] = dp[i][j][u] + w;
                Q.push({dp[i][j][vecin], vecin});
            }
        }
    }
}

int main() {
    fin >> p >> n >> m;
    for(int i = 1; i <= m; i++) {
        int x, y, z;
        fin >> x >> y >> z;
        G[x].push_back({y, z});
        G[y].push_back({x, z});
    }
    for(int i = 1; i <= p; i++) {
        fin >> dest[i];
    }
    fin.close();

    memset(dp, INF, sizeof(dp));

    for(int L = 1; L <= p; L++) {
        for(int i = 1; i <= p - L + 1; i++) {
            int j = i + L - 1;
            for(int u = 1; u <= n; u++) {
                for(int k = i; k <= j; k++) {
                    if(dest[k] == u) {
                        int st = (k > i) ? dp[i][k - 1][u] : 0;
                        int dr = (k < j) ? dp[k + 1][j][u] : 0;
                        if(st != INF && dr != INF) {
                            dp[i][j][u] = min(dp[i][j][u], st + dr);
                        }
                    }
                }
                if(dp[i][j][u] != INF) {
                    Q.push({dp[i][j][u], u});
                }
            }
            dijkstra(i, j);
        }
    }

    fout << dp[1][p][1] << "\n";
    fout.close();
    
    return 0;
}