#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#define inf 2147000000
using namespace std;
ifstream f("team.in");
ofstream g("team.out");

 struct vec
 { int nd,cst; } el;

 struct comp
 {
   bool operator() (vec a,vec b)
   { return a.cst>b.cst; }
 };

 vector <int> v[505],c[505];
 priority_queue <vec,vector<vec>,comp> heap;
 queue <int> q;
 int p,n,m,nod[55],dmin[505],eq[505],dist[55][55],dp[55][55][55];

 void BellmanFord(int x,int ind)
 { int i,nod1,nod2;
    for(i=1;i<=n;i++)
     dmin[i]=inf;

     dmin[x]=0;
    el.nd=x; el.cst=0;
      heap.push(el);
     while(!heap.empty())
     { el=heap.top(); heap.pop();
           nod1=el.nd;
       if (dmin[el.nd]==el.cst)
        for(i=0;i<v[nod1].size();i++)
         {
            if (el.cst+c[nod1][i]<dmin[v[nod1][i]])
           {dmin[v[nod1][i]]=dmin[nod1]+c[nod1][i];
             el.nd=v[nod1][i]; el.cst=dmin[v[nod1][i]];
            heap.push(el);
           }
         }

     }



   for(i=1;i<=p+1;i++)
    {dist[ind][i]=dmin[nod[i]];

    }
 }

void Dinamica()
{ int i,j,x,y,mn,sol,len,res=inf;


   for(len=2;len<=p;len++)
    for(x=1;x<=p-len+1;x++)
    { y=x+len-1;

       for(i=x;i<=y;i++)
       {
         sol=0;
          if (i>x)
          { mn=inf;
            for(j=x;j<i;j++)
             mn=min(mn,dp[x][i-1][j]+dist[i][j]);
            sol+=mn;
          }

          if (i<y)
          { mn=inf;
            for(j=i+1;j<=y;j++)
             mn=min(mn,dp[i+1][y][j]+dist[i][j]);
            sol+=mn;
          }

         dp[x][y][i]=sol;
       }
    }

  for(i=1;i<=p;i++)
   res=min(res,dp[1][p][i]+dist[p+1][i]);

  g<<res<<"\n";
}

int main()
{ int i,x,y,cost;
    f>>p>>n>>m;

   for(i=1;i<=m;i++)
   { f>>x>>y>>cost;
      v[x].push_back(y);
      v[y].push_back(x);
      c[x].push_back(cost);
      c[y].push_back(cost);
   }

   for(i=1;i<=p;i++)
    f>>nod[i];



  nod[p+1]=1;

  for(i=1;i<=p+1;i++)
   BellmanFord(nod[i],i);

  Dinamica();
    return 0;
}