#include <bits/stdc++.h>
#define oo 1e9 + 1
using namespace std;

vector< pair<int, int> > L[2001];
int n, k;
int a[20][20]; /// a[i][j]=drumul minim de la i la j
    /// unde i si j sunt cele k noduri + nodurile 1 si n
int C[20]; /// aici memorez cele k noduri
int d[2001];
int dp[18][(1 << 16) + 2];
/**
dp[i][j] = costul minim al drumului de la nodul 1 la i
           trecand prin nodurile marcate cu 1 in
           reprezentarea lui j in baza 2
*/

           /// dist nod
priority_queue< pair<int, int> > Q;

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

void Citire()
{
    int m, i, x, y, cost;
    fin >> n >> m;
    fin >> k;
    for (i = 1; i <= k; i++)
        fin >> C[i];
    for (i = 1; i <= m; i++)
    {
        fin >> x >> y >> cost;
        L[x].push_back({y, cost});
        L[y].push_back({x, cost});
    }
    fin.close();
}

void Dijkstra(int s)
{
    int i, nod;
    Q.push({0, s});
    for(i = 1; i <= n; i++)
        d[i] = oo;
    d[s] = 0;
    while(!Q.empty())
    {
        nod = Q.top().second;
        Q.pop();
        for(auto w : L[nod])
            if(d[w.first] > d[nod] + w.second)
            {
                d[w.first] = d[nod] + w.second;
                Q.push({-d[w.first], w.first});
            }
    }
}

void ConstrMat()
{
    int i, j;
    for (i = 1; i <= k; i++)
    {
        Dijkstra(C[i]);
        for (j = 1; j <= k; j++)
            a[i][j] = d[C[j]];
        /// nodul 1 are linia 0
        a[0][i] = a[i][0] = d[1];
        /// nodul n are linia k+1
        a[k+1][i] = a[i][k+1] = d[n];
    }
}

void Dinamica()
{
    int i, j, p, D, x, M = oo;
    D = (1 << k);
    for (i = 0; i <= k + 1; i++)
        for (j = 0; j < D; j++)
            dp[i][j] = oo;

    dp[0][0] = 0;
    /// init
    for (i = 1; i <= k; i++)
        dp[i][1 << (i - 1)] = a[0][i];

    for (j = 1; j < D; j++)
        for (i = 1; i <= k; i++)
            if (j & (1 << (i - 1)))
                for (p = 1; p <= k; p++)
                    if ((j & (1 << (p - 1))) == 0)
                        dp[p][j + (1 << (p - 1))] = min(dp[p][j + (1 << (p - 1))], dp[i][j] + a[i][p]);

    M = oo;

    for(i = 1; i <= k; i++)
        M = min(M, dp[i][D - 1] + a[i][k + 1]);

    fout << M << "\n";
    fout.close();
}

int main()
{
    Citire();
    ConstrMat();
    Dinamica();
    return 0;
}