POJ 2965 *** The Pilots Brothers' refrigerator

题意：4*4的方块，每块上面分别为‘-’或者‘+。对第m行、n列的小块变换状态时，总会导致第m行方块与第n列的所有方块改变状态，我称这样的操作为“翻转操作”，称改变某个特定坐标的状态为“变换”。求对于一个给定的图形组合，求最少进行多少次翻转操作才能是颜色全为‘-’，且输出每一步翻转的坐标。

想法：首先这道题是肯定有解的，因为如果想要只改变(m,n)的状态，那么只要需要在对(m,n)进行一次翻转操作之后对所有m行其他元素与n列其他元素分别进行一次翻转操作，那么就可以做到只改变(m,n)的状态。（这里又是因为对于不在m行与n列的元素而言，这样的翻转操作是变换了两次，相当于没有发生变化，而对于第m行或者n列的其他元素而言，这样翻转操作是变换了4次，于是也没有发生变化，而对于(m,n)这个元素是变换了7次，于是就只改变了它的状态）。

一开始我想的还是BFS，或者DFS，但是我一直没想明白怎么去存储每一步的坐标，后来我想到了链表这么一个数据结构，可以仍然用队列，但是再开两个数组，记录每一个状态前面的一个状态，另一个数组存储改变的(x,y)，将数据变成x*10+y的形式。

代码如下：

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

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

void ccout(int n) {
	int stack[18];
	stack[0] = n;
	int j=1;
	while (pre[n] != -1) {
		stack[j] = pre[n];
		n = pre[n];
		j++;
	}
	int x, y;
	for (j -= 2; j >= 0; --j) {
		x = prex[stack[j]] / 10;
		y = prex[stack[j]] % 10;
		cout << x << " " << y << endl;
	}
}

int main() {
	while (1) {
		memset(pre, 0, sizeof(pre));
		memset(prex, 0, sizeof(prex));
		memset(is, 0, sizeof(is));
		memset(step, 0, sizeof(step));
		int id = 0; char c;
		rear = front = 0;
		for (int i = 0; i < 16; ++i) {
			cin >> c;
			id <<= 1;
			if (c == '-')id += 1;}
		if (id == 65535) {
			cout << 0 << endl; 
			return 0; }
		is[id] = 1;
		pre[id] = -1;
		que[rear++] = id;
		int temp;
		while (front != rear) {
			temp = que[front++];
			id = temp;
			for (int i = 1; i <= 4; ++i) {
				for (int j = 1; j <= 4; ++j) {
					temp = id;
					temp ^= 15 << (16 - 4 * i);
					temp ^= 1 << (4 - j);
					temp ^= 1 << (8 - j);
					temp ^= 1 << (12 - j);
					temp ^= 1 << (16 - j);
					temp ^= 1 << (20 - 4 * i - j);
					if (temp == 65535) {
						pre[temp] = id;
						prex[temp] = i * 10 + j;
						cout << step[id] + 1 << endl;
						ccout(temp);
						is[temp] = 1;
						return 0;
					}
					if (!is[temp]) {
						is[temp] = 1;
						que[rear++] = temp;
						pre[temp] = id;
						prex[temp] = i * 10 + j;
						step[temp] = step[id] + 1;
					}
				}
			}
		}
	}
	return 0;
}

后来在discuss区看见一个比较简单粗暴的方法，方法很简单，先开一个4*4的数组，全部置为0，然后接受初始状态，对(m,n)处是‘+’的状态，都对数组的(m,n)进行一次翻转操作。最后统计数组中1的个数，然后按顺序打印出为1的坐标就ok了。

这个做法和我在最上面解释这个题肯定有解的思路有关，该做法记录的是需要进行一次翻转操作的(m,n)。先建立一个原始数组，全置成0，表示还未有操作。因为对‘+’状态的坐标(m,n)而言肯定是需要变换的，而能改变(m,n)的状态只能是对第m行元素或者第n列元素进行翻转操作，且如果单独对m行某个元素或者n列某个元素进行反转操作同时也会改变其他元素的状态，于是需要对m行、n列上所有元素都进行翻转操作才能保证(m,n)得到了变换，这种操作反应在原始数组上就是对(m,n)进行一次翻转操作（记录的是对初始状态数组的操作状态）。

代码如下：

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

int pre[maxn];
int res[5][5];

void set(int i,int j) {
	for (int k = 1; k < 5; ++k) {
		if(res[k][j]%2)
		res[k][j]=0;
		else res[k][j] = 1;
		if (res[i][k] % 2)
			res[i][k] = 0;
		else res[i][k] = 1;
	}
	if (res[i][j] % 2)
		res[i][j] = 0;
	else res[i][j] = 1;
}

int main() {
	
		char c;
		memset(res, 0, sizeof(res));
		for (int i = 1; i < 5; ++i)
			for (int j = 1; j < 5; ++j) {
				cin >> c;
				if (c == '+')
					set(i, j);
			}
		int num = 0;
		for (int i = 1; i < 5; ++i)
			for (int j = 1; j < 5; ++j)
				if (res[i][j])num++;
		cout << num << endl;
		for (int i = 1; i < 5; ++i)
			for (int j = 1; j < 5; ++j)
				if (res[i][j])cout << i << " " << j << endl;
	
	return 0;
}