Problem:
ジグソーパズル

子供から大人まで脳トレ系パズルゲームが流行しています。我々も遅れを取らぬよう、パズルゲームを作ってみんなで遊ぶことにしました。

我々が考えたのはジグソーパズルのゲームで、未完成の部分を埋めるのに必要なピースを選ぶというものです。図 1 (a) はパズルの枠の例です。黒が埋まっている部分、白が未完成の部分です。このパズルを完成するのに使えるピースが図 1 (b) のように与えられます。この中から、枠の白い部分を埋めることができる黒いピースを 1 つ以上選択します。例えば、図 2 の選択例 1 のような組み合わせなら正解となります。一方、選択例 2 のような組み合わせではパズルは完成しないので不正解となります。また、選択したピースが余ってしまう場合も不正解です。このように、プレイヤーは適切なピースを選択することでゲームをクリアします。

そこでこのパズルゲームで用いる判定プログラムを開発することになりました。未完成のパズル、ピースの候補、そしてプレイヤーが選んだピースの組み合わせを入力とし、プレイヤーが適切なピースを選ぶことができていれば YES を、そうでなければ NO と出力するプログラムを作成してください。

この問題では、パズルの枠は H × W の配列で表し、未完成の部分を . (半角ピリオド)、完成している部分を # (半角シャープ)によって与えます。パズルの枠の大きさは最大 20 × 20 とします。また、各ピースは h × w の配列で表し、ピースを構成する部分を # 、そうでない部分を . によって与えます。与えられる各ピースは、元の状態から 90 度、180 度、270 度だけ回転することができます。また、各ピースの大きさは最大 20 × 20 とし、与えられるピースの数 n は最大 10 とします。

Input

複数のデータセットが与えられます。各データセットは以下の形式で与えられます。

H W
g1,1g1,2...g1,W
g2,1g2,2...g2,W
:
gH,1gH,2...gH,W
n
h1 w1
c11,1c11,2...c11,w1
c12,1c12,2...c12,w1
:
c1h1,1c1h1,2...c1h1,w1
:
:
hn wn
cn1,1cn1,2...cn1,wn
cn2,1cn2,2...cn2,wn
:
cnhn,1cnhn,2...cnhn,wn
p
k1 t1 t2 ... tk1
k2 t1 t2 ... tk2
:
kp t1 t2 ... tkp

1 行目に、パズルの枠の大きさ H(縦) と W(横) が与えられます。
2 行目に、文字 gi,j (. または #) からなりパズルの盤面を表す 1 行 W 文字の文字列が H 行与えられます。

続いてピースの数 n、n 個のピースの情報が与えられます。各ピースの情報として、l 番目のピースの配列のサイズ hl (縦) と wl (横)、l 番目のピースの配列が与えられます。l 番目のピースの配列として文字 cli,j (. または #) からなる 1 行 wl 文字の文字列が hl 行与えられます。

続いてプレイヤーの人数 p、i 番目のプレイヤーの選択したピースの数 ki と選択したピースの番号 tj が与えられます。

入力は２つの 0 を含む行で終了します。データセットの数は 10 を超えません。

Output

各データセットごとに、i 番目のプレイヤーが選択したピースの正否 YES または NO を i 行目に出力してください。

Sample Input

14 20
####################
###.............####
####..........######
#######.....########
########.....#######
###..###......######
###..####......#####
#########......#####
###########.....####
############.....###
###.########......##
###.#######...###.##
##...###....#####.##
####################
10
12 15
#############..
.##########....
....#####......
.....#####.....
.....######....
......######...
......######...
........#####..
.........#####.
.........######
........###...#
.....####.....#
3 3
#..
###
#..
2 2
##
##
4 10
....#####.
....######
...###...#
####.....#
6 5
....#
..###
#####
##.##
#..##
#..#.
6 4
...#
.###
####
##.#
##.#
#...
2 6
######
.#####
2 7
..#####
#######
2 13
#############
.##########..
6 9
#####....
.######..
.######..
..######.
...#####.
....#####
8
3 1 2 3
4 1 2 3 4
7 2 3 4 5 6 7 8
5 2 3 10 7 8
6 2 3 9 5 6 4
8 2 3 4 6 9 5 4 10
4 4 5 6 9
5 10 2 3 4 9
0 0

Output for the Sample Input

YES
NO
YES
NO
YES
NO
NO
YES

Solution in C (judge verdict: Time Limit Exceeded)

#include<stdio.h>
#include<stdlib.h>

typedef struct{
	int W,H;
	int bits[20];
} Pattern;

typedef struct{
	Pattern pat;
	int bit_count;
} Board;

typedef struct{
	Pattern pat;
	int fit_count;
	int fit[20][20];
} DirectedPiece;

typedef struct{
	DirectedPiece dir[4];
	int bit_count;
} Piece;

Board g_board;
Piece g_piece[10];
int g_debug_count;

void read_pattern(Pattern *piece, int *pbit_count){
	int y, bits, c, bit_count = 0;
	scanf("%d%d\n", &piece->H, &piece->W);
	for(y = 0; y < piece->H; y ++){
		bits = 0;
		for(; c=getchar(), c!='\n';){
			bits = bits*2 + (c=='#' ? 1 : 0);
		}
		piece->bits[y] = bits;
		for(; bits; bits&=bits-1)
			bit_count ++;
	}
	*pbit_count = bit_count;
}

void rotate_pattern(Pattern *dest, Pattern *src){
	int y, x, bits;
	dest->H = src->W;
	dest->W = src->H;
	for(y = 0; y < dest->H; y ++){
		bits = 0;
		for(x = 0; x < dest->W; x ++){
			bits = bits*2 + (src->bits[x] >> y & 1);
		}
		dest->bits[y] = bits;
	}
}

int check_fit_pattern(const Pattern *board, const Pattern *piece, int piece_x, int piece_y){
	int y, H = piece->H;
	//g_debug_count ++;
	for(y = 0; y < H; y ++)
		if(board->bits[piece_y + y] & (piece->bits[y] << piece_x))
			return 0;
	return 1;
}

void add_pattern(Pattern *board, const Pattern *board_org, const Pattern *piece, int piece_x, int piece_y){
	int y, H = piece->H;
	*board = *board_org;
	for(y = 0; y < H; y ++)
		board->bits[piece_y + y] |= piece->bits[y] << piece_x;
}

void prepare_fit_directed_piece(DirectedPiece *piece){
	int x, y, board_H, board_W, piece_H, piece_W, fit_count = 0;
	board_H = g_board.pat.H;
	board_W = g_board.pat.W;
	piece_H = piece->pat.H;
	piece_W = piece->pat.W;
	for(y = 0; y+piece_H <= board_H; y ++)
		for(x = 0; x+piece_W <= board_W; x ++)
			fit_count += piece->fit[x][y] = check_fit_pattern(&g_board.pat, &piece->pat, x, y);
	piece->fit_count = fit_count;
}

int check_puzzle(const Pattern *board_org, int piece_num, int *piece_index){
	int dir, x, y, board_H, board_W, piece_H, piece_W;
	Pattern board;
	DirectedPiece *piece;

	if(piece_num == 0)
		return 1;
	board_H = board_org->H;
	board_W = board_org->W;
	for(dir = 0; dir < 4; dir ++){
		piece = &g_piece[*piece_index].dir[dir];
		piece_H = piece->pat.H;
		piece_W = piece->pat.W;
		for(y = 0; y+piece_H <= board_H; y ++){
			for(x = 0; x+piece_W <= board_W; x ++){
				if(piece->fit[x][y] && check_fit_pattern(board_org, &piece->pat, x, y)){
					add_pattern(&board, board_org, &piece->pat, x, y);
					if(check_puzzle(&board, piece_num - 1, piece_index + 1))
						return 1;
				}
			}
		}
	}
	return 0;
}

int cmp_fit_count(const int *piece_index1, const int *piece_index2){
	int i, fit_count1 = 0, fit_count2 = 0;
	for(i = 0; i < 4; i ++){
		fit_count1 += g_piece[*piece_index1].dir[i].fit_count;
		fit_count2 += g_piece[*piece_index2].dir[i].fit_count;
	}
	return fit_count1 - fit_count2;
}

int cmp_bit_count(const int *piece_index1, const int *piece_index2){
	return g_piece[*piece_index2].bit_count - g_piece[*piece_index1].bit_count;
}

int main(){
	int i, dir, player_num, piece_num, piece_index[10], bit_count;
	for(;read_pattern(&g_board.pat, &bit_count), g_board.pat.H;){
		g_board.bit_count = bit_count;
		scanf("%d", &piece_num);
		for(i = 0; i < piece_num; i ++){
			read_pattern(&g_piece[i].dir[0].pat, &bit_count);
			g_piece[i].bit_count = bit_count;
			prepare_fit_directed_piece(&g_piece[i].dir[0]);
			for(dir = 1; dir < 4; dir ++){
				rotate_pattern(&g_piece[i].dir[dir].pat, &g_piece[i].dir[dir-1].pat);
				prepare_fit_directed_piece(&g_piece[i].dir[dir]);
			}
		}
		scanf("%d", &player_num);
		g_debug_count = 0;
		for(;player_num--;){
			scanf("%d", &piece_num);
			bit_count = g_board.pat.H * g_board.pat.W - g_board.bit_count;
			for(i = 0; i < piece_num; i ++){
				scanf("%d", piece_index + i);
				piece_index[i] --; // 0 origin
				bit_count -= g_piece[piece_index[i]].bit_count;
			}
			qsort(piece_index, piece_num, sizeof(*piece_index), cmp_bit_count);
			puts(bit_count == 0 && check_puzzle(&g_board.pat, piece_num, piece_index) ? "YES" : "NO");
		}
		//printf("DBG:%d\n", g_debug_count);
	}
	return 0;
}