#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] , used[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 , j;
	
	if(done[nod]) return;
	done[nod] = true;
	
	memset(used, 0 , sizeof(used));
	
	for(i = 1; i <= n; ++i)
		d[nod][i] = inf;
	
	d[nod][nod] = 0;
	
	for(i = 1; i <= n; ++i) {
		
		int minn = inf , ind = 0;
		
		for(j = 1; j <= n; ++j)
			if(!used[j] && d[nod][j] < minn) {
				minn = d[nod][j];
				ind = j;
			}
			
		used[ind] = true;
		
		for(j = 0; j < G[ind].size(); ++j)
			if(d[nod][ind] + C[ind][j] < d[nod][G[ind][j]])
				d[nod][G[ind][j]] = d[nod][ind] + C[ind][j];
	}
}

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;
}