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

using ll = long long;
using i64 = long long;
using pii = pair<int, int>;
using db = double;

#define cY cout << "YES\n"
#define cN cout << "NO\n"
#define cA cout << ans << "\n"
#define pb push_back

const int N = 2e5 + 7;
const ll mod = 998244353;
const ll MOD = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;

#define int ll

template <class T = i64>
struct Flow {
    struct Edge {
        int y, c, f;
    };
    const int n;
    std::vector<Edge> adj;
    std::vector<std::vector<int>> g;
    std::vector<T> h, dis;
    std::vector<int> pre;

    bool dijkstra(int s, int t) {
        dis.assign(n, std::numeric_limits<T>::max());
        pre.assign(n, -1);
        using pii = std::pair<T, int>;
        std::priority_queue<pii, std::vector<pii>, std::greater<>> q;
        dis[s] = 0;
        q.emplace(0, s);

        std::vector<int> vis(n);
        while (!q.empty()) {
            auto [D, x] = q.top();
            q.pop();

            if (vis[x] || dis[x] < D)
                continue;
            vis[x] = 1;

            for (int i : g[x]) {
                const auto &[y, c, f] = adj[i];
                if (c > 0 and dis[y] > D + h[x] - h[y] + f) {
                    dis[y] = D + h[x] - h[y] + f;
                    pre[y] = i;
                    q.emplace(dis[y], y);
                }
            }
        }
        return dis[t] != std::numeric_limits<T>::max();
    }
    Flow(int n) : n(n), g(n) {}
    void add(int x, int y, int c, int f) {
        if (f < 0) {  // 删除 <=> 最大流
            g[x].push_back(adj.size());
            adj.emplace_back(y, 0, f);
            g[y].push_back(adj.size());
            adj.emplace_back(x, c, -f);
        } else {
            g[x].push_back(adj.size());
            adj.emplace_back(y, c, f);
            g[y].push_back(adj.size());
            adj.emplace_back(x, 0, -f);
        }
    }
    std::pair<int, T> work(int s, int t) {
        int flow = 0;
        T cost = 0;
        h.assign(n, 0);
        while (dijkstra(s, t)) {
            for (int i = 0; i < n; ++i)
                h[i] += dis[i];
            int aug = std::numeric_limits<int>::max();
            for (int i = t; i != s; i = adj[pre[i] ^ 1].y)
                aug = std::min(aug, adj[pre[i]].c);
            for (int i = t; i != s; i = adj[pre[i] ^ 1].y) {
                adj[pre[i]].c -= aug;
                adj[pre[i] ^ 1].c += aug;
            }
            flow += aug;
            cost += T(aug) * h[t];
        }
        return std::pair(flow, cost);
    }
};

void crossparallel() {
    int n, m;
    cin >> n >> m;

    vector<int> l(m);
    for (int i = 0; i < m; i++) {
        cin >> l[i];
    }

    vector<int> c(n + n);
    map<int, int> mp;
    for (int i = 0; i < n + n; i++) {  // 颜色
        cin >> c[i];
        c[i]--;
        mp[c[i]]++;
    }

    for (int i = 0; i < m; i++) {
        if (mp[i] < l[i]) {
            cout << -1 << "\n";
            return;
        }
    }

    int sum = 0;
    vector<int> v(n + n);
    for (int i = 0; i < n + n; i++) {  // 权值
        cin >> v[i];
        sum += v[i];
    }

    int cnt = 0;
    int s = ++cnt, t = ++cnt;
    Flow<ll> flow(m * 2 + n * 4 + 10);

    vector<int> tt(m);
    for (int i = 0; i < m; i++) {  // 颜色小源汇
        tt[i] = ++cnt;
        flow.add(tt[i], t, mp[i] - l[i], 0);
    }

    vector<int> in(n + n);
    for (int i = 0; i < n + n; i++) {  // 拆点
        in[i] = ++cnt;
    }

    flow.add(s, in[n + n - 1], n, 0);

    for (int i = 0; i < n + n; i++) {  // 配颜色，配括号
        if (i > 0)
            flow.add(in[i], in[i - 1], i / 2, 0);
        flow.add(in[i], tt[c[i]], 1, v[i]);
    }
    auto [f, cost] = flow.work(s, t);

    // cout << f << " ";
    cout << (f >= n ? sum - cost : -1) << "\n";

    return;
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int t = 1;
    cin >> t;
    while (t--) {
        crossparallel();
    }
    return 0;
}