POJ 1753 Flip Game

这道题看起来恐怖，其实还可以。。。我发现递归就是不能深想，深想就晕。。。

DFS + 枚举就可以了

放上参考过网上解题报告的数据规模分析和问题分析：

1、一共就16个格子，最多每个格子翻转一下，一共最多16步，最多是2的16次方种可能 （原来递归能够HOLD住这种数据规模）

2、翻动顺序对结果没有影响

3、就是在求格子的翻动组合

这里枚举的是翻转的步数，学习了

#include<stdio.h>
char a[5][5];
int num[5][5] = {0};
int step, state = 0;
int dir[5][2] = {{0,0}, {-1,0}, {0,-1}, {1,0}, {0,1}};		       // 比较好的解决格子邻边问题的办法！要记住！ 
int judge( ){							       // 判断是否一致的函数 
	int i, j;
	int flag = 1;
	for( i = 0; i < 4; i++)
		for( j = 0; j < 4; j++)
			if( num[i][j] != num[0][0]){ flag = 0; break;}
	return flag;
}
int flip( int i, int j){                                         // 翻动函数
	int k, flag = 0;
	for( k = 0; k <= 4; k++)
		num[i+dir[k][0]][j+dir[k][1]] = !num[i+dir[k][0]][j+dir[k][1]];      // 取反
}
void dfs( int r, int w, int temp_step); 

int main(void){
	int i, j;
	for( i = 0; i < 4; i++) gets(a[i]);			// 输入一个矩阵 
	for( i = 0; i < 4; i++)
		for( j = 0; j < 4; j++)
			if( a[i][j] == 'b') num[i][j] = 1;	// 矩阵加工，还是必要的，因为取反比较方便
			
	if( judge()) printf("0\n");
	else{
		for( step = 1; step <= 16; step++){             // 枚举步数
			dfs( 0, 0, 0);
			if( state) break;
		}
		if( state) printf("%d\n", step);
		else printf("Impossible");
	}
	return 0;
}

void dfs( int r, int w, int temp_step){
	int i, j;
	if( temp_step == step){                                // 步数相同时要返回
		state = judge();                               // 此时进行判断
		return;
	}
	else if( state || r == 4 ) return;          // 枚举完成或者已经满足条件时要返回 这里要有满足条件时返回，因为第一个判断结果是返回而不是退出函数
	else{
		flip( r, w);                                   // 翻转
		if( w < 3) dfs( r, w+1, temp_step+1);          // 翻转同行，若到3则换行
		else dfs( r+1, 0, temp_step+1);
		flip( r, w);                                   // 这里，因为是全局变量，所以要把棋盘改回最初状态才能继续枚举
		if( w < 3) dfs( r, w+1, temp_step);            // 步数是不变的
		else dfs( r+1, 0, temp_step);
	//	return ;                                       // 函数自然返回，处于一些习惯，可以不写的
	}
}