#include <bits/stdc++.h>
#define Dim 2007
#define Max 32800
using namespace std;
ifstream f("ubuntzei.in");
ofstream g("ubuntzei.out");
int T[Dim][Max],N,M,K,a,b,c;
int Numara[Dim];
bool city[Dim],viz[Dim][Max];
typedef pair<int,int> pii;

struct cmp
{
    bool operator()(pii X,pii Y)
    {
        if(T[X.first][X.second]>T[Y.first][Y.second]) return 1;
        else return 0;
    }
};

vector <pii> V[Dim];
priority_queue < pii,vector<pii>,cmp > minheap;

void Solve()
{
    viz[1][0]=1;
    minheap.push({1,0});
    T[1][0]=0;
    while(!minheap.empty())
    {
        pii val=minheap.top();
        minheap.pop();
        int nod=val.first,seq=val.second;
        viz[nod][seq]=0;

        for(unsigned int i=0;i<V[nod].size();i++)
        {
            int cost=V[nod][i].second;
            int vecin=V[nod][i].first;

            if(T[nod][seq]+cost<T[vecin][seq])
            {
                T[vecin][seq]=T[nod][seq]+cost;
                if(!viz[vecin][seq])
                {
                    viz[vecin][seq]=1;
                    minheap.push({vecin,seq});
                }
            }

            if(city[vecin])
            {
                int new_id;
                if( ( seq & ( 1<<(Numara[vecin]-1) ) )>0 )
                new_id=seq;
                else
                new_id=seq+( 1<<(Numara[vecin]-1) );

                if(T[nod][seq]+cost<T[vecin][new_id])
                {
                    T[vecin][new_id]=T[nod][seq]+cost;
                    if(!viz[vecin][new_id])
                    {
                        viz[vecin][new_id]=1;
                        minheap.push({vecin,new_id});
                    }
                }
            }
        }
    }
}

int main()
{
    f>>N>>M>>K;
    for(int i=1;i<=K;i++)
    {
        f>>a;
        city[a]=1;
        Numara[a]=i;
    }
    for(int i=1;i<=M;i++)
    {
        f>>a>>b>>c;
        V[a].push_back({b,c});
        V[b].push_back({a,c});
    }
    for(int i=1;i<=N;i++)
    for(int j=0;j<(1<<K);j++)
    T[i][j]=INT_MAX;

    Solve();
    g<<T[N][(1<<K)-1];

    return 0;
}