#include <fstream>
#include <vector>
#include <bitset>
#include <algorithm>
#include <queue>
#define Nmax 2010
#define Kmax 18
#define inf 99999999
using namespace std;

ifstream cin("ubuntzei.in");
ofstream cout("ubuntzei.out");

struct Edge
{
    int next;
    int cost;
};

vector<Edge> Graph[Nmax];
vector<Edge> Graph2[Nmax];
vector<int> loc;
vector<vector<int>> dist(Nmax);
vector<vector<int>> dist_fin(Kmax, vector<int>(1 << Kmax, inf));

int rez = inf;
int n, m, k;

void Dijkstra(int start)
{
    queue<int> q;
    q.push(start);
    dist[start] = vector<int>(Nmax, inf);
    dist[start][start] = 0;

    while(!q.empty())
    {
        int node = q.front();
        q.pop();

        for(const Edge& edge : Graph[node])
        {
            if(dist[start][edge.next] > dist[start][node] + edge.cost)
            {
                dist[start][edge.next] = dist[start][node] + edge.cost;
                q.push(edge.next);
            }
        }
    }
}

void Dijkstra2(int start)
{
    queue<pair <int, bitset<Kmax>>> q;
    bitset<Kmax> a;
    a.set(1);
    q.push({start, a});
    dist_fin[1][(int)a.to_ullong()] = 0;

    while(!q.empty())
    {
        int node = q.front().first;
        bitset<Kmax> viz = q.front().second;
        q.pop();

        //cout << "\n\n" <<  node << ' ' << viz.to_string() << ' ' << dist_fin[node][(int)viz.to_ullong()] << '\n';
        for(const Edge& edge : Graph2[node])
        {
            bitset<Kmax> viz2 = viz;
            viz2.set(edge.next);
            //cout << edge.next << ' ' << edge.cost << ' ' << viz2.to_string() << ' ' << dist_fin[edge.next][(int)viz2.to_ulong()] << ' ';

            if(dist_fin[edge.next][(int)viz2.to_ulong()] > dist_fin[node][(int)viz.to_ulong()] + edge.cost)
            {
                //cout << "DA  ";
                dist_fin[edge.next][(int)viz2.to_ulong()] = dist_fin[node][(int)viz.to_ulong()] + edge.cost;
                q.push({edge.next, viz2});
            }

            //cout << '\n';
        }
    }
}


int main()
{
    cin >> n >> m;
    cin >> k;
    bitset<Kmax> proba;

    for(int i = 0, a; i<k; i++)
    {
        cin >> a;
        loc.push_back(a);
    }
    loc.push_back(1);
    loc.push_back(n);

    sort(loc.begin(), loc.end());

    for(int i = 0, a, b, c; i<m; i++)
    {
        cin >> a >> b >> c;
        Graph[a].push_back({b, c});
        Graph[b].push_back({a, c});
    }

    for(int i = 0; i<loc.size(); i++)
    {
        Dijkstra(loc[i]);
        proba.set(i+1);
    }


        for(int i = 0; i<loc.size(); i++)
            for(int j = i+1; j<loc.size(); j++)
            {
                int n1 = loc[i];
                int n2 = loc[j];
                int cost = dist[n1][n2];

                Graph2[i+1].push_back({j+1, cost});
                Graph2[j+1].push_back({i+1, cost});
                //cout << i+1 << ' ' << j+1 << ' ' << cost << '\n';
            }

    Dijkstra2(1);
    int N = loc.size();

    cout << dist_fin[N][(int)proba.to_ulong()];


}