#include <fstream>
#include <vector>
#include <queue>
#include <climits>

using namespace std;

struct nod
{
    int index;
    int cost;
    int nrk;

    nod(int index, int cost, int nrk)
    {
        this->index = index;
        this->cost = cost;
        this->nrk = nrk;
    }

    bool operator >(const nod &arg) const
    {
        if (this->cost > arg.cost)
        {
            return true;
        }
        return false;
    }
};

const int NMAX = 2000;
const int DPMAX = 1 << 15;

vector<pair<int ,int>> graf[1 + NMAX];
pair<bool, int> prieten[1 + NMAX];
int dp[1 + NMAX][DPMAX];

priority_queue<nod, vector<nod>, greater<nod>> q;

void dijkstra()
{
    dp[0][0] = 0;
    q.push(nod(1, 0, 0));

    while (!q.empty())
    {
        int nod_ = q.top().index;
        int cost_ = q.top().cost;
        int nrK_ = q.top().nrk;
        q.pop();

        if (cost_ > dp[nod_][nrK_]) continue;

        for (int i = 0; i < graf[nod_].size(); i++)
        {
            int vecin = graf[nod_][i].second;
            int cost = graf[nod_][i].first;

            if (prieten[vecin].first)
            {
                int copie = nrK_ | (1 << prieten[vecin].second);
                if (cost_ + cost < dp[vecin][copie])
                {
                    dp[vecin][copie] = cost_ + cost;
                    q.push(nod(vecin, cost_ + cost, copie));
                }
            }
            else
            {
                if (cost_ + cost < dp[vecin][nrK_])
                {
                    dp[vecin][nrK_] = cost_ + cost;
                    q.push(nod(vecin, cost_ + cost, nrK_));
                }
            }
        }
    }
}

int main()
{
    ifstream in("ubuntzei.in");
    ofstream out("ubuntzei.out");
    int n, m, k, x;
    int a, b, c;
    int nr = -1;

    in >> n >> m >> k;
    for (int i = 1; i <= k; i++)
    {
        in >> x;
        prieten[x].first = true;
        nr++;
        prieten[x].second = nr;
    }
    for (int i = 1; i <= m; i++)
    {
        in >> a >> b >> c;
        graf[a].push_back(make_pair(c, b));
        graf[b].push_back(make_pair(c, a));
    }

    for (int i = 1; i <= n; i++)
    {
        for (int j = 0; j <= ((1 << k) - 1); j++)
        {
            dp[i][j] = INT_MAX;
        }
    }

    dijkstra();

    out << dp[n][(1 << k) - 1] << '\n';

    return 0;
}