#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#define ll long long
#define ld long double

using namespace std;
using namespace __gnu_pbds;

typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;

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

const int KMAX = 15;
const int NMAX = 750;
const ll INF = 1e18;

struct PQElement {
    int node;
    ll cost;
    bool operator < (const PQElement &other) const {
        return other.cost < cost;
    }
};

int n, k, m;
ll answer;
int targets[KMAX + 1];
vector<tuple<int, int, int>> g[NMAX + 1];
ll d[KMAX + 1][NMAX + 1];
ll dp[1 << KMAX][KMAX + 1];

void dijkstra(ll d[], int start_node) {
    for(int i = 1; i <= n; i++) {
        d[i] = INF;
    }
    priority_queue<PQElement> pq;
    pq.push({start_node, 0});
    while(!pq.empty()) {
        auto [node, curent_d] = pq.top();
        pq.pop();
        if(d[node] != INF) {
            continue;
        }

        d[node] = curent_d;
        for(auto [next_node, edge_d, edge_cnt] : g[node]) {
            pq.push({next_node, curent_d + edge_d});
        }
    }
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    fin >> k >> n >> m;
    for(int i = 1; i <= k; i++) {
        fin >> targets[i];
    }
    targets[0] = 1;

    for(int i = 1; i <= m; i++) {
        int a, b, c, d;
        fin >> a >> b >> c >> d;
        g[a].push_back({b, c, d});
        g[b].push_back({a, c, d});
    }

    for(int i = 0; i <= k; i++) {
        dijkstra(d[i], targets[i]);
    }

    for(int mask = 0; mask < (1 << k); mask++) {
        for(int i = 0; i <= k; i++) {
            dp[mask][i] = INF;
        }
    }
    for(int i = 1; i <= k; i++) {
        dp[1 << (i - 1)][i] = d[0][targets[i]];
    }

    for(int mask = 1; mask < (1 << k); mask++) {
        if(__builtin_popcount(mask) == 1) {
            continue;
        }

        vector<int> mask_targets;
        for(int i = 1; i <= k; i++) {
            if(mask >> (i - 1) & 1) {
                mask_targets.push_back(i);
            }
        }

        int sz = mask_targets.size();
        for(int i = 0; i < sz; i++) {
            for(int j = 0; j < sz; j++) {
                if(i != j) {
                    int target_i = mask_targets[i];
                    int target_j = mask_targets[j];
                    dp[mask][target_i] = min(dp[mask][target_i], dp[mask ^ (1 << (target_i - 1))][target_j] + d[target_j][targets[target_i]] * sz);
                }
            }
        }
    }

    answer = INF;
    for(int i = 1; i <= k; i++) {
        answer = min(answer, dp[(1 << k) - 1][i]);
    }
    fout << answer << '\n';
    return 0;
}