HDU 4068 模拟

/****************************************************************************************************
    有点麻烦。。。
****************************************************************************************************/
#include <iostream>
#include <functional>
#include <algorithm>
#include <complex>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <sstream>
#include <utility>
#include <bitset>
#include <cctype>
#include <cstdio>
#include <limits>
#include <memory>
#include <string>
#include <vector>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <list>
#include <map>
#include <set>
using namespace std;

#define LOWBIT(x) ( (x) & ( (x) ^ ( (x) - 1 ) ) )
#define CLR(x, k) memset((x), (k), sizeof(x))
#define CPY(t, s) memcpy((t), (s), sizeof(s))
#define SC(t, s) static_cast<t>(s)
#define LEN(s) static_cast<int>( strlen((s)) )
#define SZ(s) static_cast<int>( (s).size() )

typedef double LF;
//typedef long long LL;		//GNU C++
//typedef unsigned long long ULL;
typedef __int64 LL;		//Visual C++ 2010
typedef unsigned __int64 ULL;

typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<double, double> PDD;

typedef map<int, int>::iterator MI;
typedef vector<int>::iterator VI;
typedef list<int>::iterator LI;
typedef set<int>::iterator SI;

template <typename T>
T sqa(const T &x)
{
	return x * x;
}
template <typename T>
T gcd(T a, T b)
{
	if (!a || !b)
	{
		return max(a, b);
	}
	T t;
	while (t = a % b)
	{
		a = b;
		b = t;
	}
	return b;
}
template <typename T>
T ext_gcd(T a, T b, T &x, T &y)
{
	if (!b)
	{
		x = 1;
		y = 0;
		return a;
	}
	T d = ext_gcd(b, a % b, x, y);
	T t = x;					
	x = y;
	y = t - a / b * y;
	return d;
}
template <typename T>
T invmod(T a, T p)
{
	LL inv, y;
	ext_gcd(a, p, inv, y);
	inv < 0 ? inv += p : 0; 
	return inv;
}

const int INF_INT = 0x3f3f3f3f;
const LL INF_LL = 0x7fffffffffffffffLL;		//15f
const double oo = 10e9;
const double eps = 10e-9;
const double PI = acos(-1.0);

const int MAXN = 8;

int test, n, cap, arr[MAXN];
vector<string>V[MAXN];
string name[MAXN];

int fac(int x)
{
	int res = 1;
	for (int i = 1; i <= x; ++i)
	{
		res *= i;
	}
	return res;
}
bool can(int *arr, int *tmp, int n)
{
	int i = 0, j = 0;
	while (i < n && j < n)
	{
		vector<string>::iterator it = V[ tmp[j] ].begin();
		while (it != V[ tmp[j] ].end())
		{
			if (*it == name[ arr[i] ])
			{
				++i;
				break ;
			}
			++it;
		}
		if (it == V[ tmp[j] ].end())
		{
			++j;
		}
	}
	return i != n;
}
void reset(int *tmp, int n)
{
	for (int i = 0; i < n; ++i)
	{
		tmp[i] = i;
	}
	return ;
}
bool judge(int *arr, int n)
{
	int tmp[MAXN];
	reset(tmp, n);
	bool sign = true;
	if (!can(arr, tmp, n))
	{
		sign = false;
	}
	for (int j = 1; j < cap && sign; ++j)
	{
		next_permutation(tmp, tmp + n);
		if (!can(arr, tmp, n))
		{
			sign = false;
		}
	}
	if (sign)
	{
		return true;
	}
	for (int i = 1; i < cap; ++i)
	{
		next_permutation(arr, arr + n);
		reset(tmp, n);
		if (!can(arr, tmp, n))
		{
			continue ;
		}
		int j;
		for (j = 1; j < cap; ++j)
		{
			next_permutation(tmp, tmp + n);
			if (!can(arr, tmp, n))
			{
				break ;
			}
		}
		if (j == cap)
		{
			return true;
		}
	}
	return false;
}
void ace()
{
	int cas = 1;
	int m;
	string ss;
	bool sign;
	for (cin >> test; test--; ++cas)
	{
		cin >> n;
		for (int i = 0; i < n; ++i)
		{
			cin >> name[i];
		}
		cap = fac(n);
		sort(name, name + n);
		for (int i = 0; i < n; ++i)
		{
			arr[i] = i;
		}
		for (int i = 0; i < n; ++i)
		{
			V[i].clear();
			cin >> m;
			while (m--)
			{
				cin >> ss;
				V[i].push_back(ss);
			}
		}
		sign = judge(arr, n);
		cout << "Case " << cas << ": " << (sign ? "Yes" : "No") << endl;
		if (sign)
		{
			cout << name[ arr[0] ];
			for (int i = 1; i < n; ++i)
			{
				cout << " " << name[ arr[i] ];
			}
			cout << endl;
		}
	}
	return ;
}
int main()
{
	ace();
	return 0;
}