#include <bits/stdc++.h>
using namespace std;

ifstream fin("gather.in");
ofstream fout("gather.out");

struct edge{
  int dest, cost, d;
};

struct node{
  vector<edge> vec;
};

vector<node> g;

struct lols{
  int poz, c;
};

bool operator<(lols a, lols b){
  return a.c>b.c;
}

vector<int> dijkstra(int s, int d, int n){
  d--;
  priority_queue<lols> q;
  q.push({s, 1});
  vector<int> sol(n+1);
  while(!q.empty()){
    auto x=q.top();
    while(!q.empty()&&sol[q.top().poz]) q.pop(), x=q.top();
    if(!q.empty()){
      lols x=q.top();
      q.pop();
      int nod=x.poz;
      int cost=x.c;
      sol[nod]=cost;
      for(auto i:g[nod].vec){
        if(i.d>=d){
          q.push({i.dest, cost+i.cost});
        }
      }
    }
  }
  for(int i=1;i<=n;++i) sol[i]--;
  return sol;
}

int dp[17][1<<17];

int dist[16][16][16];

int main()
{
  int n, m, k;
  fin>>k>>n>>m;
  g.resize(n+1);
  k++;
  vector<int> v(k+1);
  v[1]=1;
  for(int i=2;i<=k;++i){
    fin>>v[i];
  }
  for(int i=1;i<=m;++i){
    int a, b, c, d;
    fin>>a>>b>>c>>d;
    g[a].vec.push_back({b, c, d});
    g[b].vec.push_back({a, c, d});
  }
  for(int i=1;i<=k;++i){
    for(int j=1;j<=k;++j){
      vector<int> sol;
      sol=dijkstra(v[i], j, n);
      for(int p=1;p<=k;++p){
        dist[i][p][j]=sol[v[p]];
      }
    }
  }
  int mask=1<<k;
  for(int i=0;i<=k;++i){
    for(int j=0;j<mask;++j){
      dp[i][j]=(1<<30);
    }
  }
  dp[1][1]=0;
  for(int i=1;i<mask;i=(i+1)|1){
    for(int poz=1;poz<=k;++poz){
      if(dp[poz][i]>=(1<<30)) continue;
      vector<int> nobit;
      int cnt=0;
      for(int j=0;j<k;++j){
        if(i&(1<<j)) cnt++;
        else{
          nobit.push_back(j);
        }
      }
      for(auto j:nobit){
        if(dist[poz][j+1][cnt]>0){
          dp[j+1][i|(1<<j)]=min(dp[j+1][i|(1<<j)], dp[poz][i]+dist[poz][j+1][cnt]*cnt);
        }
      }
    }
  }
  int sol=(1<<30);
  for(int i=1;i<=k;++i){
    sol=min(sol, dp[i][mask-1]);
  }
  fout<<sol<<"\n";
  return 0;
}