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

#define x first
#define y second

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

int x,N;
int n,m,k,i,a,b,l,j;
vector<pair<int,int> > v[2005];
int w[20];
int dist[2005];
queue<int> q;
int ma[2005][2005],cost[20][20];

vector<int> vhamilton[20];
int dp[1<<18][20];

void belman(int nod)
{
    int i;
    pair<int,int> aux2;
    int aux;
    for(i=1;i<=n;++i)
        dist[i]=1<<30;
    dist[nod]=0;
    q.push(nod);
    while(!q.empty())
    {
        aux=q.front();
        q.pop();
        for(i=0;i<(int)v[aux].size();++i)
        {
            aux2=v[aux][i];
            if(dist[aux2.x]>dist[aux]+aux2.y)
            {
                dist[aux2.x]=dist[aux]+aux2.y;
                q.push(aux2.x);
            }
        }
    }
    for(i=1;i<=n;++i)
    {
        ma[nod][i]=dist[i];
        ma[i][nod]=dist[i];
    }
}

int main()
{
    fin>>n>>m>>k;
    for(i=1;i<=k;++i)
    {
        fin>>w[i];
    }
    w[k+1]=1;
    w[k+2]=n;
    for(i=1;i<=m;++i)
    {
        fin>>a>>b>>l;
        v[a].push_back(make_pair(b,l));
        v[b].push_back(make_pair(a,l));
    }
    for(i=1;i<=k+2;++i)
        belman(w[i]);

    for(i=0;i<k+2;++i)
        for(j=0;j<k+2;++j)
        {
            cost[i][j]=ma[w[i+1]][w[j+1]];
        }
        N=k+2;
        for(i=0;i<N;++i)
            for(j=0;j<N;++j)
            vhamilton[i].push_back(j),vhamilton[j].push_back(i);

        for(i=0;i<1<<N;++i)
            for(j=0;j<N;++j)
            dp[i][j]=1<<30;
        dp[1][0]=0;

            for(i=1;i<1<<N;++i)
                for(j=0;j<N;++j)
            {
                if(i&(1<<j))
                {
                   //for(k=0;k<(int)vhamilton[j].size();++k)
                    for(x=0;x<N;++x)
                    {
                       // x=vhamilton[j][k];
                        if(i&(1<<x)&&x!=j)
                        dp[i][j]=min(dp[i][j],dp[i^(1<<j)][x]+cost[x][j]);
                    }
                }
            }
            fout<<dp[(1<<N)-1][N-1];






    return 0;
}