#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <math.h>
using namespace std;
//typedef __int64 int64_t;
static int64_t totalCt = 0;
static int64_t goal = 0;


struct food
{
    int64_t num;
    int64_t currentSum;
    vector<int64_t> stack;
    //현재 음식의 중첩 횟수
    int ct;
public:
    food()
    {
        ct = 0;
        num = 0;
        currentSum = 0;
    }
    //새로 음식값을 받아 쌓는다.
    void calculate(int64_t val)
    {
        //다 쌓여서 쌓을필요가 없다.
        if (currentSum == goal)
        {
            return;
        }
        //아직 한번도 쌓인 음식이 아닐경우,
        if (currentSum == 0)
        {
            //이 음식과 주어진 음식에 다른 비트가 존재할 경우,
            //예를들면 내음식이 0001이고 주어진 음식이 0011이라면 0010 만큼이 새로운 타켓이므로 "쌓는다"
            int64_t tem = (val - (val&num));
            if ((tem) > 0)
            {
                //쌓여진 지금 음식의 최종값
                currentSum = tem + num;
                //쌓인 음식을 스택에 넣어준다.
                stack.push_back(tem);
                //쌓인 횟수.
                ct++;
            }
            reCalculateCurrentSum();

        }
        else
        {
            bool add = false;
            //스택에 돌아가면서 쌓여진 음식중 지금 새로 들어온 음식으로 대체할수 있는지 찾는다.
            //예를들어 1010이 쌓여져 있다면 11010으로 대체할수 있다.
            for (int i = 0; i < stack.size(); i++)
            {
                //새로운 음식이 기존 음식을 포함할경우,
                if ((val&stack[i]) == stack[i])
                {
                    //스택에서 버리고
                    stack[i] = -1;
                    //카운트를 깍는다.
                    ct--;

                    add = true;
                }
            }
            reCalculateCurrentSum();
            //이미 대체했으므로 무조건 쌓아야 한다.
            if (add)
            {
                int64_t tem = (val - (val&currentSum));
                stack.push_back(tem);
                ct++;
                reCalculateCurrentSum();
            }
            //음식을 대체한 경우가 아니면, 이 음식이 새로운 비트를 가지고 있는지 확인
            else
            {
                //여태 쌓여진거 말고 새로운 비트가 있을경우 쌓는다.
                int64_t tem = (val - (val&currentSum));
                if (tem > 0)
                {

                    stack.push_back(tem);
                    ct++;
                    reCalculateCurrentSum();
                }
            }


        }
        //음식이 다 쌓여서 쌓을 필요가 없다.
        if (currentSum == goal)
        {
            if (this->ct < totalCt)
            {
                totalCt = ct;
            }
        }
    }
    void reCalculateCurrentSum()
    {
        currentSum = this->num;
        for (int i = 0; i < stack.size(); i++)
        {
            if (stack[i] == -1)
            {
                continue;
            }
            int64_t tem = (stack[i]);
            currentSum += tem;
        }
    }
};
int main(int arg, char* args[])
{
    string nums;

    getline(cin, nums);
    int num = stoi(nums);
    vector<int> answer;
    //몇번 진행할것인지.
    for (int ab = 0; ab < num; ab++)
    {
        //음식숫자
        int foodNum;
        //친구숫자
        int friendNum;
        //최종 목표가 될 숫자. 초기화
        goal = 0;
        //현재 최소 카운트. 일단 일정한 큰 수
        totalCt = 100000;
        cin >> friendNum;
        cin >> foodNum;
        std::map<string, int64_t> friendMap;

        for (int i = 0; i < friendNum; i++)
        {
            string name;
            cin >> name;
            //각 아이들을 받아올때마다 아이들에게 비트 자리수 하나식을 준다.
            friendMap[name] = pow(2, i);
            //최종 목표가 될 숫자에 아이들 마다 받은 비트를 더한다. 즉 4명이면 1111(2)가 된다.
            goal += friendMap[name];;
        }
        //음식 받아오기
        vector<food*> foods;
        for (int i = 0; i < foodNum; i++)
        {
            int fNum = 0;
            cin >> fNum;

            int64_t foodValue = 0;
            //음식을 먹을 애들.
            for (int j = 0; j < fNum; j++)
            {
                string fname;
                cin >> fname;
                //먹을 애들 하나마다 이 음식에 값을 세팅한다. 예를들어 1번아이와 3번 아이가 먹는다면 이 음식값음 0101(2)이다.
                foodValue += friendMap[fname];
            }

            //지금까지 존재한 음식에 방금 받은 음식을 "쌓는다" 이 과정에서 필요 없는 음식은 쌓이지 않고 버려진다.
            for (int tf = 0; tf < foods.size(); tf++)
            {
                foods[tf]->calculate(foodValue);
            }
            //새로운 음식을 만들어 음식 어레이에 넣는다.
            food *f = new food();
            f->num = foodValue;
            f->ct = 1;
            f->reCalculateCurrentSum();

            foods.push_back(f);
        }

        int lessCt = 10000;
        for (int tf = 0; tf < foods.size(); tf++)
        {

            food *f = foods[tf];

            //int64_t sum = f->currentSum;
            ////음식들중 합이 목표치인 경우,
            //if (sum == goal)
            //{
            //  //최소의 쌓아진 합으로 도달한것을 찾아서
            //  if (lessCt > f->ct)
            //  {
            //      //최소에다가 넣는다.
            //      lessCt = f->ct;
            //  }
            //}
            delete f;
        }
        //정답을 가지고 있는다.
        answer.push_back(totalCt);
    }
    ///출력
    for (int i = 0; i < answer.size(); i++)
    {
        cout << answer[i] << endl;
    }
}