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

#define all(x) begin(x), end(x)
#ifdef local
#include <experimental/iterator>
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
void debug_(const char *s, auto ...a) {
  cerr << "\e[1;32m(" << s << ") = (";
  int f = 0;
  (..., (cerr << (f++ ? ", " : "") << a));
  cerr << ")\e[0m\n";
}
void orange_(const char *s, auto L, auto R) {
  cerr << "\e[1;33m[ " << s << " ] = [ ";
  using namespace experimental;
  copy(L, R, make_ostream_joiner(cerr, ", "));
  cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif

template <typename F, typename C> class MCMF {
    static constexpr F INF_F = numeric_limits<F>::max() / 3;
    static constexpr C INF_C = numeric_limits<C>::max() / 3;
    struct E {
      int to, r;
      F f; C c;
      E() {}
      E(int a, int b, F x, C y)
        : to(a), r(b), f(x), c(y) {}
    };
    int n;
    array<vector<E>, 40000> g;
    vector<pair<int, int>> f;
    vector<bool> inq;
    vector<F> up; vector<C> d, h;
    optional<pair<F, C>> step(int S, int T) {
      safe;
      debug(S, T);
      priority_queue<pair<C, int>> q;
      q.emplace(d[S] = 0, S), up[S] = INF_F;
      while (not q.empty()) {
        auto [l, u] = q.top(); q.pop();
        debug(u, l, -d[u]);
        assert(-l >= d[u]);
        assert(up[u] != 0);
        if (l != -d[u]) continue;
        for (int i = 0; i < int(g[u].size()); ++i) {
          auto e = g[u][i]; int v = e.to;
          debug(u, v, e.c + h[u] - h[v]);
          if (e.f > 0)
            assert(e.c + h[u] - h[v] >= 0);
          auto nd = d[u] + e.c + h[u] - h[v];
          if (e.f <= 0 or d[v] <= nd) continue;
          f[v] = {u, i}; up[v] = min(up[u], e.f);
          q.emplace(-(d[v] = nd), v);
        }
      }
      if (d[T] == INF_C) return nullopt;
      for (size_t i = 0; i < d.size(); ++i)
        h[i] += d[i];
      for (int i = T; i != S; i = f[i].first) {
        auto &eg = g[f[i].first][f[i].second];
        eg.f -= up[T]; g[eg.to][eg.r].f += up[T];
      }
      return pair{up[T], h[T]};
    } 
    void precalc(int a) {
      d[a] = 0;
      for (int _ = 0; _ <= n; _++) {
        bool flag = false;
        for (int u = 0; u < n; u++)
          if (d[u] != INF_C)
            for (int i = 0; i < int(g[u].size()); ++i) {
              auto e = g[u][i]; int v = e.to;
              auto nd = d[u] + e.c;
              if (e.f <= 0 or d[v] <= nd) continue;
              d[v] = nd;
              flag = true;
            }
        if (_ == n) assert(!flag);
        if (!flag)
          break;
      }
      orange(all(d));
      assert(h.size() == d.size());
      for (size_t i = 0; i < d.size(); ++i)
        h[i] = d[i];
      debug(INF_C);
      fill(d.begin(), d.end(), INF_C);
    }
  public:
    MCMF(int n_) : n(n_), f(n), inq(n), up(n), d(n, INF_C), h(n) {}
    void add_edge(int s, int t, F c, C w) {
      g[s].emplace_back(t, int(g[t].size()), c, w);
      g[t].emplace_back(s, int(g[s].size()) - 1, 0, -w);
    }
    pair<F, C> solve(int a, int b) {
      precalc(a);
      F c = 0; C w = 0;
      while (auto r = step(a, b)) {
        c += r->first, w += r->first * r->second;
        fill(d.begin(), d.end(), INF_C);
      }
      return {c, w};
    }
};

using lld = int64_t;


using ll = lld;
const int N = 10025;

int lst[N], wei[N];
const ll MAXC = 1e9;
const ll INF = 1e18;

int main() {
    ios::sync_with_stdio(0), cin.tie(0);
    int m, n, k;
    ll ans = 0;
    cin >> m >> n >> k;
    int S = 0, T = 2 * k + 1;
    MCMF<lld,lld> mcmf(2 * k + 2);
    // mcmf.init(2 * k + 2);
    for (int i = 1; i <= n; ++i)
        cin >> wei[i];
    mcmf.add_edge(S, 1, m, 0);
    mcmf.add_edge(2 * k, T, m, 0);
    for (int i = 1; i <= k; ++i) {
        mcmf.add_edge(2 * i - 1, 2 * i, 1, -MAXC);
        mcmf.add_edge(2 * i - 1, 2 * i, INF, 0);
        if (i < k)
            mcmf.add_edge(2 * i, 2 * i + 1, INF, 0);
    }
    for (int i = 1; i <= k; ++i) {
        int x;
        cin >> x;
        if (lst[x]) mcmf.add_edge(2 * lst[x], 2 * i - 1, 1, -wei[x]);
        lst[x] = i;
        ans += wei[x];
    }
    auto [flow, cost] = mcmf.solve(S, T);
    cout << ans + k * MAXC + cost << "\n";
}