#include <bits/stdc++.h>

typedef long long ll;

const int MAXN = 1e4 + 10;
const int MAXM = 5e3 + 10;
const double TIMELIMIT = 4.95000;
constexpr double TIME_MULT = 1;

std::chrono::high_resolution_clock::time_point startTime, curTime;

double timeElapsed()
{
    using namespace std::chrono;
    curTime = high_resolution_clock::now();
    double time = duration_cast<duration<double>>(curTime - startTime).count();
    return time * TIME_MULT;
}

std::mt19937 mt(time(nullptr));

struct actor
{
    int idx;
    ll cost;

    actor(){};

    actor(int _idx, ll _cost)
    {
        idx = _idx;
        cost = _cost;
    }
};

struct scene
{
    int idx;
    int sz;
    ll sum;
    double average;
    std::vector < actor > actors;

    scene(){};

    scene(int _idx, int _sz, ll _sum, double _average, std::vector < actor > _actors)
    {
        idx = _idx;
        sz = _sz;
        sum = _sum;
        average = _average;
        actors = _actors;
    }
};

struct acts
{
    int idx;
    ll cost;
    ll sum;
    int sz;
    int sumsz;
    double average1;
    double average2;
    std::vector < int > vs;

    acts(){};

    acts(int _idx, ll _cost, ll _sum, int _sz, int _sumsz, double _average1, double _average2, std::vector < int > _vs)
    {
        idx = _idx;
        cost = _cost;
        sum = _sum;
        sz = _sz;
        sumsz = _sumsz;
        average1 = _average1;
        average2 = _average2;
        vs = _vs;
    }
};

int n, m;
actor a[MAXN];
actor orga[MAXN];
scene s[MAXM];
scene orgs[MAXM];

acts inscenes[MAXN];
std::vector < int > toadd[MAXN];

bool compare_by_cost_actor(acts a1, acts a2)
{
    return a1.cost < a2.cost;
}

bool compare_by_size_actor(acts a1, acts a2)
{
    return a1.sz < a2.sz;
}

bool compare_by_sumsz_actor(acts a1, acts a2)
{
    return a1.sumsz < a2.sumsz;
}

bool compare_by_sum_actor(acts a1, acts a2)
{
    return a1.sum < a2.sum;
}

bool compare_by_average1_actor(acts a1, acts a2)
{
    return a1.average1 < a2.average1;
}

bool compare_by_average2_actor(acts a1, acts a2)
{
    return a1.average2 < a2.average2;
}



bool compare_by_average_scene(scene s1, scene s2)
{
    return s1.average < s2.average;
}

bool compare_by_sum_scene(scene s1, scene s2)
{
    return s1.sum < s2.sum;
}

bool compare_by_size_scene(scene s1, scene s2)
{
    return s1.sz < s2.sz;
}



ll ans_cost = LLONG_MAX;
std::vector < int > ans_perm;
std::vector < int > perm;

void read()
{
    std::cin >> n >> m;

    for(int i = 1; i <= n; i++)
    {
        ll cost;
        std::cin >> cost;

        orga[i] = a[i] = actor(i, cost);
    }

    for(int i = 1; i <= m; i++)
    {
        int k;
        std::cin >> k;

        std::vector < actor > tmp;
        ll sum = 0;

        tmp.resize(k + 1);

        for(int j = 1; j <= k; j++)
        {
            int aidx;
            std::cin >> aidx;

            tmp[j] = orga[aidx];
            sum += orga[aidx].cost;

            toadd[aidx].push_back(i);
        }

        if(sum < 0)
            sum = LLONG_MAX;

        orgs[i] = s[i] = scene(i, k, sum, (double)((double)(sum) / (double)(k)), tmp);
    }

    for(int i = 1; i <= n; i++)
    {
        int sz = toadd[i].size();
        ll sum = 0;
        int sumsz = 0;
        double average1 = 0;
        double average2 = 0;

        for(int x : toadd[i])
        {
            sum += orgs[x].sum;
            sumsz += orgs[x].sz;
            average1 += orgs[x].average;
        }

        if(sum < 0)
            sum = LLONG_MAX;

        if(average1 < 0)
            average1 = 1e9;

        average1 = (double)(average1 / (double)(sz));
        average2 = (double)((double)(sum) / (double)(sumsz));

        inscenes[i] = acts(i, orga[i].cost, sum, sz, sumsz, average1, average2, toadd[i]);
    }
}

void aperm_to_perm()
{
    std::vector < bool > used(m + 1, 0);
    int ptr = 0;
    for(int i = 1; i <= n; i++)
    {
        for(int curs : inscenes[i].vs)
        {
            if(!used[curs])
            {
                used[curs] = true;
                perm[++ptr] = curs;
            }
        }
    }
}

bool check_perm()
{
    std::vector < bool > used(m + 1, 0);

    for(int i = 1; i <= m; i++)
    {
        if(!(1 <= perm[i] && perm[i] <= m))
            return false;

        if(used[perm[i]])
            return false;

        used[perm[i]] = 1;
    }

    return true;
}

void grade_perm()
{
    if(!check_perm())
        return;

    std::vector < int > toleft, toright;
    toleft.resize(n + 1, 0);
    toright.resize(n + 1, 0);

    for(int i = 1; i <= m; i++)
    {
        for(int j = 1; j <= orgs[perm[i]].sz; j++)
        {
            int cura = orgs[perm[i]].actors[j].idx;

            if(toleft[cura] == 0)
                toleft[cura] = i;
        }
    }

    for(int i = m; i >= 1; i--)
    {
        for(int j = 1; j <= orgs[perm[i]].sz; j++)
        {
            int cura = orgs[perm[i]].actors[j].idx;

            if(toright[cura] == 0)
                toright[cura] = i;
        }
    }

    ll sum = 0;

    for(int i = 1; i <= n; i++)
    {
        if(toleft[i] == 0 || toright[i] == 0)
            continue;

        ll len = toright[i] - toleft[i] + 1;

        sum = sum + len * orga[i].cost;
    }

    if(sum > 0 && sum < ans_cost)
    {
        ans_cost = sum;
        ans_perm = perm;
    }
}

void generate_perm()
{
    for(int i = 1; i <= m; i++)
    {
        perm[i] = s[i].idx;
    }
}

void make_pyramid()
{
    int sz = perm.size();
    
    int left, right;

    sz--;
    std::vector < int > ans(sz + 1, 0);

    if(sz % 2 == 0)
    {
        left = sz / 2;
        right = sz / 2 + 1;

        bool sw = true;

        for(int i = 1; i <= sz; i++)
        {
            if(sw && left >= 1)
            {
                ans[left] = perm[i];
                left--;
            }
            else if(right <= sz)
            {
                ans[right] = perm[i];
                right++;
            }

            sw ^= 1;
        }

        perm = ans;
    }
    else
    {
        ans[sz / 2 + 1] = perm[1];

        left = sz / 2;
        right = sz / 2 + 2;
        bool sw = true;

        for(int i = 2; i <= sz; i++)
        {
            if(sw && left >= 1)
            {
                ans[left] = perm[i];
                left--;
            }
            else if(right <= sz)
            {
                ans[right] = perm[i];
                right++;
            }

            sw ^= 1;
        }

        perm = ans;
    }
}

void try_all()
{
    generate_perm();
    grade_perm();
    make_pyramid();
    grade_perm();
}

void solve_greedy_by_scenes()
{
    perm.resize(m + 1, 0);
    try_all();

    std::sort(s + 1, s + m + 1, compare_by_average_scene);
    try_all();
    std::reverse(s + 1, s + m + 1);
    try_all();

    std::sort(s + 1, s + m + 1, compare_by_sum_scene);
    try_all();
    std::reverse(s + 1, s + m + 1);
    try_all();

    std::sort(s + 1, s + m + 1, compare_by_size_scene);
    try_all();
    std::reverse(s + 1, s + m + 1);
    try_all();
}

void solve_greedy_by_actors()
{
    perm.resize(m + 1);

    std::sort(inscenes + 1, inscenes + n + 1, compare_by_cost_actor);
    aperm_to_perm();
    grade_perm();

    std::reverse(inscenes + 1, inscenes + n + 1);
    aperm_to_perm();
    grade_perm();

    std::sort(inscenes + 1, inscenes + n + 1, compare_by_size_actor);
    aperm_to_perm();
    grade_perm();
    std::reverse(inscenes + 1, inscenes + n + 1);
    aperm_to_perm();
    grade_perm();


    std::sort(inscenes + 1, inscenes + n + 1, compare_by_sum_actor);
    aperm_to_perm();
    grade_perm();
    std::reverse(inscenes + 1, inscenes + n + 1);
    aperm_to_perm();
    grade_perm();


    std::sort(inscenes + 1, inscenes + n + 1, compare_by_sumsz_actor);
    aperm_to_perm();
    grade_perm();
    std::reverse(inscenes + 1, inscenes + n + 1);
    aperm_to_perm();
    grade_perm();


    std::sort(inscenes + 1, inscenes + n + 1, compare_by_average1_actor);
    aperm_to_perm();
    grade_perm();
    std::reverse(inscenes + 1, inscenes + n + 1);
    aperm_to_perm();
    grade_perm();


    std::sort(inscenes + 1, inscenes + n + 1, compare_by_average2_actor);
    aperm_to_perm();
    grade_perm();
    std::reverse(inscenes + 1, inscenes + n + 1);
    aperm_to_perm();
    grade_perm();
}

void print()
{
    //cout << ans_cost << endl;
    for(int i = 1; i <= m; i++)
    {
        std::cout << ans_perm[i] << " ";
    }
    std::cout << std::endl;
}

void solve_random()
{
    perm = ans_perm;

    while(timeElapsed() < TIMELIMIT)
    {
        int idx1 = mt() % m + 1;
        int idx2 = mt() % m + 1;

        while(idx1 == idx2)
        {
            idx2 = mt() % m + 1;
        }

        std::swap(perm[idx1], perm[idx2]);

        grade_perm();
    }
}

int main()
{
    startTime = std::chrono::high_resolution_clock::now();

    freopen("star.in", "r", stdin);
    freopen("star.out", "w", stdout);

    std::ios_base :: sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);

    read();

    solve_greedy_by_actors();
    solve_greedy_by_scenes();
    solve_random();

    print();

    //std::cout << timeElapsed() << std::endl;

    return 0;
}