#include <fstream>
#include <vector>
#include <cstring>
#include <algorithm>
#include <algorithm>
#include <cmath>
#include <queue>
using namespace std;
ifstream fin("ubuntzei.in");
ofstream fout("ubuntzei.out");
#define dim 2005
#define lim 10005
#define inf 0x3f3f3f3f
#define pb push_back
#define mp make_pair
int n, m, K;
vector <pair <int,int> > v[dim];
int d[dim], sate[dim], mat[20][20];
int viz[dim], best[300][300];


struct cmp
{
	bool operator () (const int &a, const int &b)
	{
		return d[a]>d[b];
	}
};priority_queue <int, vector <int>, cmp> Heap;

void read()
{
	int a, b, c, i;
	fin>>n >>m;
	fin>>K;
	
	sate[0]=1;sate[K+1]=n;
	for(i=1;i<=K;++i)
		fin>>sate[i];
	for(i=1;i<=m;++i)
	{
		fin>>a >>b >>c;
		v[a].pb(mp(b,c));
		v[b].pb(mp(a,c));
	}
}

void dijkstra(int nod)
{
	
	memset(viz,0,sizeof(viz));
	memset(d,inf,sizeof(viz));
	
	d[nod]=0;
	Heap.push(nod);
	
	while(!Heap.empty())
	{
		int re=Heap.top();
		Heap.pop();
		viz[re]=0;
		for(int k=0;k<v[re].size();++k)
			if(d[re]+v[re][k].second<d[v[re][k].first])
			{
				d[v[re][k].first]=d[re]+v[re][k].second;
				if(viz[v[re][k].first]==0)
				{
					Heap.push(v[re][k].first);
					viz[v[re][k].first]=1;
				}
			}
	}
}
	

void solve()
{
	int i,j;
	for(i=0;i<=K;++i)
	{
		dijkstra(sate[i]);
		for(j=1;j<=K+1;++j)
			mat[i][j]=d[sate[j]];
	}
	
	if(K==0)
	{
		fout<<mat[0][1];
		return ;
	}
	
		memset(best,inf,sizeof(best));
		int stare, oldstare;
			
			for(stare=1;stare<(1<<K);++stare)
				for(i=1;i<=K;++i)
					if(stare&(1<<(i-1)))
					{
						oldstare=stare^(1<<(i-1));
						
						if(oldstare==0)
							best[stare][i]=mat[0][i];
						else
							for(j=1;j<=K;++j)
								if(oldstare&(1<<(j-1)))
									best[stare][i]=min(best[stare][i], best[oldstare][j] + mat[i][j]);
				}
	
	
	int nr_min=inf;
	for(i=1;i<=K;++i)
		nr_min=min(nr_min,best[(1<<K)-1][i]+mat[i][K+1]);
	fout<<nr_min;
}

int main()
{
	read();
	solve();
	
	return 0;
}