#include<cstdio>
#include<vector>
#include<queue>
#include<cstring>
#include<bitset>
#include<algorithm>
const int inf = 1000 * 1000 * 1000;
using namespace std;

const int maxn = 505;
const int maxp = 55;

int i , j , n , m , p , a , b , c , d[maxn][maxn] , dp[maxn][maxp][maxp], dest[maxn] , k;
bool calc[maxn][maxp][maxp], done[maxn];

bitset<maxn> in_queue;

queue <int> Q;
vector <int> G[maxn] , C[maxn];

int ret(int nod, int left, int right) {
	
	if(left > right)
		return 0;
	
	int ans = inf;
	int i , l , r;
	if(calc[nod][left][right])
		return dp[nod][left][right];
	
	bool ok = false;
	
	
	for(i = left; i <= right; ++i) { 
		ans = min(ans , ret(dest[i] , left , i - 1) + ret(dest[i] , i + 1 , right) + d[nod][dest[i]]);
		if(ans == 0) break;
	}
	
	//printf("%d %d %d  %d\n",nod,left,right , ans);
	
	calc[nod][left][right] = true;
	dp[nod][left][right] = ans;
	return ans;
}

void Dijkstra(int nod)
{
	int i;
	
	if(done[nod]) return;
	done[nod] = true;
	
	for(i = 1; i <= n; ++i)
		d[nod][i] = inf;
	
	d[nod][nod] = 0;
	
	queue<int> Q;
	
	in_queue[nod] = true;
	Q.push(nod);
	
	for(;!Q.empty();) {
		
		int act = Q.front();
		Q.pop();
		in_queue[act] = false;
		
		for(i = 0; i < G[act].size(); ++i)
			if(d[nod][act] + C[act][i] < d[nod][G[act][i]]) {
				d[nod][G[act][i]] = d[nod][act] + C[act][i];
				if(!in_queue[G[act][i]]) {
					Q.push(G[act][i]);
					in_queue[G[act][i]] = true;
				}
			}
	}
}

int main()
{
	freopen("team.in","r",stdin);
	freopen("team.out","w",stdout);
	
	scanf("%d\n%d\n%d",&p,&n,&m);
	
	for(i = 1; i <= m; ++i) {
		scanf("%d %d %d",&a,&b,&c);
		G[a].push_back(b);
		C[a].push_back(c);
		G[b].push_back(a);
		C[b].push_back(c);
	}
	
	
	
	for(i = 1; i <= p; ++i)
		scanf("%d",&dest[i]);
	
	Dijkstra(1);
	
	for(i = 1 ; i <= p ; ++i)
		Dijkstra(dest[i]);
				
	
	
	printf("%d\n",ret(1 , 1 , p));
	
	
return 0;
}