poj2965

//解法一：
//自己写的暴力dfs（超时），在看了某个博主的解释后加了个判断，AC了。
//if (ma <= t) return;开关变化的次数是唯一的。
#include <iostream>
using namespace std;
#define  N 500
char a[N][N];
int sum = 0;
struct dd {
	int x, y;
}d[N],ff[N];
int ma = 0x3f3f3f3f;
void dfs(int x, int y, int t)
{
	int i, l;
	int s = 0;
	if (ma <= t) return;
	for (i = 0; i < 4; i++)
	{
		for (l = 0; l < 4; l++)
		{
			if (a[i][l] == '+')
			{
				s = 1;
				break;
			}
		}
		if (s) break;
	}

	if (!s)
	{


		if (ma >= t)
		{
			ma = t;
			for (i = 0; i < t; i++)
			{
				ff[i].x = d[i].x;
				ff[i].y = d[i].y;
			}
		}
		return;
	}

	if (x >= 4) return;

	if (a[x][y] == '-') a[x][y] = '+';
	else a[x][y] = '-';

	for (i = 0; i < 4; i++)
	{
		if (a[i][y] == '-' && i != x) a[i][y] = '+';
		else if (i != x) a[i][y] = '-';
	}
	for (i = 0; i < 4; i++)
	{
		if (a[x][i] == '-' && i != y) a[x][i] = '+';
		else if (i != y) a[x][i] = '-';
	}



	if (y + 1 < 4)
	{
		d[t].x = x + 1;
		d[t].y = y + 1;
		dfs(x, y + 1, t + 1);
	}
	else
	{
		d[t].x = x + 1;
		d[t].y = y + 1;
		dfs(x + 1, 0, t + 1);
	}


	if (a[x][y] == '-') a[x][y] = '+';
	else a[x][y] = '-';

	for (i = 0; i < 4; i++)
	{
		if (a[i][y] == '-' && i != x) a[i][y] = '+';
		else if (i != x) a[i][y] = '-';
	}
	for (i = 0; i < 4; i++)
	{
		if (a[x][i] == '-' && i != y) a[x][i] = '+';
		else if (i != y) a[x][i] = '-';
	}




	if (y + 1 < 4) dfs(x, y + 1, t);
	else dfs(x + 1, 0, t);

	return;
}
int main()
{
	int i;
	for (i = 0; i < 4; i++) scanf("%s", &a[i]);
	dfs(0, 0, 0);
	cout << ma << endl;
	for (i = 0; i < ma; i++) cout << ff[i].x << ' ' << ff[i].y << endl;
	return 0;
}

解法二：
来自于某个博主，防止以后找不到帖子，所以copy了一份。

	poj2965--较为巧妙的算法

这一题大意如下：

   	一个冰箱上有4*4共16个开关，改变任意一个开关的状态（即开变成关，关变成开）时，
   	此开关的同一行、同一列所有的开关都会自动改变状态。要想打开冰箱，要所有开关全部打开才行。

	 输入：一个4×4的矩阵，+表示关闭，-表示打开；
	 输出：使冰箱打开所需要执行的最少操作次数，以及所操作的开关坐标。

这一题很多人使用BFS的方法，其实还有一种更为精妙的方法，值得大家思考。

这种方法网上很多人都提到了，但是说的都不太清晰，我想了很久也没想明白，后来我用程序追踪一下运行的过程，才豁然开朗。

首先要明白最基本的原理：对一个开关进行操作n次，如果n为偶数，那么这个开关以及同行、同列的开关状态都不发生改变，等价于没有操作；如果n为奇数，那么这个开关以及同行同列的开关状态全都发生改变，等价于只操作了一次。

要想使所有开关状态全部打开（全部是-），就要把所有+变成-，所有-不改变。我们要做的就是找到一种“公式”，策略，使得不改变已经打开的开关状态的情况下，把关闭的开关打开。这点很类似于魔方（PS：玩过魔方的都知道，魔方所谓的公式，其实就是在不改变已经拼好的部分的情况下，把其他部分一点一点添加到已拼好的部分）。

我们找到的策略就是：把开关本身以及其同一行同一列的开关（总共7个）都进行一次操作，结果是，开关本身状态改变了7次，开关同一行、同一列的开关状态改变了4次，其他开关状态改变了2次。如下图所示。

假如开关坐标为第二行第三列的（2，3），那么按照上述策略（把开关本身以及其同一行同一列的开关都进行一次操作），结果分析如下：

对于黄色部分的开关，只有与此黄色开关同一行和同一列的两个红色开关操作时，此黄色开关的状态才会发生改变，因此所有黄色部分状态改变次数为2，相当于0次

对于红色部分的开关，只有与此红色开关同一列或同一列的开关操作时，此红色开关状态才会发生改变，一行或者一列有4个开关，因此红色部分开关状态改变次数为4，相当于0次

对于最原始的那个黑色开关，所有红色开关操作时，它的状态改变一次，然后黑色开关自己操作一次，因此黑色开关状态改变7次，相当于改变1次。

总结上述分析可以得出结论，把开关本身以及其同一行同一列的开关都进行一次操作，最终结果是只有开关本身状态发生变化，其他所有开关状态都不变。

策略找到之后，那我们就想，如果对于所有关闭着的开关都进行一次上述策略，那么肯定是能把冰箱打开的，下面我们要做的就是把一些无用的，重复的操作去掉即可。

#include <iostream>
#include <cmath>
#include <stdio.h>
using namespace std;
int map1[4][4];
bool vis[4][4];

int flip(int x, int y) {
    for (int i = 0; i < 4; i++) {
        vis[x][i] = !vis[x][i];
        vis[i][y] = !vis[i][y];
    }
    vis[x][y] = !vis[x][y];
    for (int i = 0; i < 4; i++)
    {
        for (int l = 0; l < 4; l++)
        {
            cout << vis[i][l] << ' ';
        }
        cout << endl;
    }
    return 0;
}

int main()
{
    char temp;
    int c = 0, pos[16][2];
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            cin >> temp;
            if (temp == '-') {
                map1[i][j] = 0;
            }
            else map1[i][j] = 1;
            vis[i][j] = false;
        }
    }
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            if (map1[i][j] == 1) {
                //flip cow raw
                flip(i, j);
            }
        }
    }
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            if (vis[i][j] == true) {
                pos[c][0] = i + 1;
                pos[c][1] = j + 1;
                c++;
            }
        }
    }
    cout << c << endl;
    for (int i = 0; i < c; i++) {
        cout << pos[i][0] << " " << pos[i][1] << endl;
    }
    return 0;
}