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

template<typename T>
struct Dinic {
    int n;
    struct edge {
        int to,nxt;
        T cap,flow;
        T cost;
    };

    std::vector<edge> e;
    std::vector<int> head,now;
    std::vector<T> h,dep;
    std::vector<bool> vis;
    T inf=std::numeric_limits<T>::max()>>1;

    Dinic(int _n) : n(_n),head(n+1,-1) {}

    void add_edge(int u,int v,T cap,T cost=0) {
        e.push_back({v,head[u],cap,0,cost});
        head[u]=e.size()-1;
        e.push_back({u,head[v],0,0,-cost});
        head[v]=e.size()-1;
    }

    // Johnson algorithm
    void spfa(int s) {
        h.assign(n+1,inf);
        std::queue<int> q;

        h[s]=0;
        q.push(0);
        vis[s]=true;
        while(!q.empty()) {
            int u=q.front();
            q.pop();
            vis[u]=false;

            for(int i=head[u];~i;i=e[i].nxt) {
                int v=e[i].to;
                if(e[i].cap>e[i].flow&&h[v]>h[u]+e[i].cost) {
                    h[v]=h[u]+e[i].cost;
                    if(!vis[v]) {
                        vis[v]=true;
                        q.push(v);
                    }
                }
            }
        }

    }

    bool dij(int s,int t) {
        fill(dep.begin(),dep.end(),inf);
        fill(vis.begin(),vis.end(),false);
        
        std::priority_queue<std::pair<T,int>,std::vector<std::pair<T,int>>,std::greater<std::pair<T,int>>> pq;

        dep[s]=0;
        pq.push({0,s});
        while(!pq.empty()) {
            int u=pq.top().second;
            pq.pop();
            if(vis[u]) continue;
            vis[u]=true;

            for(int i=head[u];~i;i=e[i].nxt) if(e[i].cap>e[i].flow){
                int v=e[i].to;
                auto newdep=dep[u]+e[i].cost+h[u]-h[v];
                if(dep[v]>newdep) {
                    dep[v]=newdep;
                    pq.push({dep[v],v});
                }
            }
        }

        return dep[t]!=inf;
    }

    T dfs(int u,int t,T flow) {

        if(u==t||!flow) return flow;
        T rest=flow;
        vis[u]=true;
        for(int i=now[u];~i&&rest;i=e[i].nxt) {
            now[u]=i;
            int v=e[i].to;
            if(!vis[v]&&dep[v]==dep[u]+e[i].cost+h[u]-h[v]&&e[i].cap>e[i].flow) {
                T delta=dfs(v,t,std::min(rest,e[i].cap-e[i].flow));
                if(!delta) continue;
                e[i].flow+=delta;
                e[i^1].flow-=delta;
                rest-=delta;
            }
        }
        vis[u]=false;
        return flow-rest;
    }
  
    // flag 表示初始图中是否可能存在负权边，如果存在的话需要先Johnson算法求出h函数
    auto MCMF(int s,int t,int flag=0) {
        h.assign(n+1,0); vis.assign(n+1,false); dep.resize(n+1);
        T flow=0,cost=0;
        if(flag) spfa(s);
        while(dij(s,t)) {
            std::fill(vis.begin(),vis.end(),false);
            now=head;
            T delta=0,tmp;

            while(tmp=dfs(s,t,inf)) 
                delta+=tmp;

            for(int i=0;i<=n;i++) 
                h[i]+=dep[i];
      
            flow+=delta,cost+=h[t]*delta;
        }
        return std::make_pair(cost,flow);
    }
  
    void resetflow(T x=0) {
        for(auto &it:e) 
            it.flow=x;
    }
  
};


using ll = long long ;

void sol() {
    int n,m; cin>>n>>m;
    vector<int> lim(m);
    for(int &x:lim) cin>>x;
    
    vector<int> c(2*n),v(2*n);
    vector<int> cnt(m);
    for(int &x:c) {
        cin>>x;
        cnt[--x]++;
    }
    
    ll sum=0;
    for(int &x:v) {
        cin>>x;
        sum+=x;
    }

    int s=2*n+m,t=s+1;
    Dinic<ll> dinic(t);
    dinic.add_edge(s,2*n-1,n);
    for(int i=2*n-1;i>0;i--) 
        dinic.add_edge(i,i-1,i/2);
    for(int i=0;i<2*n;i++)
        dinic.add_edge(i,2*n+c[i],1,v[i]);
    for(int i=0;i<m;i++) {
        if(cnt[i]<=lim[i]) return cout<<-1<<endl,void();
        dinic.add_edge(2*n+i,t,cnt[i]-lim[i]);
    }

    auto [mc,mf]=dinic.MCMF(s,t);
    if(mf!=n) cout<<-1<<endl;
    else cout<<sum-mc<<endl;
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);

    int T; cin>>T;
    while(T--) 
        sol();

    return 0;
}