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

const LL INF = 1e18;

struct Dinic {
    struct Edge {
        int v;
        LL w, c;
        Edge(int v, LL w, LL c) : v(v), w(w), c(c) {}
    };

    int n;
    vector<Edge> edges;
    vector<LL> d;
    vector<int> cur;
    vector<vector<int>> e;
    vector<bool> vis;
    Dinic(int n) : n(n), d(n), cur(n), e(n), vis(n) {}

    void reset(int n) { 
        this->n = n;
        edges.clear();
        e.resize(n), d.resize(n), cur.resize(n), vis.resize(n);
        for (int i = 0; i < n; ++i) 
            e.clear();
    }

    // c 取反，即是最大费用最大流
    void add(int u, int v, LL w, LL c) {
        e[u].push_back(edges.size());
        edges.emplace_back(v, w, c);
        e[v].push_back(edges.size());
        edges.emplace_back(u, 0, -c);
    }

    bool bfs(int s, int t) {
        d.assign(n, INF);
        queue<int> q;
        d[s] = 0;
        vis[s] = 1;
        q.push(s);
        while (q.size()) {
            int u = q.front();
            vis[u] = 0;
            q.pop();
            for (int i : e[u]) {
                auto [v, w, c] = edges[i];
                if (w && d[v] > d[u] + c) {  // 有 w 才能保证正确性（能正确回溯）
                    d[v] = d[u] + c;
                    if (!vis[v]) {
                        vis[v] = 1;
                        q.push(v);
                    }
                }
            }
        }
        return d[t] != INF;
    }

    pair<LL, LL> maxFlow(int s, int t) {
        LL maxflow = 0, cost = 0;

        auto dfs = [&](auto &&self, int u, LL flow) -> LL {
            if (u == t) return flow;  // 返回至多能减多少。
            vis[u] = 1;
            LL rest = flow;
            for (int &i = cur[u]; i < (int)e[u].size(); ++i) {
                int j = e[u][i];
                auto [v, w, c] = edges[j];
                if (!vis[v] && w && d[v] == d[u] + c) {
                    LL k = self(self, v, min(rest, w));
                    rest -= k, edges[j].w -= k, edges[j ^ 1].w += k;
                    cost += k * c;
                    if (!rest) break;  // 这里 break 才能保证复杂度。
                }
            }
            vis[u] = 0; // !
            return flow - rest;
        };

        while (bfs(s, t)) {
            cur.assign(n, 0);
            maxflow += dfs(dfs, s, numeric_limits<LL>::max());
        }

        return {maxflow, cost};
    }
};

void solve() {
    int n, m;
    cin >> n >> m;

    Dinic dinic(n + m + 2);
    const int S = n + m, T = n + m + 1;

    for (int i = 0; i < n; ++i) {
        dinic.add(S, i, 1, 0);
    }

    for (int i = 0; i < m; ++i) {
        int x;
        cin >> x;
        dinic.add(i + n, T, x, 0);
    }

    for (int i = 0; i < n; ++i) {
        int x;
        cin >> x;
        for (int j = 0; j < x; ++j) {
            int y;
            cin >> y;
            dinic.add(i, n + y - 1, 1, j);
        }
    }

    auto [ans, _] = dinic.maxFlow(S, T);

    cout << ans << '\n';

    vector<int> mat(n, -1);
    vector<vector<int>> a(m);
    for (int i = 0; i < n; ++i) {
        for (auto it = dinic.e[i].rbegin(); it != dinic.e[i].rend(); it++) {
            auto [v, w, c] = dinic.edges[*it];

            if (v == S) {
                continue;
            }

            if (w == 0) {
                mat[i] = v - n;
            } else if (mat[i] != -1) {
                a[v - n].push_back(i);
            }
        }
    }

    vector<vector<int>> b(n);
    vector<int> d(n);
    for (int i = 0; i < n; ++i) {
        if (mat[i] == -1) {
            continue;
        }

        for (int v : a[mat[i]]) {
            b[i].push_back(v);
            ++d[v];
        }
    }

    queue<int> q;
    for (int i = 0; i < n; ++i) {
        if (mat[i] != -1 && d[i] == 0) {
            q.push(i); 
        }
    }

    vector<int> ans1;
    while (q.size()) {
        int u = q.front();
        q.pop();
        ans1.push_back(u);

        for (int v : b[u]) {
            --d[v];
            if (d[v] == 0) {
                q.push(v);
            }
        }
    }

    for (int i = 0; i < n; ++i) {
        if (mat[i] == -1) {
            ans1.push_back(i);
        }
    }

    for (int i = 0; i < n; ++i) {
        cout << ans1[i] + 1 << " \n"[i == n - 1];
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    int t;
    cin >> t;
    while (t--) {
        solve();
    } 
    return 0;
}

/*
1
5 3
1 2 2
2 1 2
2 1 2
2 1 3
2 1 3
2 1 3
*/