POJ 2965（DFS+枚举）

题目链接：http://poj.org/problem?id=2965

题意：4*4矩阵,矩阵上每个元素都有两种符号+和-，每次变换将同行同列元素全部变为相反状态，问需要多少次可以将矩阵所有运算的状态变为+。

思路：这道题和1753那道题差不多。题目不会出现Impossible的情况。具体做法是DFS+枚举，每个元素只有两种状态，所有元素共有2^16次状态，代码整体实现和1753差不多，具体参考如下。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;

const int maxn=1010;
int T,n,m;
bool ref[10][10];
int r[20],c[20];
int step;
bool flag=false;

bool judge_State(){
	for(int i=1;i<=4;i++){
		for(int j=1;j<=4;j++){
			if(ref[i][j]!=true)
				return false;
		}
	}
	return true;
}

void change_State(int row,int col){
	ref[row][col]=!ref[row][col];
	for(int i=1;i<=4;i++){
		ref[row][i]=!ref[row][i];
		ref[i][col]=!ref[i][col];
	}
}

void dfs(int row,int col,int deep){
	if(deep==step){
		flag=judge_State();
		return ;
	}
	if(flag||row==5) return;
	r[deep]=row;c[deep]=col;
	change_State(row,col);
	if(col<4)
		dfs(row,col+1,deep+1);
	else
		dfs(row+1,1,deep+1);

	change_State(row,col);
	if(col<4)
		dfs(row,col+1,deep);
	else
		dfs(row+1,1,deep);
}

int main(){
#ifndef ONLINE_JUDGE
	freopen("test.in","r",stdin);
	freopen("test.out","w",stdout);
#endif
    char ch;
    for(int i=1;i<=4;i++){
    	for(int j=1;j<=4;j++){
    		cin>>ch;
    		if(ch=='-')
    			ref[i][j]=true;
    		else
    			ref[i][j]=false;
    	}
    }
    for(step=0;step<=16;step++){
    	dfs(1,1,0);
    	if(flag)
    		break;
    }
    printf("%d\n",step);
    for(int i=0;i<step;i++)
    	printf("%d %d\n",r[i],c[i]);
    return 0;
}

但是后来搜了一下题解，发现这道题有很多人用的是BFS，还有一些大神用的奇技淫巧，瞬间感觉自己弱爆了。

下面附上链接：http://www.cnblogs.com/Java-tp/p/3873557.html

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

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

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

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

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

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

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

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

 

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

用一个4*4的数组记录每个开关操作的次数，初始化为0，开关操作一次，记录就+1，以样例（http://poj.org/problem?id=2965）为例：

-+--
----
----
-+--

1 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0

1 1 0 0
0 0 0 0
0 0 0 0
0 0 0 0

1 1 1 0
0 0 0 0
0 0 0 0
0 0 0 0

1 1 1 1
0 0 0 0
0 0 0 0
0 0 0 0

1 1 1 1
0 1 0 0
0 0 0 0
0 0 0 0

1 1 1 1
0 1 0 0
0 1 0 0
0 0 0 0

1 1 1 1
0 1 0 0
0 1 0 0
0 1 0 0

 

 

1 1 1 1
0 1 0 0
0 1 0 0
1 1 0 0

1 1 1 1
0 1 0 0
0 1 0 0
1 2 0 0

1 1 1 1
0 1 0 0
0 1 0 0
1 2 1 0

1 1 1 1
0 1 0 0
0 1 0 0
1 2 1 1

1 2 1 1
0 1 0 0
0 1 0 0
1 2 1 1

1 2 1 1
0 2 0 0
0 1 0 0
1 2 1 1

1 2 1 1
0 2 0 0
0 2 0 0
1 2 1 1

对于样例中的每一个+开关，进行一次策略，记录数组所记录的每一个开关操作的次数变化如上所示。那么在最终得到的数组中可以看出，有些开关操作了偶数次，有些操作了奇数次。操作了偶数次的开关就是上面所说的无用的，重复的操作，直接去掉，留下奇数次的就最终的答案。

附上代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;

const int maxn=1010;
int T,n,m;
int ref[10][10];

int get_Step(){
	int ans=0;
	for(int i=1;i<=4;i++){
		for(int j=1;j<=4;j++){
			ans+=ref[i][j]%2;
		}
	}
	return ans;
}

void output_Path(){
    for(int i=1;i<=4;i++){
		for(int j=1;j<=4;j++){
			if(ref[i][j]&1)
				printf("%d %d\n",i,j);
		}
	}
}

int main(){
#ifndef ONLINE_JUDGE
	freopen("test.in","r",stdin);
	freopen("test.out","w",stdout);
#endif
	memset(ref,0,sizeof(ref));
    char ch;
    for(int i=1;i<=4;i++){
    	for(int j=1;j<=4;j++){
    		cin>>ch;
    		if(ch=='+'){
    			for(int k=1;k<=4;k++){
    				ref[i][k]++;
    				ref[k][j]++;
    			}
    			ref[i][j]--;
    		}
    	}
    }
    int step=get_Step();
    printf("%d\n",step);
    output_Path();
    return 0;
}