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

const int NMAX = 2e3 + 1;
const int INF = 1 << 30;

struct muchie
{
    int to,cost;
};

vector<vector<int>> dp;

struct elem
{
    int ind,nod;
    bool operator <(const elem a) const
    {
        return dp[ind][a.nod] < dp[ind][nod];
    }
};

vector<muchie> muchii[NMAX];
vector<int> prieteni;

vector<vector<int>> din(16,vector<int>(1 << 16,INF));

void dijkstra(int s,int n)
{
    dp[s].resize(n + 1,INF);
    dp[s][prieteni[s]] = 0;
    priority_queue<elem> pq;
    pq.push({s,prieteni[s]});

    while(!pq.empty())
        {
            elem a = pq.top(); pq.pop();
            for(auto it : muchii[a.nod])
                {
                    if(dp[s][it.to] > dp[s][a.nod] + it.cost)
                        {
                            dp[s][it.to] = dp[s][a.nod] + it.cost;
                            pq.push({s,it.to});
                        }
                }
        }
}

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

    int n,m,k,a,b,c,d;
    fin >> n >> m;
    fin >> k; prieteni.resize(k);
    for(auto &it : prieteni) fin >> it;
    while(m--)
        {
            fin >> a >> b >> c;
            muchii[a].push_back({b,c});
            muchii[b].push_back({a,c});
        }

    dp.resize(k);

    if(!k)
    {
        dp.resize(1);
        prieteni.emplace_back(1);
        dijkstra(0,n);

        fout << dp[0][n] << endl;
        return 0;
    }

    for(int i = 0 ; i < k ; i++) dijkstra(i,n);

    int masca = 1 << k;
    for(int p = 0 ; p < k ; p++) din[p][1 << p] = dp[p][1];
    for(int m = 1; m < masca ; m++)
        {
            for(int p = 0 ; p < k ; p++)
                {
                    if(din[p][m] == INF) continue;
                    for(int b = 0 ; b < k ; b++)
                        {
                            if(m & (1 << b)) continue;
                            din[b][m | (1 << b)] = min(din[b][m | (1 << b)],din[p][m] + dp[p][prieteni[b]]);
                        }
                }
        }

    int ans = INF;
    for(int t = 0 ; t < k ; t++)
        {
            ans = min(ans,din[t][masca - 1] + dp[t][n]);
        }

    fout << ans;


}