#include <iostream>
#include <vector>
#include <algorithm>
#include <fstream>
#include <unordered_map>
#include <set>

using namespace std;

struct Scene {
    int index;
    vector<int> actors;
    double score;  // Heuristic score for scene scheduling
};

struct Actor {
    int id;
    int wage;
    vector<int> scenes;
    int scene_count;
};

// Calculate the cost of the current schedule
long long calculateCost(const vector<int>& schedule, const vector<Scene>& scenes, 
                       const vector<int>& wages, int M) {
    vector<int> first_appearance(wages.size(), -1);
    vector<int> last_appearance(wages.size(), -1);
    
    for (int i = 0; i < M; i++) {
        for (const int& actor : scenes[schedule[i]-1].actors) {
            if (first_appearance[actor-1] == -1) {
                first_appearance[actor-1] = i;
            }
            last_appearance[actor-1] = i;
        }
    }
    
    long long total_cost = 0;
    for (size_t i = 0; i < wages.size(); i++) {
        if (first_appearance[i] != -1) {
            total_cost += (long long)(last_appearance[i] - first_appearance[i] + 1) * wages[i];
        }
    }
    return total_cost;
}

// Try to improve schedule using local search
void localSearch(vector<int>& best_schedule, const vector<Scene>& scenes, 
                const vector<int>& wages, int M, int max_iterations) {
    long long best_cost = calculateCost(best_schedule, scenes, wages, M);
    
    for (int iter = 0; iter < max_iterations; iter++) {
        int i = rand() % M;
        int j = rand() % M;
        
        swap(best_schedule[i], best_schedule[j]);
        long long new_cost = calculateCost(best_schedule, scenes, wages, M);
        
        if (new_cost < best_cost) {
            best_cost = new_cost;
        } else {
            swap(best_schedule[i], best_schedule[j]);  // Revert if no improvement
        }
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    ifstream fin("star.in");
    ofstream fout("star.out");

    int N, M;
    fin >> N >> M;

    vector<int> wages(N);
    vector<Actor> actors(N);
    for (int i = 0; i < N; i++) {
        fin >> wages[i];
        actors[i].id = i + 1;
        actors[i].wage = wages[i];
        actors[i].scene_count = 0;
    }

    vector<Scene> scenes(M);
    for (int i = 0; i < M; i++) {
        scenes[i].index = i + 1;
        int br;
        fin >> br;
        scenes[i].actors.resize(br);
        
        double total_wage = 0;
        for (int j = 0; j < br; j++) {
            fin >> scenes[i].actors[j];
            actors[scenes[i].actors[j]-1].scenes.push_back(i+1);
            actors[scenes[i].actors[j]-1].scene_count++;
            total_wage += wages[scenes[i].actors[j]-1];
        }
        
        // Calculate scene score based on multiple factors
        scenes[i].score = total_wage / br;  // Average wage per actor
    }

    // Sort actors by wage (descending) and scene count (ascending)
    sort(actors.begin(), actors.end(), [](const Actor& a, const Actor& b) {
        if (a.scene_count == b.scene_count)
            return a.wage > b.wage;
        return a.scene_count < b.scene_count;
    });

    // Initialize schedule
    vector<int> schedule(M);
    vector<bool> used(M + 1, false);
    
    // Build initial schedule based on actor appearances
    int pos = 0;
    for (const Actor& actor : actors) {
        for (int scene : actor.scenes) {
            if (!used[scene]) {
                schedule[pos++] = scene;
                used[scene] = true;
            }
        }
    }
    
    // Fill remaining positions
    for (int i = 1; i <= M; i++) {
        if (!used[i]) {
            schedule[pos++] = i;
        }
    }

    // Apply local search to improve the solution
    localSearch(schedule, scenes, wages, M, min(5000, M * M));

    // Output result
    for (int i = 0; i < M; i++) {
        fout << schedule[i] << (i < M-1 ? " " : "");
    }

    fin.close();
    fout.close();
    return 0;
}