#include <bits/stdc++.h>
using namespace std;

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

struct muchie
{
    int node, cost;
};

struct heap
{
    int node, cost;
    bool operator < (const heap &num) const
    {
        return cost > num.cost;
    }
};

const int NMAX = 2005, INF = 1e9;
int n, m, k, ans = INT_MAX;
bool frq[NMAX];
int adj[NMAX][NMAX];
int loca[NMAX], arr[NMAX];
vector<muchie>g[NMAX];

inline void dijkstra(int start)
{
    int dist[NMAX];
    priority_queue<heap>pq;
    pq.push({start, 0});
    adj[start][start] = 0;

    while(!pq.empty())
    {
        int curr_node = pq.top().node;
        pq.pop();

        for(auto new_node : g[curr_node])
        {
            if(adj[start][new_node.node] > adj[start][curr_node] + new_node.cost)
            {
                adj[start][new_node.node] = adj[start][curr_node] + new_node.cost;
                pq.push({new_node.node, adj[start][new_node.node]});
            }
        }
    }
}

inline void backtracking(int poz)
{
    if(poz == k + 1)
    {
        int s = 0;
        s += adj[arr[1]][1];
        s += adj[arr[k]][n];
        for(int i = 1; i < k; ++ i)
        {
            s+= adj[arr[i]][arr[i+1]];
        }
        ans = min(ans, s);
    }
    else
    {
        for(int i = 1; i <= k; ++ i)
        {
            if(!frq[i])
            {
                frq[i] = 1;
                arr[poz] = loca[i];
                backtracking(poz + 1);
                frq[i] = 0;
            }
        }
    }
}

int main()
{
    fin >> n >> m >> k;

    for(int i = 1; i <= k; ++ i)
        fin >> loca[i];

    for(int i = 1; i <= m; ++ i)
    {
        int x, y, cost;
        cin >> x >> y >> cost;
        g[x].push_back({y, cost});
        g[y].push_back({x, cost});
    }

    for(int i = 0; i < NMAX; ++ i)
        for(int j = 0; j < NMAX; ++ j)
            adj[i][j] = INF;

    for(int i = 1; i <= k; ++ i)
    {
        dijkstra(loca[i]);
    }

    backtracking(1);

    fout << ans;
}