#include<fstream>
#include<string.h>
#include<bitset>
#include<vector>
#include<algorithm>
using namespace std;
 
ifstream in("ratina.in");
ofstream out("ratina.out");
char s[10010][2010];
int t[15];
int len[10010];
 
struct Node
{
    Node *l[28];
	vector<int> vec[23];
};
 
vector<Node*> vec[2010][28];
 
class Trie
{
private:
    Node *t;
public:
    Trie();
    void add(int i, const char *c);
    int length_com_pref(int id, int g[], int size);
};
 
Trie::Trie()
{
    t = new Node;
    memset(t, 0, sizeof(Node));
}
 
void Trie::add(int id, const char *c)
{
    Node *q = t;
    int i = 0;
    while (c[i] != '\0')
    {
        if (!q->l[c[i] - 'a'])
        {
            q->l[c[i] - 'a'] = new Node;
            memset(q->l[c[i] - 'a'], 0, sizeof(Node));
            vec[i][c[i] - 'a'].push_back(q->l[c[i] - 'a']);
        }
        q = q->l[c[i] - 'a'];
        q->vec[id%23].push_back(id);
        ++i;
    }
    len[id] = i;
}
 
int Trie::length_com_pref(int id, int g[], int size)
{
    Node *q = t;
    int l = 0, r = len[id] - 1;
    int mx = -1;
    while (l <= r)
    {
        int mid = (l + r)>>1;
        int ok = 0;
        for (int i = 0;i < vec[mid][s[id][mid] - 'a'].size();++i)
        {
            int j;
			for (j = 1;j <= size;++j)
			{
				int k;
				for (k = 0; k < vec[mid][s[id][mid] - 'a'][i]->vec[g[j] % 23].size();++k)
					if(vec[mid][s[id][mid] - 'a'][i]->vec[g[j] % 23][k]==g[j])
						break;
				if (k == vec[mid][s[id][mid] - 'a'][i]->vec[g[j] % 23].size())
					break;
			}
            if (j == size + 1)
            {
                ok = 1;
                break;
            }
        }
 
        if (ok)
            mx = mid, l = mid + 1;
        else
            r = mid - 1;
 
    }
 
 
    return mx + 1;
}
 
 
int main()
{
    int op;
    Trie trie;
    int N, K;
    in >> N >> K;
    for (int i = 1;i <= N;++i)
    {
        in >> s[i];
        trie.add(i, s[i]);
    }
 
    for (int i = 1;i <= K;++i)
    {
        int e, f;
        in >> e;
        for (int j = 1;j <= e;++j)
            in >> t[j];
 
        out << trie.length_com_pref(t[1], t, e) << '\n';
    }
 
    return 0;
}