#include <fstream>
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <algorithm>
#include <time.h>

using namespace std;

struct Row {
	int row;
	int br;
	double secondHighestCost;
	double highestCost;
	double totalCost;
	int* actors;
};

bool compareRowsByRow(const Row& r1, const Row& r2) {
	return r1.row > r2.row;
}

bool compareRowsByBr(const Row& r1, const Row& r2) {
	if (r1.br != r2.br) {
		return r1.br > r2.br;
	}
	return r1.row > r2.row;
}

bool compareRowsByHighestCost(const Row& r1, const Row& r2) {
	if (r1.highestCost != r2.highestCost) {
		return r1.highestCost > r2.highestCost;
	}
	return r1.row > r2.row;
}

bool compareRowsByTwoHighestCosts(const Row& r1, const Row& r2) {
	double c1 = r1.highestCost*2+r1.secondHighestCost;
	double c2 = r2.highestCost*2+r2.secondHighestCost;
	if (c1 != c2) {
		return c1 > c2;
	}
	return r1.row > r2.row;
}

bool compareRowsByTotalCost(const Row& r1, const Row& r2) {
	if (r1.totalCost != r2.totalCost) {
		return r1.totalCost > r2.totalCost;
	}
	return r1.row > r2.row;
}

bool contains(int* a, int br, int aa) {
	for (int i=0;i<br;++i) {
		if (a[i] == aa) return true;
	}
	return false;
}

double costFunctionV(int n, int m, double* c, std::vector<Row> rows) {
	double cost = 0;
	
	for (int i=0;i<n;++i) {
		int first=0;
		int last=m-1;
		while (true) {
			int* actors = rows[first].actors;
			int br = rows[first].br;
			if (contains(actors,br,i)) break;
			first++;
		}
		while (true) {
			int* actors = rows[last].actors;
			int br = rows[last].br;
			if (contains(actors,br,i)) break;
			last--;
		}
		
		cost += c[i] * (last - first + 1);
	}
	
	return cost;
}

int main() {
	clock_t t1 = clock();
	ifstream inp;
	inp.open("star.in");
	
	int n,m;
	inp>>n>>m;
	
	double* c = new double[n];
	
	for (int i = 0; i < n; ++i) {
		inp>>c[i];
	}
	
	std::vector<Row> rows(m);
	std::vector<Row> bestRows(m);
	for (int i = 0; i < m; ++i) {
		inp>>rows[i].br;
		rows[i].row = i + 1;
		rows[i].actors = new int[rows[i].br];
		rows[i].highestCost = 0;
		rows[i].totalCost = 0;
		for (int j = 0; j < rows[i].br; ++j) {
			int actor;
			inp>>actor;
			actor--;
			rows[i].actors[j] = actor;
			if (c[actor]>rows[i].highestCost) {
				rows[i].secondHighestCost = rows[i].highestCost;
				rows[i].highestCost = c[actor];
			}
			rows[i].totalCost += c[actor];
		}
	}
	inp.close();
	
		
	std::sort(rows.begin(), rows.end(), compareRowsByHighestCost);
	double cost = costFunctionV(n,m,c,rows);
	double bestCost = cost+1;
	if (cost<bestCost) {
		bestCost = cost;
		bestRows = rows;
	}
	
	std::sort(rows.begin(), rows.end(), compareRowsByBr);
	cost = costFunctionV(n,m,c,rows);
	if (cost<bestCost) {
		bestCost = cost;
		bestRows = rows;
	}
	
	std::sort(rows.begin(), rows.end(), compareRowsByTotalCost);
	cost = costFunctionV(n,m,c,rows);
	if (cost<bestCost) {
		bestCost = cost;
		bestRows = rows;
	}
	
	std::sort(rows.begin(), rows.end(), compareRowsByTwoHighestCosts);
	cost = costFunctionV(n,m,c,rows);
	if (cost<bestCost) {
		bestCost = cost;
		bestRows = rows;
	}

	rows = bestRows;

	srand(0);
	int r1 = rand() % (m-1);
	int r2 = rand() % (m-1);
	int r3 = rand() % (m-1);
	int r4 = rand() % (m-1);
	int t = 0;
	
	while(t<4500) {
		std::swap(rows[r1],rows[r1+1]);
		std::swap(rows[r2],rows[r2+1]);
		std::swap(rows[r3],rows[r3+1]);
		std::swap(rows[r4],rows[r4+1]);
		double cost = costFunctionV(n,m,c,rows);
		if (cost<bestCost) {
			bestCost = cost;
		} else {
			std::swap(rows[r4],rows[r4+1]);
			std::swap(rows[r3],rows[r3+1]);
			std::swap(rows[r2],rows[r2+1]);
			std::swap(rows[r1],rows[r1+1]);
		}
		r1 = rand() % (m-1);
		r2 = rand() % (m-1);
		r3 = rand() % (m-1);
		r4 = rand() % (m-1);
		t = (clock()-t1) * 1000 / CLOCKS_PER_SEC;
	}
	
	std::vector<Row> bestRowsPivot = bestRows = rows; // !!!
	
	while(t<4600 && std::next_permutation(rows.begin(), rows.end(), compareRowsByRow)) {
		double cost = costFunctionV(n,m,c,rows);
		if (cost<bestCost) {
			bestCost = cost;
			bestRows = rows;
		}
		t = (clock()-t1) * 1000 / CLOCKS_PER_SEC;
	}

	rows = bestRowsPivot;
	
	while(t<4700 && std::prev_permutation(rows.begin(), rows.end(), compareRowsByRow)) {
		double cost = costFunctionV(n,m,c,rows);
		if (cost<bestCost) {
			bestCost = cost;
			bestRows = rows;
		}
		t = (clock()-t1) * 1000 / CLOCKS_PER_SEC;
	}
	
	//cout<<bestCost<<endl;
	
	ofstream out;
	out.open("star.out");
	
	for (int i = 0; i < m; ++i) {
		out<<bestRows[i].row<<" ";
	}

	out.close();
	
	return 0;
}