#include <limits>
#include <queue>
#include <vector>
using i64 = long long;
using ll = long long;

struct MCFGraph {
    struct Edge {
        int v, c;
        ll f;
        Edge(int v, int c, ll f) : v(v), c(c), f(f) {}
    };
    const int n;
    std::vector<Edge> e;
    std::vector<std::vector<int>> g;
    std::vector<i64> h, dis;
    std::vector<int> pre;
    bool dijkstra(int s, int t) {
        dis.assign(n, std::numeric_limits<i64>::max());
        pre.assign(n, -1);
        std::priority_queue<std::pair<i64, int>, std::vector<std::pair<i64, int>>, std::greater<std::pair<i64, int>>> que;
        dis[s] = 0;
        que.emplace(0, s);
        while (!que.empty()) {
            i64 d = que.top().first;
            int u = que.top().second;
            que.pop();
            if (dis[u] < d) continue;
            for (int i : g[u]) {
                int v = e[i].v;
                int c = e[i].c;
                ll f = e[i].f;
                if (c > 0 && dis[v] > d + h[u] - h[v] + f) {
                    dis[v] = d + h[u] - h[v] + f;
                    pre[v] = i;
                    que.emplace(dis[v], v);
                }
            }
        }
        return dis[t] != std::numeric_limits<i64>::max();
    }
    MCFGraph(int n) : n(n), g(n) {}
    int add(int u, int v, int c, ll f) { // 最大流
        g[u].push_back(e.size());
        int t = e.size();
        e.emplace_back(v, c, f);
        g[v].push_back(e.size());
        e.emplace_back(u, 0, -f);
        return t;
    }

    // void addEdge(int u, int v, int c, int f) {
    //     if (f < 0) {
    //         g[u].push_back(e.size());
    //         e.emplace_back(v, 0, f);
    //         g[v].push_back(e.size());
    //         e.emplace_back(u, c, -f);
    //     } else {
    //         g[u].push_back(e.size());
    //         e.emplace_back(v, c, f);
    //         g[v].push_back(e.size());
    //         e.emplace_back(u, 0, -f);
    //     }
    // }
    std::pair<int, i64> flow(int s, int t) {
        int flow = 0;
        i64 cost = 0;
        h.assign(n, 0);
        while (dijkstra(s, t)) {
            for (int i = 0; i < n; ++i) h[i] += dis[i];
            int aug = std::numeric_limits<int>::max();
            for (int i = t; i != s; i = e[pre[i] ^ 1].v) aug = std::min(aug, e[pre[i]].c);
            for (int i = t; i != s; i = e[pre[i] ^ 1].v) {
                e[pre[i]].c -= aug;
                e[pre[i] ^ 1].c += aug;
            }
            flow += aug;
            cost += i64(aug) * h[t];
        }
        return std::make_pair(flow, cost);
    }
};

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f

using namespace std;
const int N = 1505;
vector<int> g[N];
int c[N];
int b[N];
int n, m;

vector<int> get_ans() {
    vector<int> b1(m + 1);
    for (int i = 1; i <= m; ++i) b1[i] = b[i];
    queue<int> q;
    vector<int> ans;
    vector<int> cur(n + 1, 0);
    vector<vector<int>> w(m + 1);

    ans.reserve(n);

    auto get = [&](int i) {
        return g[i][cur[i]];
    };
    for (int i = 1; i <= m; ++i) {
        if (b1[i] == 0) q.push(i);
    }
    for (int i = 1; i <= n; ++i) {
        if (c[i] == 0) continue;
        int w1 = g[i][cur[i]];
        if (w1 == c[i]) {
            // assert(b1[w1] > 0);
            b1[w1]--;
            if (b1[w1] == 0) q.push(w1);
            ans.push_back(i);
        } else {
            w[w1].push_back(i);
        }
    }

    while (q.size()) {
        int f = q.front();
        q.pop();
        for (const auto u : w[f]) {
            while (b1[get(u)] == 0) {
                cur[u]++;
            }
            int w1 = get(u);
            if (w1 == c[u]) {
                // assert(b1[w1] > 0);
                b1[w1]--;
                if (b1[w1] == 0) q.push(w1);
                ans.push_back(u);
            } else {
                w[w1].push_back(u);
            }
        }
        w[f].clear();
    }

    for (int i = 1; i <= n; ++i) {
        if (c[i] == 0) ans.push_back(i);
    }
    return ans;
}

int s, t;

void INIT() {
    s = n + m + 1, t = n + m + 2;
}

void solve() {
    cin >> n >> m;
    INIT();
    vector<vector<int>> as(n + 1, vector<int>(m + 1));
    MCFGraph mcfg(t + 2);
    for (int i = 1; i <= n; ++i) g[i].clear();
    for (int i = 1; i <= m; ++i) cin >> b[i], mcfg.add(n + i, t, b[i], 0);
    for (int i = 1; i <= n; ++i) {
        mcfg.add(s, i, 1, 0);
        int k;
        cin >> k;
        g[i].reserve(k);
        int la = 0;
        for (int j = 1, tmp; j <= k; ++j) {
            cin >> tmp;
            g[i].push_back(tmp);
            // mcfg.add(i, n + tmp, 1, j);
            as[i][tmp] = mcfg.add(i, n + tmp, 1, j);
        }
    }

    memset(c, 0, sizeof(c));
    auto [flow, _] = mcfg.flow(s, t);
    for (int i = 1; i <= n; ++i) {
        for (int x : g[i]) {
            if (mcfg.e[as[i][x]].c == 0) c[i] = x;
        }
    }
    cout << flow << '\n';
    vector<int> ans = get_ans();
    for (auto u : ans) {
        cout << u << " ";
    }
    cout << '\n';
    // puts("");
}

int main() {
    cin.tie(0), cout.tie(0), ios::sync_with_stdio(0);

    int t;
    cin >> t;
    while (t--) solve();
}
/*
1
5 4
1 1 1 1

1 1
3 3 1 2
1 1
2 1 3
4 1 2 3 4
*/