#include <fstream>
#include <vector>
#include <queue>

#define nMax 1001
#define kMax 16
#define confMax (1 << 15)
#define INF 1000000000
#define pb push_back
#define mkp make_pair
#define x first
#define y second

using namespace std;

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

int n, m, nrMust;
int dist[kMax][nMax], city[kMax];
long long dp[confMax][kMax];
vector<pair<int, int> > G[nMax];
priority_queue<pair<int, int>, vector<pair<int, int> >, greater<pair<int, int> > > pQueue;

void dijkstra(int node, int dist[])
{
    for(int i=1; i<=n; i++)
        dist[i]=INF;
    dist[node]=0;
    pQueue.push(mkp(dist[node], node));

    while(!pQueue.empty())
    {
        int node=pQueue.top().y, d=pQueue.top().x;
        pQueue.pop();
        if(d!=dist[node])
            continue;
        for(vector<pair<int, int> >::iterator it=G[node].begin(); it!=G[node].end(); it++)
        {
            int fiu=it->first, cost=it->second;
            if(dist[fiu]>dist[node]+cost)
            {
                dist[fiu]=dist[node]+cost;
                pQueue.push(mkp(dist[fiu], fiu));
            }
        }
    }
}

int main()
{
    int a, b, c;
    fin>>n>>m>>nrMust;
    for(int i=0; i<nrMust; i++)
        fin>>city[i];

    for(int i=1; i<=m; i++)
    {
        fin>>a>>b>>c;
        G[a].pb(mkp(b, c));
        G[b].pb(mkp(a, c));
    }

    dijkstra(1, dist[nrMust]);
    for(int i=0; i<nrMust; i++)
        dijkstra(city[i], dist[i]);
    if(nrMust==0)
    {
        fout<<dist[nrMust][n];
        return 0;
    }

    int limit=(1 << nrMust)-1;
    for(int i=0; i<=limit; i++)
        for(int j=0; j<nrMust; j++)
            dp[i][j]=INF;

    for(int i=0; i<nrMust; i++)
        dp[1 << i][i]=dist[nrMust][city[i]];

    for(int conf=1; conf<limit; conf++)
        for(int i=0; i<nrMust; i++)
            if(conf & (1 << i))
                for(int j=0; j<nrMust; j++)
                    if(i!=j && !(conf & (1 << j)))
                        dp[conf | (1 << j)][j]=min(dp[conf | (1 << j)][j], dp[conf][i]+dist[i][city[j]]);

    long long Sol=2000000000000000;
    for(int i=0; i<nrMust; i++)
        Sol=min(Sol, dp[limit][i]+dist[i][n]);
    fout<<Sol;


}