using namespace std;
#include <cstdio>
#include <cstring>
#include <vector>
#include <map>
#include <set>
#include <queue>

#define Nmax 512
#define Pmax 64
#define next first
#define cost second

int N, M, P, i, j, k, x, y, z, d;
vector< pair<int,int> > G[Nmax];
int D[Pmax], C[Nmax][Nmax], A[Nmax][Pmax][Pmax];
char W[Nmax];

inline int min(int a, int b) { return a<b?a:b; }

struct cmp{ bool operator()(const int &a, const int &b) { return C[ D[i] ][a] > C[ D[i] ][b]; } };

priority_queue<int, vector<int>, cmp> Q;

void citire()
{
 freopen("team.in","r",stdin);
 scanf("%d %d %d", &P, &N, &M);
 for (i=0; i<M; ++i)
     {
      scanf("%d %d %d", &x, &y, &z);
      G[x].push_back( make_pair(y,z) );
      G[y].push_back( make_pair(x,z) );
     }
 for (i=1; i<=N; ++i)
     scanf("%d", D+i);
}

void dijkstra(int S)
{
 int nod;
 vector< pair<int,int> >::iterator it;
 
 memset(W, 0, sizeof(W));
 memset(C[S], 0x3f3f, sizeof(C[S]));
 C[S][S] = 1;
 Q.push(S);
 while ( !Q.empty() )
       {        
        nod = Q.top();
        Q.pop();
        if (W[nod]) continue;
        W[nod] = 1;
        for (it=G[nod].begin(); it<G[nod].end(); ++it)
            if (C[S][nod] + it->cost < C[S][it->next])
               {
                C[S][it->next] = C[S][nod] + it->cost;
                Q.push(it->next);
               }
       }
}

void dinamica()
{
 D[++P] = 1;
 for (i=1; i<=P; ++i)
     for (j=1; j<=P; ++j)
         for (k=j; k<=P; ++k)
             A[D[i]][j][k] = 0x3f3f3f3f;
 for (i=1; i<=P; ++i)
     for (j=1; j<P; ++j)
         A[D[i]][j][j] = C[D[j]][D[i]] - 1;
 
 for (x=2; x<P; ++x)
  for (d=1; d<=P; ++d)
     for (i=1; i<P; ++i)
         {
          j = i + x - 1;
          if (j >= P) break;
          for (k=i; k<=j; ++k)
              A[D[d]][i][j] = min(A[D[d]][i][j], A[D[k]][i][k-1] + A[D[k]][k+1][j] + C[D[k]][D[d]] - 1);
         }
}

int main()
{
 freopen("team.out","w",stdout);
 citire();
 
 for (i=1; i<=P; ++i)
    if (! C[D[i]][D[i]]) dijkstra(D[i]);
 
 dinamica();
 
 printf("%d\n",A[1][1][P-1]);
 return 0;
}