POJ 1753 *** Flip Game-CSDN博客

本文介绍了一种使用BFS算法解决4x4方格翻色问题的方法，通过状态压缩将所有可能的状态表示为整数，并利用队列进行广度优先搜索以找出最少翻转次数。

题意：有一个4*4的方格组成的图形，每个1*1的小块是黑色或者白色。对第m行、n列的小块变换颜色时，总会导致其上下左右的方块改变颜色。求对于一个给定的颜色组合，求最少要翻多少次才能是颜色全为白色或者全为黑色。

想法：用BFS。首先将黑色或者白色的状态用0、1表示，对于4*4的方块，一共有2^16=65536种状态。于是棋盘的状态可以用这样一个状态来表示。对于某一个特定的状态，分别遍历完所有方格，标记已经经历的状态且记录到达该状态的最小步数直到找到想要的结果或者没有结果。用队列来存储中间状态。

代码如下:

#pragma warning(disable:4996)
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
const int maxn = 65536;

int que[maxn * 2];
int is[maxn];
int step[maxn];
int front, rear;

int main() {
	int id = 0,temp;
	char color;
	for (int i = 0; i < 16; ++i) {
		cin >> color;
		id <<= 1;
		if (color == 'b')id += 1;
	}
	if (id == 0 || id == 65535) { cout << 0 << endl; return 0; }
	step[id] = 0; is[id] = 1;
	que[rear++] = id;
	while (front < rear) {
		int temp = que[front++];
		id = temp;
		for (int i = 0; i < 4; ++i)
			for (int j = 0; j < 4; ++j) {
				temp = id;
				if (i == 0)temp ^= 1 << (11 - 4 * i - j);
				else if (i == 3)temp ^= 1 << (19 - 4 * i - j);
				else {
					temp ^= 1 << (11 - 4 * i - j);
					temp ^= 1 << (19 - 4 * i - j);
				}
				if (j == 0)temp ^= 3 << (14 - 4 * i - j);
				else if (j == 3)temp ^= 3 << (15 - 4 * i - j);
				else temp ^= 7 << (14 - 4 * i - j);
				if (temp == 0 || temp == 65535) { cout << step[id] + 1 << endl; return 0; }
				if (!is[temp]) {
					is[temp] = 1;
					que[rear++] = temp;
					step[temp] = step[id] + 1;
				}
			}
	}
	cout << "Impossible" << endl;
	return 0;
}

一开始我自己想的是，因为65536种不同的翻转方法，于是我就用0到65536这么多种方法去对初始状态进行变换，然后如果某一个状态能够翻转得到结果，那么记录此时的step状态，下一次循环的时候将方法中需要翻转的次数与step对比，如果比step小那么进行操作，否则跳过。

代码如下:

#pragma warning(disable:4996)
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;

int f[6][6];
bool is(int(*m)[6]) {
	bool flag = 1;
	for (int i = 1; i < 5; ++i)
		if(flag)
			for (int j = 1; j < 5; ++j)
				if (!m[i][j]) { flag = 0; break; }
	if (flag)return flag;
	flag = 1;
	for (int i = 1; i < 5; ++i)
		if (flag)
			for (int j = 1; j < 5;++j)
				if (m[i][j]) { flag = 0; break; }
	if (flag)return flag;
	return 0;
}

int size(int n) {
	int i = 0;
	while (n) {
		if (n % 2)++i;
		n = n / 2;
	}
	return i;
}
void flip(int (*m)[6], int i, int j) {
	m[i][j] ^= 1;
	m[i - 1][j] ^= 1;
	m[i + 1][j] ^= 1;
	m[i][j - 1] ^= 1;
	m[i][j + 1] ^= 1;
}

int main(void) {
		int temp[6][6];
		for (int i = 0; i < 6; ++i) {
			f[0][i] = 1;
			f[5][i] = 1;
			f[i][0] = 1;
			f[i][5] = 1;
		}
		int n, min = 20;
		int tt, flag;
		char c;
		for (int i = 1; i < 5; ++i)
			for (int j = 1; j < 5; ++j) {
				cin >> c;
				if (c == 'b')f[i][j] = 0; else f[i][j] = 1;
			}
		for (n = 0; n < 65536; ++n) {
			memcpy(temp, f, sizeof(f));
			if (size(n) < min) {
				tt = n;
				flag = tt % 2;
				for (int i = 1; i < 5; ++i)
					for (int j = 1; j < 5; ++j) {
						if (flag)
							flip(temp, i, j);
						tt = tt / 2;
						flag = tt % 2;
					}
				if (is(temp))min = size(n);
			}
		}
		if (min != 20)
			cout << min << endl;
		else cout << "Impossible" << endl;
	return 0;
}