#include <bits/stdc++.h>

using namespace std;

template<class Z, class ZC>
struct CostFlow {
  int n;
  vector<vector<tuple<int, int, Z, ZC>>> g;

  CostFlow(int n) : n(n), g(n) {}

  void addEdge(int u, int v, Z c, ZC w) {
    int ru = g[u].size(), rv = g[v].size();
    g[u].emplace_back(v, rv, c, w), g[v].emplace_back(u, ru, 0, -w);
  }

  pair<Z, ZC> dinic(int s, int t) {
    vector<ZC> h(n), dis(n);
    vector<int> level(n), inQueue(n), cur(n);
    auto getH = [&]() {
      fill_n(h.begin(), n, numeric_limits<ZC>::max());
      queue<int> q; q.push(s), h[s] = 0, inQueue[s] = 1;
      while (!q.empty()) {
        int u = q.front(); q.pop(), inQueue[u] = 0;
        for (auto [v, _, c, w]: g[u]) {
          if (c && h[v] > h[u] + w) {
            h[v] = h[u] + w;
            if (!inQueue[v]) q.push(v), inQueue[v] = 1;
          }
        }
      }
    };
    getH();
    if (h[t] == numeric_limits<ZC>::max()) return {0, 0};
    auto getLevel = [&]() {
      fill_n(dis.begin(), n, numeric_limits<ZC>::max());
      priority_queue<pair<ZC, int>, vector<pair<ZC, int>>, greater<pair<ZC, int>>> pQ;
      pQ.emplace(dis[s] = 0, s);
      while (!pQ.empty()) {
        auto [d, u] = pQ.top(); pQ.pop();
        if (d > dis[u]) continue;
        for (auto [v, _, c, w]: g[u]) {
          w += h[u] - h[v];
          if (c && dis[v] > dis[u] + w) pQ.emplace(dis[v] = dis[u] + w, v);
        }
      }
      queue<int> q; fill_n(level.begin(), n, -1), q.push(s), level[s] = 0;
      while (!q.empty()) {
        int u = q.front(); q.pop();
        for (auto [v, _, c, w]: g[u])
          if (c && dis[v] == dis[u] + w + h[u] - h[v] && level[v] == -1) level[v] = level[u] + 1, q.push(v);
      }
    };
    Z ret = 0; ZC cost = 0;
    function<Z(int, Z)> cap = [&](int u, Z lim) {
      if (u == t) return lim;
      Z ret = 0;
      for (; cur[u] && ret < lim; --cur[u]) {
        auto &[v, rev, c, w] = g[u][cur[u] - 1];
        if (c && dis[v] == dis[u] + w + h[u] - h[v] && level[v] == level[u] + 1) {
          Z flow = cap(v, min(lim - ret, c));
          ret += flow, cost += flow * w, c -= flow, get<2>(g[v][rev]) += flow;
          if (ret == lim) return ret;
        }
      }
      return ret;
    };
    while (getLevel(), level[t] != -1) {
      for (int i = 0; i < n; ++i) cur[i] = g[i].size();
      ret += cap(s, numeric_limits<Z>::max());
      for (int i = 0; i < n; ++i) h[i] += dis[i];
    }
    return {ret, cost};
  }
};

int main() {
  int m, n, k, s, t; scanf("%d%d%d", &n, &m, &k);
  vector<int> w(n), a(k);
  for (int &i : w) scanf("%d", &i);
  for (int &i : a) scanf("%d", &i), --i;
  a.erase(unique(a.begin(), a.end()), a.end()), s = k = a.size(), t = k - 1;
  CostFlow<int, int> costFlow(k + 1);
  int ans = 0;
  vector<int> las(n, -1);
  costFlow.addEdge(s, 0, m - 1, 0);
  for (int i = 0; i + 1 < k; ++i) costFlow.addEdge(i, i + 1, numeric_limits<int>::max(), 0);
  for (int i = 0; i < k; ++i) {
    if (las[a[i]] != -1) costFlow.addEdge(las[a[i]] + 1, i, 1, -w[a[i]]);
    las[a[i]] = i, ans += w[a[i]];
  }
  printf("%d\n", ans += costFlow.dinic(s, t).second);
}