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

#define pb emplace_back
#define mp make_pair

using ll = long long;
using pii = pair<int,int>;

constexpr int mod = 998244353;
constexpr int inf = 0x3f3f3f3f;
constexpr int N = 1e3 + 10;

struct Edge{
  int from, to, cap, flow, cost;
  Edge(){}
  Edge(int from, int to, int cap, int cost):from(from),to(to),cap(cap),cost(cost){
    flow = 0;
  }
};

struct Node{
  int id, d;
  Node(){}
  Node(int id, int d):id(id),d(d){}
  bool operator < (const Node &A)const{
    return d > A.d;
  }
};

int T, n, m, b[N], pt[N], key[N], used[N];
vector<int> a[N];
vector<int> V[N];
vector<Edge> G;
int tar, P[N], dis[N];
bool inq[N], vis[N];
int flow, cost, h[N];

void add_edge(int from, int to, int cap, int cost){
  G.pb(from, to, cap, cost);
  G.pb(to, from, 0, -cost);
  int x = G.size();
  V[from].pb(x - 2);
  V[to].pb(x - 1);
}

void spfa(){
  queue<int> Q;
  for(int i=0; i<=tar; ++i){
    inq[i] = 0;
    h[i] = inf;
  }
  Q.push(0);
  inq[0] = 1;
  h[0] = 0;
  while(!Q.empty()){
    int x = Q.front(); Q.pop();
    inq[x] = 0;
    for(int i : V[x]){
      Edge &e = G[i];
      if(e.cap > e.flow && h[e.to] > h[x] + e.cost){
        h[e.to] = h[x] + e.cost;
        if(!inq[e.to]){
          inq[e.to] = 1;
          Q.push(e.to);
        }
      }
    }
  }
}

bool dijkstra() {
  priority_queue<Node> Q;
  for(int i=0; i<=tar; ++i){
    dis[i] = inf;
    vis[i] = 0;
  }
  dis[0] = 0;
  Q.emplace(0, 0);
  while(!Q.empty()){
    auto nd = Q.top(); Q.pop();
    if(vis[nd.id])  continue;
    vis[nd.id] = 1;
    for(int i : V[nd.id]){
      Edge &e = G[i];
      int nc = e.cost + h[nd.id] - h[e.to];
      if(e.cap > e.flow && dis[e.to] > dis[nd.id] + nc) {
        dis[e.to] = dis[nd.id] + nc;
        P[e.to] = i;
        if(!vis[e.to])  Q.emplace(e.to, dis[e.to]);
      }
    }
  }
  return dis[tar] != inf;
}

void get_ans(int len){
  for(int i=1; i<=n; ++i){
    pt[i] = 0;
    key[i] = -1;
    vis[i] = 0;
    for(int j=0; j<V[i].size(); ++j){
      auto &e = G[V[i][j]];
      if(e.to > n && e.to < tar && e.flow > 0){
        key[i] = e.to - n;
        break;
      }
    }
  }
  for(int i=1; i<=m; ++i) used[i] = 0;
  vector<int> ans;
  for(int i=0; i<len; ++i){
    for(int j=1; j<=n; ++j){
      if(key[j] == -1 || vis[j])  continue;
      int x = a[j][pt[j]];
      while(used[x] == b[x]){
        x = a[j][++pt[j]];
      }
      if(x == key[j]){
        ++used[x];
        ans.pb(j);
        vis[j] = 1;
        break;
      }
    }
  }
  for(int i=1; i<=n; ++i){
    if(key[i] == -1)  ans.pb(i);
  }
  cout << len << '\n';
  for(int i=0; i<n; ++i)  cout << ans[i] << " \n"[i == n - 1];
}

void _main(){
  cin >> T;
  while(T--){
    cin >> n >> m;
    tar = n + m + 1;
    for(int i=1; i<=m; ++i) cin >> b[i];
    for(int i=1; i<=n; ++i){
      int k;
      cin >> k;
      a[i].resize(k);
      add_edge(0, i, 1, 0);
      for(int j=0; j<k; ++j){
        cin >> a[i][j];
        add_edge(i, a[i][j] + n, 1, j);
      }
    }
    for(int i=1; i<=m; ++i){
      add_edge(i + n, tar, b[i], 0);
    }

    flow = cost = 0;
    spfa();
    while(dijkstra()){
      int minf = inf;
      for(int i=0; i<=tar; ++i) h[i] += dis[i];
      for(int i=tar; i != 0; i=G[P[i]].from)  minf = min(minf, G[P[i]].cap - G[P[i]].flow);
      for(int i=tar; i != 0; i=G[P[i]].from){
        G[P[i]].flow += minf;
        G[P[i] ^ 1].flow -= minf;
      }
      flow += minf;
      cost += minf * h[tar];
    }

    get_ans(flow);

    for(int i=1; i<=n; ++i) a[i].clear();
    G.clear();
    for(int i=0; i<=tar; ++i) V[i].clear();
  }
}

int main(){
  ios::sync_with_stdio(false);
  cin.tie(nullptr); cout.tie(nullptr);
  _main();
  cout.flush();
  return 0;
}