#include <algorithm>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iostream>
#include <ranges>
#include <vector>

using namespace std;

constexpr int MAXN = 10000, MAXM = 5000;

int n, m;
int64_t cost[MAXN];
vector<int> actors_for_scene[MAXM];
vector<int> scenes_for_actor[MAXN];
int index_for_scene[MAXM];
int actors[MAXN];
int scenes[MAXM];
int index_for_scene_fixed[MAXM];
int scenes_best[MAXM];
int64_t best_value = 1e18;
clock_t start_time;
double time_limit = 4.9;

inline auto sort_key(int actor)
{
    return -cost[actor];
}

int64_t finish(int scenes_used)
{
    int64_t value = 0;
    for (int i = 0; i < n; ++i) {
        int actor = actors[i];
        int first = m - 1, last = 0;
        for (int scene : scenes_for_actor[actor]) {
            if (index_for_scene[scene] == -1) {
                index_for_scene[scene] = scenes_used;
                scenes[scenes_used++] = scene;
            }
            first = min(first, index_for_scene[scene]);
            last = max(last, index_for_scene[scene]);
        }
        value += cost[actor] * (last - first + 1);
    }
    return value;
}

bool recurse(int limit, int scenes_used = 0)
{
    if (double(clock() - start_time) / CLOCKS_PER_SEC > time_limit) {
        return true;
    }
    if (limit == 0 || scenes_used == m) {
        memcpy(index_for_scene, index_for_scene_fixed, m * sizeof(*index_for_scene));
        int64_t value = finish(scenes_used);
        if (value < best_value) {
            best_value = value;
            memcpy(scenes_best, scenes, m * sizeof(*scenes));
        }
        return false;
    }
    for (int i = 0; i < m; ++i) {
        if (index_for_scene_fixed[i] == -1) {
            index_for_scene_fixed[i] = scenes_used;
            scenes[scenes_used] = i;
            if (recurse(limit - 1, scenes_used + 1)) {
                return true;
            }
            index_for_scene_fixed[i] = -1;
        }
    }
    return false;
}

int main()
{
    start_time = clock();

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

    cin >> n >> m;

    for (int i = 0; i < n; ++i) {
        cin >> cost[i];
        actors[i] = i;
    }

    for (int i = 0; i < m; ++i) {
        index_for_scene_fixed[i] = -1;
        int br;
        cin >> br;
        actors_for_scene[i].resize(br);
        for (int j = 0; j < br; ++j) {
            cin >> actors_for_scene[i][j];
            actors_for_scene[i][j]--;
            scenes_for_actor[actors_for_scene[i][j]].push_back(i);
        }
    }

    sort(actors, actors + n, [](int a, int b) { return sort_key(a) < sort_key(b); });

    for (int limit = 0; limit <= m; ++limit) {
        if (recurse(limit)) {
            break;
        }
    }
    // cerr << finish(0) << endl;
    // memcpy(scenes_best, scenes, m * sizeof(*scenes));

    for (int i = 0; i < m; ++i) {
        cout << scenes_best[i] + 1 << ' ';
    }

    cout << endl;
}