#include <fstream>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;

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

const int N=2005;
const int inf=0x3f3f3f3f;

int d[N],n,k;
bool use[N];
int h[1<<18][20];
int c[20];
int nr[20];




struct nod
{
	int x,dist;
	nod(int _x,int _dist)
	{
		x=_x;
		dist=_dist;
	}

	nod()
	{
		x=0;
		dist=0;
	}

	bool operator < (const nod &x) const
	{
		return dist > x.dist;
	}
};

vector <nod> v[N];
nod a[20][20];

inline int min(int a,int b)
{
	if(a<b)
        return a;
    return b;
}

void dijkstra (int start)
{
	memset(use, false, sizeof(use));
	memset(d,inf, sizeof(d));
	int x1,y,dis;
	d[start]=0;

	priority_queue <nod> q;

	q.push(nod(start,d[start]));

	while(!q.empty())
	{
		x1=q.top().x;
		q.pop();

		if(use[x1])
			continue;
		use[x1]=true;

		for(vector <nod> :: iterator it=v[x1].begin();it!=v[x1].end(); it++)
		{
			y=it->x;
			dis=it->dist+d[x1];
			if(d[y]>dis)
			{
				d[y]=dis;
				q.push(nod(y,dis));
			}
		}
	}
}


void hamilton()
{
	int i,j;

	memset(h,inf,sizeof(h));
	h[1][0]=0;

	for(i=2;i<=(1<<(k+1))-1;i++)
	{
		for(j=0;j<=k;j++)
		{
			if(i&(1<<j))
			{
				//for(vector <nod> :: iterator it=a[j].begin();it!=a[j].end();it++)
				for(k=1; k<=nr[j]; k++)
				{
				    int vrf = a[j][k].x, dst = a[j][k].dist;
				    if(i & (1<<vrf))
                        h[i][j]=min(h[i][j],h[i^(1<<j)][vrf]+dst);
				}
					//if(i& (1<< (it->x) ) )
						//h[i][j]=min(h[i][j],h[i^(1<<j)][it->x]+it->dist);
			}
		}
	}


}

int main()
{
	int m,i,x1,y,dis,j;

	in>>n>>m;
	in>>k;

	for(i=1;i<=k;i++)
		in>>c[i];

	while(m--)
	{
		in>>x1>>y>>dis;
		v[x1].push_back(nod(y,dis));
		v[y].push_back(nod(x1,dis));
	}


    dijkstra(1);

    if(k==0)
    {
        out<<d[n];
        return 0;
    }

    c[0]=1;
	c[k+1]=n;
	k++;

    for(j=1;j<k;j++)
		{
			if(d[c[j]]!=inf)
			{
				a[j][++nr[j]]=nod(0,d[c[j]]);
				a[0][++nr[0]]=nod(j,d[c[j]]);
			}
		}

	for(i=1;i<k;i++)
	{
		dijkstra(c[i]);
		for(j=1;j<=k;j++)
		{
			if(d[c[j]]!=inf && i!=j)
            {
				a[j][++nr[j]]=nod(i,d[c[j]]);
				a[i][++nr[i]]=nod(j,d[c[j]]);
            }
		}

	}

	hamilton();

	out<<h[(1<<(k+1))-1][k];


	return 0;
}