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

using namespace std;

ifstream f ("team.in");
ofstream g ("team.out");

const int INF = 10000000;
const int NMAX = 500 + 1, PMAX = 50 + 1;

int p, n, m;
int destinatie[PMAX];
int d[PMAX][NMAX];
bool inQ[NMAX];
vector < pair <int, int> > graf[NMAX];

int dp[PMAX][NMAX][PMAX];

void citeste() {
    f >> p >> n >> m;
    int a, b, c;

    for (int i = 1; i <= m; i++) {
        f >> a >> b >> c;
        graf[a].push_back(make_pair(b, c));
        graf[b].push_back(make_pair(a, c));
    }

    for (int i = 1; i <= p; i++) f >> destinatie[i];
}

void bellman_ford(int sursa, int d[]) {
    int nod, fiu, l, c;
    queue <int> Q;
    Q.push(sursa);
    inQ[sursa] = true;

    for (int i = 1; i <= n; i++) d[i] = INF, inQ[i] = false;
    d[sursa] = 0;

    while (!Q.empty()) {
        nod = Q.front();
        Q.pop();
        inQ[sursa] = false;
        int l = graf[nod].size();
        for (int i = 0; i < l; i++) {

            fiu = graf[nod][i].first;
            c = graf[nod][i].second;
            if (d[nod] + c < d[fiu]) {
                d[fiu] = d[nod] + c;
                if (inQ[fiu]) continue;
                inQ[fiu] = true;
                Q.push(fiu);
            }
        }
    }
}

void rezolva() {
    for (int i = 1; i <= p; i++) bellman_ford(destinatie[i], d[i]);

    int j;
    int min1, min2;
    min1 = min2 = INF;
    for (int lg = 2; lg <= p; lg++) {
        for (int i = 1; i <= p; i++) {
            j = i + lg - 1;
            if (j > p) break;
            for (int k = i; k <= j; k++) {
                min1 = min2 = INF;
                for (int a = i; a <= k - 1; a++)
                    min1 = min(min1, dp[i][k - 1][a] + d[destinatie[k]][a]);
                for (int a = k + 1; a <= n; a++)
                    min2 = min(min2, dp[k + 1][j][a] + d[destinatie[k]][a]);
                if (min1 == INF) min1 = 0;
                if (min2 == INF) min2 = 0;
                dp[i][j][k] = min1 + min2;
            }
        }
    }

    int sol = INF;
    for (int i = 1; i <= p; i++)
        sol = min(sol, dp[1][p][i] + d[i][1]);
    g << sol;
}


int main() {
    citeste();
    rezolva();
    return 0;
}