#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;
//     }
  
// };

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;
    std::vector<int> pre;
    T inf=std::numeric_limits<T>::max()>>1;

    Dinic(int _n) : n(_n) {
        head.resize(n+1,-1);
        now.resize(n+1);
        h.resize(n+1);
        dep.resize(n+1);
        vis.resize(n+1);
        pre.resize(n+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) {
        fill(h.begin(),h.end(),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;
                    pre[v]=i; // 记录前驱边
                    pq.push({dep[v],v});
                }
            }
        }

        return dep[t]!=inf;
    }

  
    // flag 表示初始图中是否可能存在负权边，如果存在的话需要先Johnson算法求出h函数
    auto MCMF(int s,int t,int flag=0) {
        T flow=0,cost=0;
        if(flag) spfa(s);
        while(dij(s,t)) {
            for(int i=0;i<=n;i++) 
                h[i]+=dep[i];
            T delta=std::numeric_limits<T>::max();
            for(int i=t;i!=s;i=e[pre[i]^1].to) 
                delta=std::min(delta,e[pre[i]].cap-e[pre[i]].flow);

            for(int i=t;i!=s;i=e[pre[i]^1].to) {
                e[pre[i]].flow+=delta;
                e[pre[i]^1].flow-=delta;
            }
            flow+=delta;
            cost+=delta*h[t];
        }
        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;
}