#include <cstdio>
#include <queue>
#include <algorithm>
#include <cstring>

typedef std::pair<int, int> PII;
using std::min;
const int INF = 1000000000;
namespace Flow {
    struct Edge {int to, nxt, cap, cost;} e[100005];
    int head[5005], dis[5005], delta[5005], tot = 1, s, t;
    std::queue<int> QQ;
    std::priority_queue<PII, std::vector<PII>, std::greater<PII> > Q;
    bool vis[5005], mark[5005], done[5005];
    inline void ae(int u, int v, int cap, int cost) {
        e[++ tot].to = v, e[tot].cap = cap, e[tot].cost = cost,
        e[tot].nxt = head[u], head[u] = tot;
        e[++ tot].to = u, e[tot].cap = 0, e[tot].cost = -cost,
        e[tot].nxt = head[v], head[v] = tot;
    }
    bool spfa() {
        memset(dis, 0x3f, sizeof dis);
        memset(vis, false, sizeof vis);
        QQ.push(s), dis[s] = 0;
        while (QQ.size()) {
            int u = QQ.front(); QQ.pop(); mark[u] = false;
            for (int i = head[u]; i; i = e[i].nxt)
                if (e[i].cap && dis[u] + e[i].cost < dis[e[i].to]) {
                    dis[e[i].to] = dis[u] + e[i].cost;
                    if (!mark[e[i].to]) QQ.push(e[i].to), mark[e[i].to] = true;
                }
        }
        return dis[t] <= INF;
    }
    bool dijkstra() {
        memset(delta, 0x3f, sizeof delta);
        memset(vis, false, sizeof vis);
        memset(done, false, sizeof done);
        Q.push(std::make_pair(delta[s] = 0, s));
        while (Q.size()) {
            int u = Q.top().second; Q.pop();
            if (done[u]) continue; done[u] = true;
            for (int i = head[u]; i; i = e[i].nxt)
                if (e[i].cap && delta[u] + e[i].cost + dis[u] - dis[e[i].to] < delta[e[i].to])
                    Q.push(std::make_pair(delta[e[i].to] = delta[u] + e[i].cost
                    + dis[u] - dis[e[i].to], e[i].to));
        }
        for (int i = 1; i <= t; ++ i) dis[i] += delta[i];
        return dis[t] <= INF;
    }
    int dfs(int u, int flow) {
        if (u == t) return flow;
        vis[u] = true;
        int used = 0;
        for (int i = head[u]; i; i = e[i].nxt) {
            int v = e[i].to;
            if (!vis[v] && dis[u] + e[i].cost == dis[v] && e[i].cap) {
                int tmp = dfs(v, min(e[i].cap, flow));
                e[i].cap -= tmp, e[i ^ 1].cap += tmp, used += tmp, flow -= tmp;
                if (!flow) return used;
            }
        }
        return used;
    }
    int Dinic() {
        int mincost = 0;
        if (!spfa()) return 0;
        do mincost += dfs(s, INF) * dis[t]; while (dijkstra());
        return mincost;
    }
}
int w[5005], a[5005], lst[5005], b[5005], n, m, q;

int main() {
    scanf("%d%d%d", &n, &m, &q);
    int sum = 0;
    for (int i = 1; i <= n; ++ i) scanf("%d", w + i);
    for (int i = 1; i <= q; ++ i) scanf("%d", a + i);
    int newq = 0;
    for (int i = 1; i <= q; ++ i) {
        int j = i;
        while (j < q && a[j + 1] == a[i]) ++ j;
        b[++ newq] = a[i], i = j;
    }
    memcpy(a, b, sizeof a);
    for (int i = 1; i <= q; ++ i) Flow::ae(i, i + 1, m - 1, 0);
    for (int i = 1; i <= q; ++ i) {
        if (lst[a[i]]) Flow::ae(lst[a[i]] + 1, i, 1, -w[a[i]]);
        lst[a[i]] = i, sum += w[a[i]];
    }
    Flow::s = 1, Flow::t = q + 1;
    printf("%d", sum + Flow::Dinic());
    return 0;
}