#include <bits/stdc++.h>
using std::cin,std::cout,std::vector,std::array;
#define endl "\n"
#define ALL(x) x.begin(),x.end()
using ll = long long;
using PII = std::pair<int,int>;
using T3I = std::tuple<int,int,int>;

template <typename T>
class MCF_Graph {
private:
    using PTI = std::pair<T, int>;
    struct _Edge {
        int to;
        T cap, cost;
        _Edge(int _to, T _cap, T _cost): to(_to), cap(_cap), cost(_cost) {}
    };
    
    const int n;
    std::vector<_Edge> edges;
    std::vector<std::vector<int>> adj;
    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);
        std::priority_queue<PTI, std::vector<PTI>, std::greater<PTI>> pq;
        dis[s] = 0;
        pq.emplace(0, s);
        while(!pq.empty()) {
            auto [uDis,u] = pq.top(); pq.pop();
            if(dis[u]<uDis) continue;
            for(auto &i:adj[u]) {
                auto &[v,cp,ct] = edges[i];
                if(cp>0 && dis[v]>uDis+h[u]-h[v]+ct) {
                    dis[v] = uDis+h[u]-h[v]+ct;
                    pre[v] = i;
                    pq.emplace(dis[v], v);
                }
            }
        }
        return dis[t]!=std::numeric_limits<T>::max();
    }

public:
    MCF_Graph(size_t _n): n(_n), adj(_n) {}
    
    void addEdge(int u, int v, T cost=0, T cap=std::numeric_limits<T>::max()) {
        adj[u].emplace_back(edges.size());
        edges.emplace_back(v, cap, cost);
        adj[v].emplace_back(edges.size());
        edges.emplace_back(u, 0, -cost);
    }
    // first: maxFlow
    // second: minCost
    std::pair<T, T> getFlow(int s, int t) {
        T maxFlow = 0, minCost = 0;
        h.assign(n, 0);
        while(dijkstra(s, t)) {
            for(int i=0; i<n; ++i) h[i] += dis[i];
            T aug = std::numeric_limits<T>::max();
            for(int i=t; i!=s; i=edges[pre[i]^1].to) aug = std::min(aug, edges[pre[i]].cap);
            for(int i=t; i!=s; i=edges[pre[i]^1].to) {
                edges[pre[i]].cap -= aug;
                edges[pre[i]^1].cap += aug;
            }
            maxFlow += aug;
            minCost += aug*h[t];
        }
        return {maxFlow, minCost};
    }
};

void solve()
{
    int n,m; cin>>n>>m;
    vector<int> l(m+1), c(n*2+1), v(n*2+1), cnt(m+1);
    for(int i=1; i<=m; ++i) cin>>l[i];
    for(int i=1; i<=n*2; ++i) {
        cin>>c[i];
        ++cnt[c[i]];
    }
    for(int i=1; i<=n*2; ++i) cin>>v[i];
    
    if(std::accumulate(ALL(l), 0)>n){ cout<<-1<<endl; return; }
    
    ll sum_val = std::accumulate(ALL(v), 0LL);
    
    int S = n*2+m+1, T = S+1;
    MCF_Graph<ll> MF(T+1);
    MF.addEdge(S, n*2, 0, n);
    for(int i=n*2-1; i; --i) 
        MF.addEdge(i+1, i, 0, i/2);
    for(int i=n*2; i; --i)
        MF.addEdge(i, n*2+c[i], v[i], 1);
    for(int i=1; i<=m; ++i)
        MF.addEdge(n*2+i, T, 0, cnt[i]-l[i]);
    auto [maxFlow, minCost] = MF.getFlow(S, T);
    if(maxFlow<n) cout<<-1<<endl;
    else cout<<sum_val-minCost<<endl;
}

int main()
{
    std::cin.tie(nullptr)->sync_with_stdio(false);
#ifndef ONLINE_JUDGE
    std::ifstream in("C++/in.txt");
    std::cin.rdbuf(in.rdbuf());
#endif
    int T = 1;
    std::cin>>T;
    while(T--) solve();
    return 0;
}