#include <queue>
#include <vector>
#include <fstream>
#include <cstring>
#define INF 600000000
using namespace std;
ifstream fin("ubuntzei.in");
ofstream fout("ubuntzei.out");

struct elem{
    int nod, cost;
};

struct cmp{
    bool operator()(elem a, elem b)
    {
        return a.cost>b.cost;
    }
};

struct muchie{
    int nod, cost;
};

vector <muchie> l[2001];

int n;
int v[30], viz[2001], d[20][2001], dp[100001][17];

priority_queue <elem, vector<elem>, cmp> pq;

void dijkstra(int poz)
{
    memset(viz, 0, sizeof(viz));
    pq.push({v[poz], 0});
    d[poz][v[poz]]=0;
    for(int i=1;i<=n;i++)
    {
        d[poz][i]=200000000;
    }
    d[poz][v[poz]]=0;
    while(!pq.empty())
    {
        int nod=pq.top().nod;
        int cost=pq.top().cost;
        pq.pop();
        if(viz[nod]==1)
        {
            continue;
        }
        viz[nod]=1;
        for(int i=0;i<l[nod].size();i++)
        {
            int vecin=l[nod][i].nod;
            int costvecin=l[nod][i].cost;
            if(d[poz][vecin]>d[poz][nod]+costvecin)
            {
                d[poz][vecin]=d[poz][nod]+costvecin;
                pq.push({vecin, d[poz][vecin]});
            }
        }
    }
}

int main()
{
    int m, k, i, j, p, x, y, c;
    fin>>n>>m;
    fin>>k;
    for(i=0;i<k;i++)
    {
        fin>>v[i];
    }
    for(i=1;i<=m;i++)
    {
        fin>>x>>y>>c;
        l[x].push_back({y, c});
        l[y].push_back({x, c});
    }
    if(k==0)
    {
        dijkstra(1);
        fout<<d[1][n];
        return 0;
    }
    else
    {
        for(i=0;i<k;i++)
        {
            dijkstra(i);
        }
    }
    int stare=(1<<k)-1;
    for(i=0;i<=stare;i++)
    {
        for(j=0;j<k;j++)
        {
            dp[i][j]=INF;
        }
    }
    for(i=0;i<k;i++)
    {
        dp[1<<i][i]=d[i][1];
    }
    for(i=1;i<=stare;i++)
    {
        for(j=0;j<k;j++)
        {
            if(dp[i][j]!=INF)
            {
                for(p=0;p<k;p++)
                {
                    if(j!=p&&(i>>p)&1==0)
                    {
                        int next=i+(1<<p);
                        dp[next][j]=max(dp[next][j], dp[i][j]+d[j][v[p]]);
                    }
                }
            }
        }
    }
    int mini=INF;
    for(i=0;i<k;i++)
    {
        mini=min(mini, dp[stare][i]+d[i][n]);
    }
//    for(i=1;i<=stare;i++)
//    {
//        for(j=0;j<k;j++)
//        {
//            fout<<dp[i][j]<<" ";
//        }
//        fout<<"\n";
//    }
    fout<<mini;
    return 0;
}