#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <queue>
#include <fstream>

using namespace std;

ifstream fin("ubuntzei.in");
ofstream fout("ubuntzei.out");
using VI = vector<int>;
using VVI = vector<VI>;
using VPI = vector<pair<int, int>>;
using PI = pair<int, int>;
using VVPI = vector<VPI>;
using VB = vector<bool>;
VVPI G;
const int INF = 0x3f3f3f;
int n, k, e;
void Dijkstra(int r, VI& d)
{
    VB mark(n + 1);
    priority_queue<PI, VPI, greater<PI>> Q;
    Q.emplace(0, r);
    d[r] = 0;
    int u;
    while (!Q.empty())
    {
        u = Q.top().second;
        Q.pop();

        if (mark[u])
            continue;

        mark[u] = true;

        for (auto i : G[u])
        {
            if (d[i.first] > d[u] + i.second)
            {
                d[i.first] = d[u] + i.second;
                Q.emplace(d[i.first], i.first);
            }
        }
    }
}


int main()
{

    fin >> n >> e;
    fin >> k;
    VI prieteni(k + 1);
    G = VVPI(n + 1);
    for (int i = 1;  i <= k; ++i)
    {
        fin >> prieteni[i];
    }
    int fir, sec, val;
    for (int i = 1; i <= e; ++i)
    {
        fin >> fir >> sec >> val;
        G[fir].emplace_back(sec, val);
        G[sec].emplace_back(fir, val);
    }

    VVI dist(k + 1, VI(n + 1, INF));

    for (int i = 1; i <= k; ++i)
    {
        Dijkstra(prieteni[i], dist[i]);
    }



    VVPI dp = VVPI(k + 1, VPI(k + 1 , {INF, INF}));

    for (int i = 1; i <= k; ++i)
    {
        dp[1][i].first = dist[i][1];
        dp[1][i].second = (1 << i);
    }

    for (int poz = 2; poz <= k; ++poz)
    {
        for (int last = 1; last <= k; ++last)
        {
            for (int i = 1; i <= k; ++i)
            {
                if ((dp[poz - 1][last].second & (1 << i)) == 0 &&
                    dp[poz][i].first > dp[poz - 1][last].first + dist[last][i])
                {
                    dp[poz][i].first = dp[poz - 1][last].first + dist[last][prieteni[i]];
                    dp[poz][i].second = (dp[poz - 1][last].first | (1 << i));
                }
            }
        }
    }

    int mi = INF;

    for (int i = 1; i <= k; ++i)
    {
        mi = min(mi, dp[k][i].first + dist[i][n]);
    }

    fout << mi;
}