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

int n,m,k,i,j,t,a[2002][2002],x,y,ct,uz[2002],s[2002],minn=2000000000,aux,pc,pf;

vector <int> c;

int inf=2000000000;
int d[2002],p[2002],H[2002],vf;
int l;

queue < pair<int,int> > q;

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

void up(int k)
{
    int fiu=k,tata=k/2;
    while(tata>=1 && d[H[fiu]]<d[H[tata]])
    {
        swap(H[tata],H[fiu]);
        swap(p[H[tata]],p[H[fiu]]);
        tata=fiu;
        fiu/=2;
    }
}

void down(int k)
{
    int tata=k,fiu=2*k;
    while(fiu<=l)
    {
        if(fiu+1<=l && d[H[fiu]]>d[H[fiu+1]]) fiu++;
        if(d[H[tata]]>d[H[fiu]])
        {
            swap(H[tata],H[fiu]);
            swap(p[H[tata]],p[H[fiu]]);
            tata=fiu;
            fiu=2*tata;
        }
        else fiu=l+1;
    }
}

void dijkstra(int S)
{
    int i;
    for(i=1;i<=n;i++)
    {
        d[i]=inf;
        p[i]=-1;
    }
    d[S]=0;
    H[++l]=S;
    p[S]=1;

    while(l>0)
    {
        vf=H[1];
        swap(H[1],H[l]);
        p[H[1]]=1;
        l--;
        down(1);

        for(i=1;i<=n;i++)
            if(a[vf][i]!=0 && d[i]>d[vf]+a[vf][i])
            {
                d[i]=d[vf]+a[vf][i];
                if(p[i]!=-1)
                    up(p[i]);
                else
                {
                    H[++l]=i;
                    p[H[l]]=l;
                    up(l);
                }
            }
    }

    for(i=1;i<=n;i++)
    {
        a[S][i]=d[i];
        a[i][S]=d[i];
    }

}

int main()
{
    f>>n>>m;
    f>>k;
    for(i=1;i<=k;i++)
    {
        f>>x;
        c.push_back(x);
    }

    for(i=1;i<=n;i++)
    for(j=1;j<=n;j++)
        a[i][j]=1000000000;
    for(i=1;i<=n;i++)
        a[i][i]=0;

    for(i=1;i<=m;i++)
    {
        f>>x>>y>>ct;
        a[x][y]=ct;
        a[y][x]=ct;
    }

    dijkstra(1);
    for(i=0;i<c.size();i++)
        dijkstra(c[i]);
    dijkstra(n);

    if(k>0)
    {
		sort(c.begin(),c.end());
		pc=1;
		pf=n;
		minn=2000000000;
		do
        {
			aux=a[pc][c.front()]+a[c.back()][pf];

			for(i=0;i<(int)c.size()-1;i++)
				aux+=a[c[i]][c[i+1]];

			minn=min(minn,aux);
		} while(next_permutation(c.begin(),c.end()));

		g<<minn<<"\n";
	}
	else
		g<<a[1][n]<<"\n";

    f.close();
    g.close();
    return 0;
}