#include <stdio.h>
#include <vector>
#include <queue>

FILE* fin;
FILE* fout;

const int MAX_N = 2000;
const int MAX_K = 15;
const int INF = 1e9;

struct Edge {
  int v, c;
};

struct State {
  int u;
  int d;

  bool operator <(const State& rhs) const {
    return d > rhs.d;
  }
};

int n, k;
int nodes[MAX_K + 2];
std::vector<Edge> adj[MAX_N];
int dp[1 << MAX_K][MAX_K + 2];
int dist[MAX_N][MAX_N];

void dijkstra(int source) {
  for(int i = 0; i < n; i++) {
    dist[source][i] = INF;
  }
  std::priority_queue<State> pq;
  pq.push({source, 0});
  dist[source][source] = 0;
  while(!pq.empty()) {
    auto [u, d] = pq.top();
    pq.pop();
    if(d == dist[source][u]) {
      for(auto [v, c] : adj[u]) {
        int new_d = d + c;
        if(new_d < dist[source][v]) {
          pq.push({v, new_d});
          dist[source][v] = new_d;
        }
      }
    }
  }
}

int main() {
  fin = fopen("ubuntzei.in", "r");
  fout = fopen("ubuntzei.out", "w");

  int m;
  fscanf(fin, "%d%d%d", &n, &m, &k);

  nodes[0] = 0;
  nodes[k + 1] = n - 1;
  for(int i = 1; i <= k; i++) {
    fscanf(fin, "%d", &nodes[i]);
    nodes[i]--;
  }
  k += 2;

  for(int i = 0; i < m; i++) {
    int u, v, c;
    fscanf(fin, "%d%d%d", &u, &v, &c);
    u--;
    v--;
    adj[u].push_back({v, c});
    adj[v].push_back({u, c});
  }

  for(int u = 0; u < n; u++) {
    dijkstra(u);
  }

  for(int mask = 0; mask < (1 << k); mask++) {
    for(int i = 0; i < k; i++) {
      dp[mask][i] = INF;
    }
  }
  dp[1][0] = 0;
  for(int mask = 0; mask < (1 << k); mask++) {
    for(int i = 0; i < k; i++) {
      for(int j = 0; j < k; j++) {
        if(((mask >> i) & 1) && !((mask >> j) & 1)) {
          dp[mask | (1 << j)][j] = std::min(
            dp[mask | (1 << j)][j],
            dp[mask][i] + dist[nodes[i]][nodes[j]]
          );
        }
      }
    }
  }

  fprintf(fout, "%d\n", dp[(1 << k) - 1][k - 1]);

  fclose(fin);
  fclose(fout);

  return 0;
}