#include <fstream>
#include <algorithm>
#include <queue>
#include <vector>

#define pe pair<int, int>
#define mp make_pair
#define fi first
#define se second

using namespace std;

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

const int MAX_P = 51;
const int MAX_N = 510;
const int INF = (1 << 30);

class cmp {
  public:
    inline bool operator () (const pe &a, const pe &b) {
        return a.se > b.se;
    }
};

priority_queue<pe, vector<pe>, cmp> Q;

vector<pe> A[MAX_N];

int dest[MAX_P];
int d[MAX_P][MAX_N];
int dp[MAX_P][MAX_P][MAX_P];
bool viz[MAX_N];

int n;

void dijkstra(int S, int d[MAX_N]) {
    for(int i = 1; i <= n; i++) {
        d[i] = INF;
        viz[i] = false;
    }

    d[S] = 0;
    viz[0] = true;
    Q.push(mp(S,0));

    while(!Q.empty()) {
        int nod = Q.top().fi;
        Q.pop();
        if(viz[nod]) {
            continue;
        }
        viz[nod] = true;
        for(auto it : A[nod]) {
            if(d[nod] + it.se < d[it.fi]) {
                d[it.fi] = d[nod] + it.se;
                Q.push(mp(it.fi, d[it.fi]));
            }
        }
    }
}

int main() {
    int p, m;
    fin >> p >> n >> m;
    
    for(int i = 1; i <= m; i++) {
        int a, b, c;
        fin >> a >> b >> c;
        A[a].push_back(mp(b, c));
        A[b].push_back(mp(a, c));
    }

    dest[0] = 1;
    for(int i = 1; i <= p; i++) {
        fin >>  dest[i];
    }
    
    for(int i = 0; i <= p; i++) {
        dijkstra(dest[i], d[i]);
    }


    for(int i = 0; i <= p; i++) {
        for(int j = 1; j <= p; j++) {
            for(int k = j; k <= p; k++) {
                if(j == k) {
                    dp[i][j][k] = d[i][ dest[j]];
                }
                else {
                    dp[i][j][k] = INF;
                }
            }
        }
    }

    for(int l = 1; l < p; l++) {
        for(int j = 1; (j + l) <= p; j++) {
            for(int i = 0; i <= p; i++) {
                for(int k = j; k <= j + l; k++) {
                    dp[i][j][j + l] = min(dp[i][j][j + l], d[i][dest[k]] + dp[k][j][k-1] + dp[k][k+1][j+l]);
                }
            }
        }
    }

    fout << dp[0][1][p];

    return 0;
}