#include<cstdio>
#include<algorithm>
#include<vector>
#include<queue>
#include<functional>
using namespace std;
typedef long long weight;
weight const infty = 0x3fffffffffffff;
typedef pair<weight,int> edge;
//行列形式(|V|<1e3)
class SmallGraph{
private:
    int numVertex;
    weight *adj;   //adj[numVertex*a+b]=(i->j)の重み
public:
    SmallGraph(int v){
        numVertex=v;
        adj=new weight[v*v];
    }
    ~SmallGraph(){
        delete[] adj;
    }
    void initialize(weight w=infty,weight selfw=0){
        for(int i=0;i<numVertex*numVertex;i++)adj[i]=w;
        for(int i=0;i<numVertex;i++)adj[i*numVertex+i]=selfw;
    }
    void setWeight(int i,int j,weight w,bool isDirected=false){
        adj[i*numVertex+j]=w;
        if(!isDirected)adj[j*numVertex+i]=w;
    }
    //始点sからの最短経路長l[]
    //応用：負の閉路が存在する\iff bellman_fordのあとにrelaxingできる
    //応用：sからtへ向かう負の閉路が存在する\iff bellman_fordを2回してl[t]が更新される
    void bellman_ford(weight l[],int s){
        for(int i=0;i<numVertex;i++)l[i]=infty;
        l[s]=0;
        for(int rep=0;rep<numVertex;rep++){
            if(!relaxing(l))break;
        }
    }
    bool relaxing(weight l[]){
        bool relaxed=false;
        for(int i=0;i<numVertex;i++){
            for(int j=0;j<numVertex;j++){
                if(l[j]>l[i]+adj[i*numVertex+j]){
                    l[j]=l[i]+adj[i*numVertex+j];
                    relaxed=true;
                }
            }
        }
        return relaxed;
    }
    //始点sから全頂点を通る最短経路path[]
    //Held-Karpのアルゴリズム, 計算量O(n^2 2^n)
    weight shortest_hamilton_path(int path[],int s,bool isLoop=false){
        //bitDP: dp[numVertex*S+i]=(Sのすべての頂点を経由してiに到達したときの最小経路長)
        int dpsize=(1<<numVertex)*numVertex;
        weight *dp=new weight[dpsize];
        int *prev=new int[dpsize];
        //初期化
        for(int k=0;k<dpsize;k++)dp[k]=infty;
        for(int i=0;i<numVertex;i++)dp[(1<<i)*numVertex+i]=adj[s*numVertex+i];
        //DPの計算
        for(int S=0;S<(1<<numVertex);S++){
            //i\in Sなら、dp[S\cup {j}][j]<=dp[S][i]+adj[i][j]が必要
            for(int i=0;i<numVertex;i++){
                if((S&(1<<i))!=0){
                    for(int j=0;j<numVertex;j++){
                        if(dp[(S|(1<<j))*numVertex+j]>dp[S*numVertex+i]+adj[i*numVertex+j]){
                            dp[(S|(1<<j))*numVertex+j]=dp[S*numVertex+i]+adj[i*numVertex+j];
                            prev[(S|(1<<j))*numVertex+j]=i;
                        }
                    }
                }
            }
        }
        int maxS=(1<<numVertex)-1;
        //ループの最短経路を求めるときは、dp[maxS][i]たちにadj[i][s]を加えてループの距離を出す
        if(isLoop){
            for(int i=0;i<numVertex;i++)dp[maxS*numVertex+i]+=adj[i*numVertex+s];
        }
        //pathを後ろから構成
        weight *dp_maxS=dp+maxS*numVertex;
        int lastT=min_element(dp_maxS,dp_maxS+numVertex)-dp_maxS;
        int nowS=maxS, nowT=lastT;
        for(int nowV=numVertex-1;nowV>=0;nowV--){
            path[nowV]=nowT;
            int newS=nowS^(1<<nowT);
            nowT=prev[nowS*numVertex+nowT];
            nowS=newS;
        }
        if(isLoop){
            path[numVertex]=path[0];
        }
        //答えの出力
        weight ans=dp[maxS*numVertex+lastT];
        delete[] dp;
        delete[] prev;
        return ans;
    }
    //始点を決めない、全頂点を通る最短経路path[], 計算量O(n^2 2^n)
    //ループとしての最短経路をとって、一番重い場所で切る
    weight shortest_hamilton_path(int path[]){
        weight allw=shortest_hamilton_path(path,0,true), maxw=adj[path[0]*numVertex+path[1]];
        int maxi=1;
        for(int i=2;i<=numVertex;i++){
            if(maxw<adj[path[i-1]*numVertex+path[i]]){
                maxw=adj[path[i-1]*numVertex+path[i]];
                maxi=i;
            }
        }
        int *new_path = new int[numVertex];
        for(int i=0;i<numVertex;i++)new_path[i]=path[(maxi+i)%numVertex];
        for(int i=0;i<numVertex;i++)path[i]=new_path[i];
        delete[] new_path;
        return allw-maxw;
    }
    weight shortest_hamilton_path_naive(int path[]){
        int *thispath=new int[numVertex];
        for(int i=0;i<numVertex;i++)thispath[i]=i;
        weight mincost=infty;
        do{
            weight thiscost=0;
            for(int i=1;i<numVertex;i++)thiscost+=adj[thispath[i-1]*numVertex+thispath[i]];
            if(mincost>thiscost){
                mincost=thiscost;
                for(int i=0;i<numVertex;i++)path[i]=thispath[i];
                path[numVertex]=thispath[0];
            }
        }while(next_permutation(thispath,thispath+numVertex));
        delete[] thispath;
        return mincost;
    }
    void print(){
        printf("numVertex: %d\n",numVertex);
        for(int i=0;i<numVertex;i++){
            for(int j=0;j<numVertex;j++){
                printf("%3lld ",adj[i*numVertex+j]);
            }
            printf("\n");
        }
    }
};
weight w[8][201];
int main(){
    int n,m,r,ri[8],a,b,c,l[10];
    scanf("%d%d%d",&n,&m,&r);
    SmallGraph g(n+1);
    g.initialize();
    for(int i=0;i<r;i++)scanf("%d",&ri[i]);
    for(int i=0;i<m;i++){
        scanf("%d%d%d",&a,&b,&c);
        g.setWeight(a,b,c);
    }
    for(int i=0;i<r;i++)g.bellman_ford(w[i],ri[i]);
    SmallGraph h(r);
    h.initialize();
    for(int i=0;i<r;i++){
        for(int j=i+1;j<r;j++){
            h.setWeight(i,j,w[i][ri[j]]);
        }
    }
    printf("%lld",h.shortest_hamilton_path_naive(l));
    //printf("%lld",h.shortest_hamilton_path(l));
    return 0;
}

Measured memory_bytes: 512