#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
 
const int NMAX = 2005;
const int INF = 0x3f3f3f3f;
const int KMAX = 16;

ifstream in("../ubuntzei.in");
ofstream out("../ubuntzei.out");
 
int n, m, k;
int c[NMAX], cost[NMAX][NMAX], d[NMAX], dp[1 << KMAX][KMAX];
queue<int> Q;

vector<pair<int, int>> Graf[NMAX];
 
void citire() 
{
	in >> n >> m >> k;
 
  for (int i = 0; i < k; i++)
    in >> c[i];
 
  c[k++] = n;
 
  for (int i = 1; i <= m; i++) 
	{
    int x, y, c;
    in  >> x >> y >> c;
    Graf[x].push_back({y, c});
    Graf[y].push_back({x, c});
	}
}
 
void bellman(int x) 
{
  fill(d + 1, d + n + 1, INF);
  d[x] = 0;
  Q.push(x);
 
  while (!Q.empty()) 
	{
		x = Q.front();
		Q.pop();
		for (auto y : Graf[x]) 
		{
		if (d[y.first] > d[x] + y.second) 
			{
				d[y.first] = d[x] + y.second;
				Q.push(y.first);
			}
		}
	}
}
 
void costuri() 
{
	for (int i = 0; i < k; i++) 
	{
		bellman(c[i]);
		for (int j = 0; j <= n; j++)
			cost[i][j] = d[j];
	}
}
 
void init() 
{
  for (int i = 0; i < (1 << k); i++)
    for (int j = 0; j < k; j++)
      dp[i][j] = INF;
 
  for (int i = 0; i < k; i++)
    dp[1 << i][i] = cost[i][1];
}
 
void hamilton(int drum) 
{
  for (int nod = 0; nod < k; nod++) 
	{
		if (drum & (1 << nod)) 
			{
				for (int vecin = 0; vecin < k; vecin++) 
					{
						if (drum & (1 << vecin)) 
							{
								dp[drum][nod] = min(dp[drum][nod], dp[drum ^ (1 << nod)][vecin] + cost[vecin][c[nod]]);
							}
					}
			}
	}
}
 
int main() {
	citire();
	costuri();
	init();
 
	for (int drum = 1; drum < (1 << k); drum++)
		hamilton(drum);
 
	out << dp[(1 << k) - 1][k - 1];
 
  return 0;
}