#include <algorithm>
#include <fstream>
#include <unordered_map>
#include <vector>
#include <string>
#include <limits>
#include <cstdint>
#include <cmath>

using namespace std;

int64_t calculateTotalCost(const vector<int>& sceneOrder,
    const unordered_map<int, vector<int>>& actorScenes,
    const unordered_map<int, int>& actorWages) {
    unordered_map<int, int> sceneToIndex;
    for (size_t i = 0; i < sceneOrder.size(); ++i) {
        sceneToIndex[sceneOrder[i]] = i;
    }

    int64_t totalCost = 0;
    for (const auto& pair : actorScenes) {
        int actor = pair.first;
        const vector<int>& scenes = pair.second;

        int firstIndex = numeric_limits<int>::max();
        int lastIndex = numeric_limits<int>::min();

        for (int scene : scenes) {
            int idx = sceneToIndex[scene];
            firstIndex = min(firstIndex, idx);
            lastIndex = max(lastIndex, idx);
        }

        int timeOnSet = lastIndex - firstIndex + 1;
        totalCost += static_cast<int64_t>(timeOnSet) * actorWages.at(actor);
    }

    return totalCost;
}

vector<int> findNearlyOptimalSceneOrderV2(const vector<int>& scenes,
    const unordered_map<int, vector<int>>& actorScenes,
    const unordered_map<int, int>& actorWages) {
    unordered_map<int, double> sceneWeights;

    for (const auto& pair : actorScenes) {
        int actor = pair.first;
        const vector<int>& scenes2 = pair.second;
        for (int scene : scenes2) {
            sceneWeights[scene] += actorWages.at(actor);
        }
    }

    vector<int> sortedScenes = scenes;
    sort(sortedScenes.begin(), sortedScenes.end(),
        [&sceneWeights](int a, int b) {
            return sceneWeights[a] > sceneWeights[b];
        });

    return sortedScenes;
}

vector<int> findNearlyOptimalSceneOrderV3(const vector<int>& scenes,
    const unordered_map<int, vector<int>>& actorScenes,
    const unordered_map<int, int>& actorWages) {
    unordered_map<int, double> sceneWeights;
    unordered_map<int, pair<int, int>> actorSceneRanges;

    for (const auto& pair : actorScenes) {
        int actor = pair.first;
        const vector<int>& scenes2 = pair.second;
        int minScene = *min_element(scenes2.begin(), scenes2.end());
        int maxScene = *max_element(scenes2.begin(), scenes2.end());
        actorSceneRanges[actor] = make_pair(minScene, maxScene);

        for (int scene : scenes2) {
            sceneWeights[scene] += actorWages.at(actor);
        }
    }

    unordered_map<int, double> sceneScores;
    for (int scene : scenes) {
        double waitingCost = 0;
        for (const auto& pair2 : actorSceneRanges) {
            int actor = pair2.first;
            const pair<int, int>& range = pair2.second;
            if (range.first <= scene && scene <= range.second) {
                waitingCost += actorWages.at(actor) * (range.second - range.first + 1);
            }
        }
        sceneScores[scene] = sceneWeights[scene] + waitingCost;
    }

    vector<int> sortedScenes = scenes;
    sort(sortedScenes.begin(), sortedScenes.end(),
        [&sceneScores](int a, int b) {
            return sceneScores[a] > sceneScores[b];
        });

    return sortedScenes;
}

vector<int> findNearlyOptimalSceneOrderV4(const vector<int>& scenes,
    const unordered_map<int, vector<int>>& actorScenes,
    const unordered_map<int, int>& actorWages) {
    unordered_map<int, double> sceneWeights;

    unordered_map<int, double> sceneScores;
    for (int scene : scenes) {
        double waitingCost = 0;
        for (const auto& pair2 : actorScenes) {
            int actor = pair2.first;
            const vector<int>& range = pair2.second;
            sceneScores[scene] += actorWages.at(actor) * pow(range.size(), 0.5);
        }
    }

    vector<int> sortedScenes = scenes;
    sort(sortedScenes.begin(), sortedScenes.end(),
        [&sceneScores](int a, int b) {
            return sceneScores[a] > sceneScores[b];
        });

    return sortedScenes;
}

int main() {
    ifstream inFile("star.in");
    int n, m;
    inFile >> n >> m;

    vector<int> scenes(m);
    for (int i = 0; i < m; ++i) {
        scenes[i] = i + 1;
    }

    unordered_map<int, int> actorWages;
    for (int i = 1; i <= n; ++i) {
        int wage;
        inFile >> wage;
        actorWages[i] = wage;
    }

    unordered_map<int, vector<int>> actorScenes;
    for (int scene = 0; scene < m; ++scene) {
        int actorCount;
        inFile >> actorCount;
        for (int i = 0; i < actorCount; ++i) {
            int actor;
            inFile >> actor;
            actorScenes[actor].push_back(scene + 1);
        }
    }
    inFile.close();

    int64_t minCost = numeric_limits<int64_t>::max();
    vector<int> bestSceneOrder;

    vector<int> sceneOrder2 = findNearlyOptimalSceneOrderV2(scenes, actorScenes, actorWages);
    int64_t cost2 = calculateTotalCost(sceneOrder2, actorScenes, actorWages);

    vector<int> sceneOrder3 = findNearlyOptimalSceneOrderV3(scenes, actorScenes, actorWages);
    int64_t cost3 = calculateTotalCost(sceneOrder3, actorScenes, actorWages);

    vector<int> sceneOrder4 = findNearlyOptimalSceneOrderV4(scenes, actorScenes, actorWages);
    int64_t cost4 = calculateTotalCost(sceneOrder3, actorScenes, actorWages);

    minCost = min({ cost2, cost3, cost4 });

    if (minCost == cost2) {
        bestSceneOrder = sceneOrder2;
    }
    else if (minCost == cost3) {
        bestSceneOrder = sceneOrder3;
    }
    else {
        bestSceneOrder = sceneOrder4;
    }

    ofstream outFile("star.out");
    for (size_t i = 0; i < bestSceneOrder.size(); ++i) {
        if (i > 0) outFile << " ";
        outFile << bestSceneOrder[i];
    }
    outFile.close();

    return 0;
}