#include <bits/stdc++.h>

using namespace std;

const int N = 105, M = 1005;

int c[N], du[N];
vector<int> G[N];
vector< vector<int> > tG[N];
__int128 res[N], bc[N], Rc[N];

void dfs(int x) {
    if (res[x]) return;
    res[x] = -1;
    for (auto v : G[x]) dfs(v);
}

void output(__int128 x) {
    if (!x) return;
    output(x / 10); putchar(x % 10 + '0');
}

int dfn[N], low[N], inS[N], bcc[N];
vector<int> wh[N], nG[N], rG[N];
stack<int> S;

void Tarjan(int x) {
    dfn[x] = low[x] = ++dfn[0];
    S.push(x); inS[x] = 1;
    for (auto v : G[x]) {
        if (!dfn[v]) {
            Tarjan(v);
            low[x] = min(low[x], low[v]);
        } else if (inS[v]) {
            low[x] = min(low[x], dfn[v]);
        }
    }
    if (dfn[x] == low[x]) {
        ++bcc[0];
        int v;
        do {
            v = S.top(); S.pop();
            inS[v] = 0; bcc[v] = bcc[0];
            wh[bcc[0]].push_back(v);
        } while (v != x);
    }
}

void dfsdfs(int x) {
    if (bc[x] == -2) return;
    bc[x] = -2;
    for (auto v : nG[x]) {
        dfsdfs(v);
    }
}

__int128 xishu[N];

signed main() {
    int n, m; scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &c[i]);
    }
    for (int i = 1; i <= m; ++i) {
        int a, k; scanf("%d%d", &a, &k);
        tG[a].push_back(vector<int>{});
        while (k--) {
            int x; scanf("%d", &x);
            tG[a].back().push_back(x);
            G[a].push_back(x);
            ++du[x];
        }
    }
    for (int i = 1; i <= n; ++i) {
        if (c[i]) dfs(i);
    }
    for (int i = 1; i <= n; ++i) {
        if (!dfn[i]) {
            Tarjan(i);
        }
        Rc[bcc[i]] += c[i];
    }
    for (int i = 1; i <= n; ++i) {
        for (auto v : G[i]) {
            if (bcc[i] != bcc[v]) {
                nG[bcc[i]].push_back(bcc[v]);
            }
        }
    }
    for (int i = 1; i <= bcc[0]; ++i) {
        sort(nG[i].begin(), nG[i].end());
        nG[i].erase(unique(nG[i].begin(), nG[i].end()), nG[i].end());
        for (auto x : nG[i]) {
            rG[x].push_back(i);
        }
    }
    for (int i = 1; i <= bcc[0]; ++i) {
        int C = 0;
        for (auto v : wh[i]) {
            for (auto w : G[v]) {
                if (bcc[w] == i) {
                    ++C;
                }
            }
        }
        if (C >= wh[i].size()) {
            for (auto iv : nG[i]) {
                dfsdfs(iv);
            }
        }
        if (C > wh[i].size()) {
            int flg = 0;
            for (auto v : wh[i]) {
                for (auto z : tG[v]) {
                    int s = 0;
                    for (auto zz : z) {
                        s += (bcc[zz] == i);
                    }
                    flg |= (s >= 2);
                }
            }
            dfsdfs(i);
        }
    }
    for (int i = 1; i <= n; ++i) {
        if (res[i] == -1 && bc[bcc[i]] != -2) {
            bc[bcc[i]] = -1;
        }
    }
    for (int i = 1; i <= bcc[0]; ++i) {
        if (bc[i] != -1) {
            continue;
        }
        for (int j = 1; j <= bcc[0]; ++j) {
            xishu[j] = 0;
        }
        xishu[i] = 1;
        for (int j = 1; j <= bcc[0]; ++j) {
            if (j != i && wh[j].size() == 1) {
                int pos = wh[j][0];
                for (int k = 0; k < tG[pos].size(); ++k) {
                    __int128 s = 0;
                    for (int l = 0; l < tG[pos][k].size(); ++l) {
                        s += xishu[bcc[tG[pos][k][l]]];
                    }
                    xishu[j] = max(xishu[j], s);
                }
            }
        }
        bc[i] = 0;
        for (int j = 1; j <= bcc[0]; ++j) {
            bc[i] += xishu[j] * Rc[j];
        }
    }
    for (int i = 1; i <= n; ++i) {
        if (res[i] == 0) puts("0");
        else if (res[i] == -2 || bc[bcc[i]] == -2) puts("infinity");
        else output(bc[bcc[i]]), putchar('\n');
    }
    return 0;
}