#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<queue>
#include<cassert>
#define rep(i, a, b) for(int i = (a); i <= (b); i++)
using namespace std;
const int N = 510, M = N+N+N*N;

namespace FLOW{
    int dis[N], s, t, cur[N], h[N], cnt;
    bool v[N];
    struct edge {int to, nxt, val, cst;} e[M<<1];
    queue<int> q;
    bool spfa(){
        // printf("enter spfa.\n");
        rep(i, 1, t) dis[i] = 0x3f3f3f3f, v[i] = 0;
        q.push(s); dis[s] = 0, v[s] = 1;
        while(!q.empty()){
            int x = q.front(); q.pop(); v[x] = 0;
            // printf("spfa: %d %d\n", x, dis[x]);
            cur[x] = h[x];
            for(int y = h[x]; y; y = e[y].nxt){
                int z = e[y].to, w = e[y].val, d = e[y].cst;
                // printf("spfa: %d->%d (%d %d)\n", x, z, w, d);
                if(w && dis[x] + d < dis[z]){
                    dis[z] = dis[x] + d;
                    if(!v[z]) q.push(z), v[z] = 1;
                }
            }
        }
        // printf("end spfa. (ret = %d)\n", (dis[t] < 0x3f3f3f3f));
        // rep(i, 1, t) printf("%d ", dis[i]);
        // puts("");
        return dis[t] < 0x3f3f3f3f;
    }
    int dfs(int x, int flow){
        // printf("dfs: %d %d\n", x, flow);
        if(x == t) return flow;
        v[x] = 1; int ret = 0;
        for(int &y = cur[x]; y && flow; y = e[y].nxt){
            int z = e[y].to, w = e[y].val, d = e[y].cst;
            if(!v[z] && (dis[z] == dis[x]+d) && w){
                int tmp = dfs(z, min(flow, w));
                if(tmp){
                    ret += tmp, flow -= tmp;
                    e[y].val -= tmp, e[y ^ 1].val += tmp;
                }
                else dis[z] = 0x3f3f3f3f;
            }
        }
        v[x] = 0; return ret;
    }
    int dinic(){
        int ret = 0;
        while(spfa()) ret += dfs(s, 0x3f3f3f3f);
        return ret;
    }
    void init(int S, int T){
        rep(i, 1, t) h[i] = 0;
        cnt = 1, s = S, t = T;
    }
    void add_edge(int x, int y, int w, int d){
        // printf("add_edge: %d %d %d %d\n", x, y, w, d);
        e[++cnt] = edge{y, h[x], w, d}; h[x] = cnt;
        e[++cnt] = edge{x, h[y], 0, -d}; h[y] = cnt;
    }
}

int n, m, cnt, ans[N];
vector<int> a[N], e[N];
bool v[N];

void solve_ans(int x){
    if(v[x]) return;
    v[x] = 1;
    for(int &y : e[x]) for(int &i : a[y]){
        if(i == x) break;
        solve_ans(i);
    }
    for(int &y : e[x]) ans[++cnt] = y;
}

void solve(){
    scanf("%d%d", &n, &m);
    FLOW::init(n+m+1, n+m+2);
    rep(i, 1, n) FLOW::add_edge(FLOW::s, i, 1, 0);
    rep(i, 1, m){
        int x; scanf("%d", &x);
        FLOW::add_edge(i+n, FLOW::t, x, 0);
    }
    rep(i, 1, n){
        a[i].clear();
        int k; scanf("%d", &k);
        rep(j, 1, k){
            int x; scanf("%d", &x);
            a[i].push_back(x);
            FLOW::add_edge(i, x+n, 1, j);
        }
    }
    printf("%d\n", FLOW::dinic());
    rep(i, 1, m) e[i].clear(), v[i] = 0;
    rep(i, 1, n){
        bool flag = 0;
        for(int y = FLOW::h[i]; y; y = FLOW::e[y].nxt)
            if(FLOW::e[y].to > n) if(!FLOW::e[y].val){
                e[FLOW::e[y].to-n].push_back(i);
                flag = 1; break;
            }
        if(!flag) e[m+1].push_back(i);
    }
    cnt = 0;
    // printf("main: ");
    // rep(i, 1, m+1) printf("%d ", (int)e[i].size());
    // puts("");
    rep(i, 1, m+1) solve_ans(i);
    // assert(cnt == n);
    rep(i, 1, cnt) printf("%d ", ans[i]);
    puts("");
}

int main(){
    int T; scanf("%d", &T); while(T--) solve();
    return 0;
}