#include <iostream>
#include <vector>
#include <unordered_map>
#include <fstream>
#include <sstream>
#include <queue>
#include <algorithm>
#include <string>
#include <climits>
using namespace std;

vector<int> costs;

pair<int, int> cmp(unordered_map<int, int>& map) {
    int node = -1;
    int min = INT_MAX;
    
    for(auto it: map){
        if (it.second < min && it.second > 0)
        {
            min = it.second;
            node = it.first;
        }
        else if (it.second == min && (it.second * costs[it.first]) < (min * costs[node]))
        {
            node = it.first;
        }
        else if (it.second == min && (it.second * costs[it.first]) == (min * costs[node]) && costs[it.first] > costs[node])
        {
            node = it.first;
        }
    }

    return {node, min};
}

bool cmp1(pair< int, vector<int>>& a, pair< int, vector<int>>& b) {
    return a.second.size() < b.second.size();
}

vector<int> minimalOrder(int N, int M, vector<pair<int, vector<int>>>& scenes, unordered_map<int, int>& actorScenes) {
    vector<int> res;
    queue<int> q;

    pair<int, int> first = cmp(actorScenes);

    for (int i = 0; i < scenes.size(); i++)
    {
        if (count(scenes[i].second.begin(), scenes[i].second.end(), first.first) == 1) {
            q.push(scenes[i].first);
            for (int j = 0; j < scenes[i].second.size(); j++)
            {
                actorScenes[scenes[i].second[j]]--;
            }
            scenes.erase(scenes.begin() + i);
            break;
        }
    }

    while (!q.empty())
    {
        int scene = q.front();
        q.pop();

        res.push_back(scene);

        if (scenes.empty())
        {
            break;
        }

        pair<int, int> lookfor = cmp(actorScenes);

        for (int i = 0; i < scenes.size(); i++)
        {
            if (count(scenes[i].second.begin(), scenes[i].second.end(), lookfor.first) == 1) {
                q.push(scenes[i].first);
                for (int j = 0; j < scenes[i].second.size(); j++)
                {
                    actorScenes[scenes[i].second[j]]--;
                }
                scenes.erase(scenes.begin() + i);
                break;
            }
        }

        sort(scenes.begin(), scenes.end(), cmp1);
    }

    return res;
}

int main() {
    string myText;
    ifstream MyReadFile("star.in");
    if (!MyReadFile.is_open()) {
        cerr << "Error opening input file" << endl;
        return 1;
    }

    getline(MyReadFile, myText);
    stringstream ss(myText);

    int N, M;
    ss >> N >> M;

    if (N == 0 || M == 0) {
        ofstream MyFile("star.out");
        MyFile << ""; // Празен изход
        MyFile.close();
        return 0;
    }

    ss.clear();

    vector<pair<int, vector<int>>> scenes;
    costs.resize(N + 1);
    unordered_map<int, int>actorScenes;

    getline(MyReadFile, myText);
    ss.str(myText);

    int actor = 1;
    int curr;

    while (ss >> curr)
    {
        costs[actor] = curr;
        actorScenes[actor] = 0;
        actor++;
    }

    ss.clear();

    for (int i = 0; i < M; i++) {

        getline(MyReadFile, myText);
        ss.str(myText);

        pair<int, vector<int>> scene;
        scene.first = i + 1;

        int actorC;
        ss >> actorC;

        while (ss >> actorC)
        {
            scene.second.push_back(actorC);
            actorScenes[actorC]++;
        }

        scenes.push_back(scene);
        ss.clear();
    }

    ss.clear();
    MyReadFile.close();

    sort(scenes.begin(), scenes.end(), cmp1);

    // Solve the problem
    auto result = minimalOrder(N, M, scenes, actorScenes);

    if (!result.empty())
    {
        string res = "";

        for (auto scene : result)
        {
            res += to_string(scene);
            res += ' ';
        }

        if (!res.empty()) {
            res.pop_back();
        }

        ofstream MyFile("star.out");
        MyFile << res;

        MyFile.close();
    }

    return 0;
}