#include <iostream>
#include <fstream>
#include <algorithm>
#include <queue>
#define inf 2e8
using namespace std;
int n,a[2013][2013];
void bellman(int st, int d[])
{
    int nod,i;
    queue <int> q;
    q.push(st);
    while (!q.empty())
    {
        nod=q.front();
        q.pop();
        for (i=1;i<=n;i++)
            if (a[nod][i])
                if (i!=st)
                    if (d[i]==0 || d[i]>d[nod]+a[nod][i])
                    {
                        d[i]=d[nod]+a[nod][i];
                        q.push(i);
                    }
    }
}
int c[20],d[20][2013],cost[20][33000]={inf},m,k,dd[2013];
int min (int q,int w)
{
    if (q<w)
        return q;
    return w;
}
int main()
{
    int x,y,z,i,j;
    fstream f,g;
    f.open("ubuntzei.in",ios::in);
    g.open("ubuntzei.out",ios::out);
    f>>n>>m;
    f>>k;
    for (i=0;i<k;i++)
        f>>c[i];
    for (i=1;i<=m;i++)
    {
        f>>x>>y>>z;
        a[x][y]=a[y][x]=z;
    }


    bellman(1,dd);
    if (k==0)
    {
        g<<dd[n];
        return 0;
    }
    for (i=0;i<k;i++)
        bellman(c[i],d[i]);
    int s,nrsub=1<<k;
    for (s=1;s<nrsub;s++)
    {
        for (i=0;i<k;i++)
            if (s==(1<<i))
            {
                cost[i][s]=dd[c[i]];
                break;
            }
        if (i<k) continue;
        for (i=0;i<k;i++)
        {
            cost[i][s]=1<<29;
            for (j=0;j<k;j++)
                if(s&(1<<j) && j!=i)
                    cost[i][s]=min(cost[j][s-(1<<i)]+d[j][c[i]],cost[i][s]);// ??
        }
    }
    int Min=1<<29;
    for (i=0;i<k;i++)
        Min=min(Min,cost[i][nrsub-1]+d[i][n]);
    g<<Min;
}


// Filip Buruiana
/*
#include <stdio.h>
#include <vector>
#include <set>

using namespace std;

#define minim(a, b) ((a < b) ? a : b)
#define INF 999999999
#define KMAX 15
#define NMAX 10005
#define pii pair<int, int>
#define f first
#define s second
#define mp make_pair
#define pb push_back

int N, M, K, C[KMAX];
int source[NMAX], path[KMAX][NMAX];
vector<pii> G[NMAX];
int pd[1<<KMAX][KMAX];
set<pii> q;

inline int bit(int x, int nr)
{ return (x & (1<<nr)) != 0; }

void dijkstra(int sursa, int *sol)
{
	int i, vec;
	for (i = 1; i <= N; ++i)
		sol[i] = INF;
	sol[sursa] = 0;
	q.clear();
	for (i = 1; i <= N; ++i)
		q.insert(mp(sol[i],i));
	for (i = 1; i < N; ++i)
	{
		pii top = *q.begin();
		q.erase(q.begin());
		int nod = top.s;
		if (sol[nod] < top.f)  continue;
		for (size_t j = 0; j < G[nod].size(); ++j)
			if (sol[vec = G[nod][j].f] > sol[nod] + G[nod][j].s)
			{
				sol[vec] = sol[nod] + G[nod][j].s;
				q.insert(mp(sol[vec], vec));
			}
	}
}

int main()
{
	int i, j, k, newCost;

	freopen("ubuntzei.in", "r", stdin);
	freopen("ubuntzei.out", "w", stdout);

	scanf("%d %d %d", &N, &M, &K);
	for (i = 0; i < K; ++i)
		scanf("%d", &C[i]);

	for (; M; --M)
	{
		scanf("%d %d %d", &i, &j, &k);
		G[i].pb(mp(j,k));
		G[j].pb(mp(i,k));
	}

	dijkstra(1, source);
	if (K == 0)
	{
		printf("%d\n", source[N]);
		return 0;
	}

	for (i = 0; i < K; ++i)
		dijkstra(C[i], path[i]);

	for (i = 1; i < (1<<K); ++i)
	{
		for (j = 0; j < K; ++j)
			if (i == (1<<j))
				break;
		if (j < K && i == (1<<j))
		{
			pd[i][j] = source[C[j]];
			continue;
		}

		for (j = 0; j < K; ++j)
		{
			pd[i][j] = INF;
			if (bit(i,j))
				for (k = 0; k < K; ++k)
					if (k != j && bit(i, k))
					{
						newCost = pd[i-(1<<j)][k] + path[k][C[j]];
						pd[i][j] = minim(pd[i][j], newCost);
					}
		}
	}

	int bst = INF;
	for (i = 0; i < K; ++i)
		bst = minim(bst, pd[(1<<K)-1][i] + path[i][N]);

	printf("%d\n", bst);

	return 0;
}

*/