using namespace std;
#include <cstdio>
#include <vector>
#include <queue>
#define maxn 751
#define pb push_back

struct nod { int n, c, ppl; nod(){}; nod(int a, int b, int cc){n=a; c=b; ppl=cc;};};

vector<nod> a[maxn];

int dp[maxn*10][maxn][16];
int ppl[16];
int K, n, m;
int used[16];
bool USE[maxn];
inline int min(int a, int b)
{
  if(a<b) return a;
  return b;
}


void read()
{
  freopen("gather.in","r",stdin);
  scanf("%d %d %d\n", &K, &n, &m);

  int i, p, q, c, mx, t;
  for(i=1;i<=K;++i){ scanf("%d\n", &t); ppl[t]=1;}
  while(m--)
    {
      scanf("%d %d %d %d\n", &p, &q, &c, &mx);
      a[p].pb(nod(q, c, mx));
      a[q].pb(nod(p, c, mx));
    }
}


int memo(int t, int i, int j)
{
   if(t>maxn) return 0;
  if(dp[t][i][j]) return dp[t][i][j];

  if(j==K) return 0;

  vector<nod>::iterator it;
  dp[t][i][j]=0x3f3f3f3f;
  for(it=a[i].begin();it!=a[i].end();++it)
    {
      dp[t][i][j]=min(dp[t][i][j],  memo(t+1, it->n, j)+(j+1)*it->c);
      if(ppl[i])
	{
	  used[i]=1;
	  dp[t][i][j]=min(dp[t][i][j], memo(t+1, it->n, j+1)+(j+1)*it->c);
	  dp[t][i][j]=min(dp[t][i][j], memo(t+1, it->n, j) + (j+1)*it->c);
	  used[i]=0;
	}
    }

  return dp[t][i][j];
}
      




void solve()
{
  int i, j, k, t, ok;
  vector<nod>::iterator it;
  queue<int>Q;

  dp[1][1][0]=0;
  dp[1][1][1]=0;
  USE[1]=1;

  for(t=2;t<=n;++t)
    for(i=1;i<=n;++i)
      for(j=0;j<=K;++j)
	{
	  dp[t][i][j]=0x3f3f3f3f;
	  for(it=a[i].begin();it!=a[i].end();++it)
	    {
	      if(ppl[it->n] && !used[it->n] && USE[it->n])
		{
		  if(j+1<=it->ppl)
		    {
		      ok=0;
		      if(dp[t][i][j]>dp[t-1][it->n][j-1])
			{
			  dp[t][i][j]=dp[t-1][it->n][j-1];
			  ++used[it->n];
			  ok=1;
			}
		      
		      if(dp[t][i][j] > dp[t-1][it->n][j])
			{
			  if(ok) --used[it->n];
			  dp[t][i][j]=dp[t-1][it->n][j-1];
			}
		      
		      /*
		      if(dp[t-1][it->n][j]>dp[t-1][it->n][j-1]) 
			{
			  dp[t][i][j]=dp[t-1][it->n][j-1];
			  used[it->n]=1;
			}
		      else
			dp[t][i][j]=dp[t-1][it->n][j-1];
		      */
		      ///		  dp[i][j]=min(dp[it->n][j]+(j+1)*it->c, dp[it->n][j-1]+(j+1)*i->c);
		    }
		  
		}
	      if(!ppl[it->n]) dp[t][i][j]=min(dp[t][i][j],dp[t-1][it->n][j]);
	      dp[t][i][j]+=(j+1)*it->c;
	      USE[i]=1;
	    }
	}
  
  int sol=0x3f3f3f3f;
  for(t=2;t<=n;++t)
    for(i=1;i<=n;++i)
      //      for(j=1;j<=K;++j)
	if(dp[t][i][K]!=0) sol=min(sol, dp[t][i][K]);

  printf("%d\n", sol);
 
  printf("%d %d\n", dp[2][2][0], dp[2][2][1]);
}

int main()
{
  read();
  //  solve();
  freopen("gather.out","w",stdout);
  printf("%d\n", memo(1,1,0)); 



  return 0;
}