#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <algorithm>
#include <fstream>
using namespace std;

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

const int INF = 1e9;
const int N = 2000;
const int K = 17;
const int K2 = 131072;

vector <pair<int, int> > g[N];
priority_queue <pair<int, int> > pq;
bool visited[N];
int dist[N];
int orase[K];


int n,k;
int cost[N][N];
int dp[K2][K];

void dijkstra(int start){
	for(int i=0; i<n; i++)
		dist[i] = INF, visited[i] = false;

	dist[start] = 0;
	pq.push(make_pair(0, start));
	while(!pq.empty()){
		int node = pq.top().second;
		pq.pop();
		if(visited[node] == true)
			continue;
		visited[node] = true;
		for(int p=0; p<(int)g[node].size(); p++){
			int next = g[node][p].first;
			int c = g[node][p].second;
			if(dist[node] + c < dist[next]){
				dist[next] = dist[node] + c;
				pq.push(make_pair(-dist[next], next));
			}
		}
	}

	for(int i=0; i<n; i++){
		cost[start][i] = min(cost[start][i], dist[i]);
		cost[i][start] = min(cost[i][start], dist[i]);
	}
}

void setupHamilton(){
	for(int i=0; i<n; i++)
		for(int j=0; j<n; j++)
			cost[i][j] = INF;

	for(int i=0; i< (1<<k); i++)
		for(int j=0; j<k; j++)
			dp[i][j] = INF;
}

int main()
{
	int m,i,j,p,x,y,c;
	fin >> n >> m >> k;
	for(i=0; i<k; i++){
		fin >> orase[i];
		orase[i]--;
	}
	orase[k++] = 0, orase[k++] = n-1;
	sort(orase, orase+k);
	for(i=0; i<m; i++){
		fin >> x >> y >> c;
		x--;
		y--;
		g[x].push_back(make_pair(y, c));
		g[y].push_back(make_pair(x, c));
	}
	setupHamilton();
	for(i=0; i<k; i++)
		dijkstra(orase[i]);

	dp[1][0] = 0;
	for(i=1; i < (1<<k); i++)
		for(j=1; j<k; j++)
			if(i & (1<<j))
				for(p=0; p<k; p++)
					if(i & (1<<p))
						dp[i][j] = min(dp[i][j], dp[i ^ (1<<j)][p] + cost[orase[p]][orase[j]]);

	fout << dp[(1 << k) - 1][k-1] << "\n";
	return 0;
}