#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 505, inf = 1e9;

struct MCMF {
    
    struct edge {
        int to, cap, cost, rev;
        //edge() {}
        //edge(int to, int _cap, int _cost, int _rev) : to(to), cap(_cap), cost(_cost), rev(_rev) {}
    };

    int V, H[maxn + 5], dis[maxn + 5], PreV[maxn + 5], PreE[maxn + 5];
    vector<edge> G[maxn + 5];

    void init(int n) {
        V = n;
        for (int i = 0; i <= V; ++i)G[i].clear();
    }

    void addedge(int from, int to, int cap, int cost) {
        G[from].emplace_back(edge{to, cap, cost, (int) G[to].size()});
        G[to].emplace_back(edge{from, 0, -cost, (int) G[from].size() - 1});
    }

    int mcmf(int s, int t) {
        int res = 0, flow = 0;
        fill(H, H + 1 + V, 0);
        int f = inf;
        while (f) {
            priority_queue<pair<int, int> > q;
            fill(dis, dis + 1 + V, inf);
            dis[s] = 0;
            q.push(pair<int, int>(0, s));
            while (!q.empty()) {
                pair<int, int> now = q.top();
                q.pop();
                int v = now.second, Size;
                if (dis[v] < -now.first)continue;
                Size = G[v].size();
                for (int i = 0; i < Size; ++i) {
                    edge e = G[v][i];
                    if (e.cap > 0 && dis[e.to] > dis[v] + e.cost + H[v] - H[e.to]) {
                        dis[e.to] = dis[v] + e.cost + H[v] - H[e.to];
                        PreV[e.to] = v;
                        PreE[e.to] = i;
                        q.push(pair<int, int>(-dis[e.to], e.to));
                    }
                }
            }
            if (dis[t] == inf)break;
            for (int i = 0; i <= V; ++i)H[i] += dis[i];
            int d = f;
            for (int v = t; v != s; v = PreV[v])d = min(d, G[PreV[v]][PreE[v]].cap);
            f -= d;
            flow += d;
            res += d * H[t];
            for (int v = t; v != s; v = PreV[v]) {
                edge &e = G[PreV[v]][PreE[v]];
                e.cap -= d;
                G[v][e.rev].cap += d;
            }
        }
        return flow;
    }
} mcmf;


// namespace MCMF {
// 	#define INF INT_MAX

// 	int n, s, t, tot;
// 	std::vector<int> to, nxt, cap, cost, head;
// 	std::vector<int> dis;

// 	void AddEdge(int u, int v, int c, int w) {
// 		to[tot] = v, nxt[tot] = head[u], cap[tot] = c, cost[tot] = w, head[u] = tot++;
// 	}

// 	void Init(int _n, int _s, int _t, std::vector<std::array<int, 4> > edge) {
// 		n = _n, s = _s, t = _t, tot = 0;
// 		int m = edge.size();
// 		to = nxt = cap = cost = std::vector<int> (m << 1);
// 		head = dis = std::vector<int> (n, -1);
// 		for (auto [u, v, c, w] : edge) {
// 			AddEdge(u, v, c, w);
// 			AddEdge(v, u, 0, -w);
// 		}
// 	}

// 	std::pair<int, int> SPFA() {
// 		dis = std::vector<int> (n, INF);
// 		std::vector<int> vis(n), que;
// 		std::vector<std::pair<int, int> > pre(n, std::make_pair(-1, -1));
// 		que.emplace_back(s), dis[s] = 0, vis[s] = 1;
// 		for (int j = 0, u; j < que.size(); ++j) {
// 			u = que[j], vis[u] = 0;
// 			for (int i = head[u], v, c, w; ~i; i = nxt[i]) {
// 				v = to[i], c = cap[i], w = cost[i];
// 				int new_val = dis[u] + w;
// 				if (c && dis[v] > new_val) {
// 					dis[v] = new_val;
// 					pre[v] = std::make_pair(u, i);
// 					if (!vis[v]) que.emplace_back(v), vis[v] = 1;
// 				}
// 			}
// 		}
// 		if (dis[t] >= INT_MAX) return std::make_pair(0, 0);
// 		int min_cost = 0, max_flow = INF;
// 		int now = t;
// 		std::vector<int> all_e_idx;
// 		while (now != s) {
// 			auto [u, e_idx] = pre[now];
// 			now = u;
// 			max_flow = std::min(max_flow, cap[e_idx]);
// 			all_e_idx.emplace_back(e_idx);
// 		}
// 		for (int e_idx : all_e_idx) {
// 			min_cost += max_flow * cost[e_idx];
// 			cap[e_idx] -= max_flow, cap[e_idx ^ 1] += max_flow;
// 		}

// 		return std::make_pair(min_cost, max_flow);
// 	}

// 	std::pair<int, int> MCMF() {
// 		int min_cost = 0, max_flow = 0;
// 		while (true) {
// 			auto [new_cost, new_flow] = SPFA();
// 			if (!new_flow) break;
// 			else min_cost += new_cost, max_flow += new_flow;
// 		}
// 		return std::make_pair(min_cost, max_flow);
// 	}
// }

void charming() {
  int n, m; std::cin >> n >> m;
  std::vector<int> b(m);
  for (int i = 0; i < m; ++i) std::cin >> b[i];

  int s = 0, t = 1, tot = 2;
  std::map<int, int> mp0, mp1, rev_mp1;
  std::vector<std::array<int, 4> > edge;
  std::vector<std::vector<int> > a(n);
  for (int i = 0; i < n; ++i) {
    mp0[i] = tot++;
    edge.emplace_back((std::array<int, 4>) {s, mp0[i], 1, 0});
  }
  for (int i = 0; i < m; ++i) {
    mp1[i] = tot;
    rev_mp1[tot++] = i;
    edge.emplace_back((std::array<int, 4>) {mp1[i], t, b[i], 0});
  }
  for (int i = 0, k; i < n; ++i) {
    std::cin >> k;
    a[i] = std::vector<int> (k);
    for (int j = 0; j < k; ++j) {
      std::cin >> a[i][j], --a[i][j];
      edge.emplace_back((std::array<int, 4>) {mp0[i], mp1[a[i][j]], 1, j});
    }
  }
  
  mcmf.init(tot + 1);
  for (auto [u, v, c, w] : edge) mcmf.addedge(u, v, c, w);

  int ans = mcmf.mcmf(s, t);

  std::vector<int> seq;
  {

    std::vector<int> match(n, -1);
    for (int i = 0, u; i < n; ++i) {
      u = mp0[i];
      for (auto e : mcmf.G[u]) {
        int v = e.to, c = e.cap, w = e.cost;
        if (rev_mp1.count(v)) {
          if (!c) {
            match[i] = w;
            break;
          }
        }
      }
    }

    std::vector<int> vis(n);
    for (int i = 0; i < n; ++i) {
      for (int j = 0; j < n; ++j) if (match[j] > -1 && !vis[j]) {
        bool ok = true;
        for (int k = 0; k < match[j]; ++k) {
          if (b[a[j][k]]) {
            ok = false;
            break;
          }
        }
        if (ok) {
          vis[j] = 1;
          seq.emplace_back(j + 1);
          --b[a[j][match[j]]];
          break;
        }
      }
    }
    for (int i = 0; i < n; ++i) if (match[i] == -1) {
      seq.emplace_back(i + 1);
    }
  }
  
  // std::vector<int> vec(n);
  // std::iota(vec.begin(), vec.end(), 0);
  // sort(vec.begin(), vec.end(), [&](int x, int y) {
  //   if (match[x] == -1) return false;
  //   else if (match[y] == -1) return false;
  //   else {
  //     return match[x] < match[y];
  //   }
  // });

  std::cout << ans << '\n';
  for (int i = 0; i < n; ++i) std::cout << seq[i] << " \n"[i == n - 1];
}

signed main() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(NULL);
  std::cout.tie(NULL);
  int t; std::cin >> t;
  while (t--) charming();
  return 0;
}