F . Overlapping Squares

Description

In most puzzles we are given some pieces and we have to make a target pattern which can be built in only one possible way. But some puzzles are a bit different, we are given a target pattern and from that target pattern we have to find in how many ways the pieces can be placed. Such a puzzle is the puzzle of overlapping squares. To understand this puzzle, look at the pictures below:

In first figure we have placed a (2 ×2) filled square in a (4×4) grid. In the second figure we have placed another (2 × 2) filled square in the grid, which have of course deleted some part of the black lines of the previous square, in third picture we have placed a third square and in the fourth picture we have placed a fourth square. The picture can become even more complex if we place more (2 × 2) squares.

Write a program to determine if it’s possible to form a target image using between 1 and 6 pieces (inclusive) of 2 × 2 squares.

Input

The input consists of several test cases. Each test case is contained in five lines and each line contains nine characters. If the horizontal border of a filled square is visible it is denoted with ‘_’ (ASCII value 95) sign and if vertical border of a filled square is visible then it is denoted with ‘|’ (ASCII value 124) character. The board contains no other character than ‘_’, ‘|’ and of course ‘ ’ (ASCII Value 32). The border lines of the squares can only be along the grid lines. Each board lines end with a ‘#’ (Hash character) which denotes the end of line. This character is not a part of the grid or square. The last test case is followed by a single zero, which should not be processed.

Output

For each test case, print the case number and ‘Yes’ or ‘No’, depending on whether it’s possible to form the target.

Samples

Input 复制

#
_ _ _ #
| |_ _| #
|_| | #
|_ _| #
        #
 _ _  #
|    | #
|_ _| #
            #
_ _ _ _ #
|_|_|_|_|#
|_|_|_|_|#
|_|_|_|_|#
|_|_|_|_|#
   _ _    #
_|     |_ #
| |_ _| |#
|_| |_|#
|_ _|_|#
0

Output

Case 1: Yes
Case 2: Yes
Case 3: No
Case 4: Yes

（详细图片请见原题）

题目大意：

在大多数拼图中，我们都会得到一些拼图，我们必须制作一个只能用一种可能的方式构建的目标模式。但是有些谜题有点不同，我们被赋予了一个目标模式，从这个目标模式中我们必须找到可以以多少方式放置这些碎片。这种拼图就是重叠正方形拼图。要理解这个难题，请看下面的图片：

在第一个图中，我们在（4×4）网格中放置了一个（2×2）填充正方形。在第二幅图中，我们在网格中放置了另一个（2×2）填充正方形，当然删除了前一个正方形的部分黑线，在第三幅图中，我们放置了第三个正方形，在第四幅图中，我们放置了第四个正方形。如果我们放置更多（2×2）个正方形，图片会变得更加复杂。
编写一个程序来确定是否可以使用1到6个2×2（含）的图像块来形成目标图像

输入：

输入由几个测试用例组成。每个测试用例包含在五行中，每行包含九个字符。如果填充正方形的水平边框可见，则用“|”（ASCII值95）符号表示，如果填充正方形的垂直边框可见，则用“|”（ASCII值124）字符表示。电路板除了“|”、“|”当然还有“”（ASCII值32）之外，没有其他字符。正方形的边界线只能沿着网格线。每个电路板行以一个“#”（散列字符）结束，表示行的结束。此字符不是网格或正方形的一部分。最后一个测试用例后面是一个0，不应该处理它。

输出：

对于每个测试用例，打印用例号和“是”或“否”，这取决于是否可能形成目标。

代码：

#include<bits/stdc++.h>
#define LL long long
using namespace std;
int pic[5][10];  //定义原始图形 
int p[5][10];   //之后的图形

/*
0表示 " "
1表示 "_"
2表示 "|"

一个正方形的填充区域
01010
20002
21012
*/

bool vis[10];
bool read() {
	memset(pic, 0, sizeof(pic));
	memset(p, 0, sizeof(p));
	memset(vis, 0, sizeof(vis));
	//五行 7列
	for (int i = 0; i < 5; i++) {
		for (int j = 0; j < 10; j++) {
			char ch;
			ch = cin.get();
			if (ch == '0') return false;
			if (isspace(ch)) {
				pic[i][j] = 0;
			}
			else if (ch == '_') {
				pic[i][j] = 1;
			}
			else if (ch == '|') {
				pic[i][j] = 2;
			}
			else {
				cin.get(); //读掉换行
				break;
			}
		}
	}
	// for(int i = 0; i < 5; i++) {
	//     for(int j = 0; j < 10; j++) {
	//         cout << pic[i][j];
	//     }
	//     cout << endl;
	// }
	return true;
}

//定义偏移量
int offx[] = { 0, 1, 2 };
int offy[] = { 0, 1, 2 };

string s[3] = { "01010", "20002", "21012" };

//放置 0 - 8 个图形
//返回原来的情况
vector<string> put(int num1) {
	int ox = num1 / 3;
	int oy = num1 % 3;
	vector<string> ss;
	ss.resize(5);
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 5; j++) {
			ss[i].push_back(p[i + ox][j + oy * 2]);
			if (i == 0 && s[i][j] == '0') continue;
			p[i + ox][j + oy * 2] = s[i][j] - '0';
		}
	}
	return ss;
}

//回溯用
void reset(int num1, vector<string> ss) {
	int ox = num1 / 3;
	int oy = num1 % 3;
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 5; j++) {
			if (i == 0 && s[i][j] == '0') continue;
			p[i + ox][j + oy * 2] = ss[i][j];
		}
	}
}

bool check() {
	for (int i = 0; i < 5; i++) {
		for (int j = 0; j < 10; j++) {
			if (pic[i][j] != p[i][j]) return false;
		}
	}
	return true;
}

//搜索与回溯

bool dfs(int d, int maxd) {
	//cout << "d: " << d << endl;
	//for(int i = 0; i < 5; i++) {
	//	for(int j = 0; j < 10; j++) {
	//		//cout << p[i][j];
	//		if (p[i][j] == 0) cout << " ";
	//		if (p[i][j] == 1) cout << "_";
	//		if (p[i][j] == 2) cout << "|";
	//	}
	//	cout << endl;
	//}
	//cout << endl;
	if (d == maxd) {
		if (check()) 
			return true;
		return false;
	}
	if (check()) return true;
	for (int i = 0; i < 9; i++) {
		if (vis[i]) continue;
		vis[i] = true;
		vector<string> ss = put(i);
		if (dfs(d + 1, maxd))
			return true;
		reset(i, ss);
		vis[i] = false;
	}
	return false;
}

int main() {
	// freopen("in.txt", "r", stdin);
	// freopen("out.txt", "w", stdout);
	ios::sync_with_stdio(false);
	cin.tie(0);
	int kase = 0;
	while (read()) {
		cout << "Case " << ++kase << ": ";
		if (check() || dfs(0, 6)) {
			cout << "Yes" << endl;
			continue;
		}
		cout << "No" << endl;
	}
	return 0;
}