POJ1753 Flip Game（AC）

最新推荐文章于 2020-07-14 21:48:35 发布
最新推荐文章于 2020-07-14 21:48:35 发布
阅读量359 收藏
点赞数
分类专栏： DFS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010009623/article/details/49903103
版权
Flip Game
Time Limit: 1000MS Memory Limit: 65536K
Total Submissions: 46594 Accepted: 19948

Description

Flip game is played on a rectangular 4x4 field with two-sided pieces placed on each of its 16 squares. One side of each piece is white and the other one is black and each piece is lying either it's black or white side up. Each round you flip 3 to 5 pieces, thus changing the color of their upper side from black to white and vice versa. The pieces to be flipped are chosen every round according to the following rules: 
  1. Choose any one of the 16 pieces. 
  2. Flip the chosen piece and also all adjacent pieces to the left, to the right, to the top, and to the bottom of the chosen piece (if there are any).

Consider the following position as an example: 

bwbw 
wwww 
bbwb 
bwwb 
Here "b" denotes pieces lying their black side up and "w" denotes pieces lying their white side up. If we choose to flip the 1st piece from the 3rd row (this choice is shown at the picture), then the field will become: 

bwbw 
bwww 
wwwb 
wwwb 
The goal of the game is to flip either all pieces white side up or all pieces black side up. You are to write a program that will search for the minimum number of rounds needed to achieve this goal. 

Input

The input consists of 4 lines with 4 characters "w" or "b" each that denote game field position.

Output

Write to the output file a single integer number - the minimum number of rounds needed to achieve the goal of the game from the given position. If the goal is initially achieved, then write 0. If it's impossible to achieve the goal, then write the word "Impossible" (without quotes).

Sample Input

bwwb
bbwb
bwwb
bwww

Sample Output

4

Source

Northeastern Europe 2000 

//20170902
//多少步才能全白或者全黑，最小步
//DFS的过程是将所有过程都遍历下
//此题第一遍是所有棋子都不动
//到最后一个棋子的不动状态，然后就到最后一个棋子需要翻的状态，函数返回，再到倒数第2个棋子需要翻的状态，然后是最后一个棋子翻和不翻的两个状态再走一遍

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#define MAXN 5

char matrix[MAXN][MAXN];
int ans = 130000;

int whitenum = 0;
int blacknum = 0;

int dis[4][2] = { { 1, 0 }, { -1, 0 }, { 0, 1 }, {0,-1} };

int strcmpp(char* s, char*d)
{	
	while (*s != '\0')
	{
		if (*s != *d) return 0;
		s += 1;
		d += 1;
	}
	return 1;
}

int same()
{
	int i = 0;
	int j = 0;
	int white = 0;
	int black = 0;

	if (strcmpp(matrix[0], "bbbb") && strcmpp(matrix[1], "bbbb") && strcmpp(matrix[2], "bbbb") && (strcmpp(matrix[3], "bbbb")))
	{
		return 1;
	}
	else if(strcmpp(matrix[0], "wwww") && strcmpp(matrix[1], "wwww") && strcmpp(matrix[2], "wwww") && (strcmpp(matrix[3], "wwww")))
	{
		return 1;
	}
	else
	{
		return 0;
	}					


	return 0;
}

void reverse(int x, int y)
{
	int i = 0;
	int j = 0;
	int tmpx = 0;
	int tmpy = 0;
	//注意中心点也要变的
	if ('b' == matrix[x][y])
	{
		matrix[x][y] = 'w';
	}
	else
	{
		matrix[x][y] = 'b';
	}

	for (i = 0; i < 4;i++)
	{
		tmpx = x + dis[i][0];
		tmpy = y + dis[i][1];
		if ((tmpx<0) || (tmpx >= 4) || (tmpy<0) || (tmpy>=4)) continue;
		if ('b' == matrix[tmpx][tmpy])
		{
			matrix[tmpx][tmpy] = 'w';
		}
		else
		{
			matrix[tmpx][tmpy] = 'b';
		}
	}
	return;
}

void dfs(int x, int y, int step)
{
	int i = 0;
	if ((x<0) ||(x>=4)||(y<0)) return;
	if (ans<=step) return; //进来的步数已经比现在大了，那就不需要再比较了

	if (1 == same())
	{
		if (ans>step)
		{
			ans = step;
		}
		return;
	}

	if (y >= 4)
	{
		x += 1;//换行
		y = 0;//这个不能漏
	}

	//每个点都可以翻或不翻
	for (i = 1; i <= 2;i++)
	{
		//(x,y)点不翻，直接到下一个点
		if (1 == i)
		{
			dfs(x, y + 1, step);
		}
		else
		{
			reverse(x, y);
			dfs(x, y + 1, step + 1);
			reverse(x, y);
		}
	}

	return;
}

int main()
{
	int i = 0;
	int j = 0;
	int step = 0;
	freopen("input.txt","r",stdin);
	for (i = 0; i < 4;i++)
	{
		scanf("%s",matrix[i]);
		for (j = 0; j < 4;j++)
		{
			if ('b' == matrix[i][j])
			{
				blacknum += 1;
			}
			else
			{
				whitenum += 1;
			}
		}
	}

	//矩阵这么小，可以用DFS做
	if (1 == same())
	{
		printf("0\n");
	}
	else
	{
		//dfs
		/*for (i = 0; i < 4;i++)
		{
			for (j = 0; j < 4; j++)
			{
				dfs(i,j,);
			}
		}*/

		//不用for循环，因为DFS里面会不断check
		dfs(0, 0, step);


		if (130000 == ans)
		{
			printf("Impossible\n");
		}
		else
		{
			printf("%d\n",ans);
		}
	}

	return 0;
}


 
 
#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

#define MAXINT 5

char map[MAXINT][MAXINT];
int  visit[MAXINT][MAXINT];
int  ans = 10000;
int shu = 0;

int dir[4][2] = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };
/*ST AC*/

//因为题目中定了是只有4*4的矩阵，所以可以用DFS
//而且我认为每个元素只能当一次中心，否则就没法弄了这道题

/*第一次提交WA 20/100 后来reverse加了中心点也要取反*/
/*第二次提交WA 40/100 然后发现主体代码写的就不太对，找点的时候都是随机找的，而不是从四个方向找，取反是从四个方向取反的
  但是这样改之后发现时间复杂度很高，超时*/

/*每个点要么变要么不变，然后一共16个点，那时间复杂度应该是2^16，但是我写的代码怎么就变成16!(16*15*...*2*1),这个不对的呀，肯定有很多重复的场景存在*/
/*最终的解题方法还是参考的别人的代码的，自己还是要增加主观能动性啊*/
/*第四次提交85/100 没有考虑全黑全白的情况,ans没有重新赋值*/
/*修改后第五次提交95/100 找不到什么具体的原因啊。。。。
  走查代码找到了
  if (3 == x) //如果x搜索到最后一行，则重新开始，然后列增加
	{
		x = -1; //因为后面会给x+1的，如果这边x=0的话，那0行就错过了，这是不对的
		y += 1;
	}
原来写的是x=0*/

void init()
{
	int k = 0;
	int j = 0;
	for (j = 0; j < MAXINT; j++)
	{
		for (k = 0; k < MAXINT; k++)
		{
			map[j][k]   = '\0';
			visit[j][k] = 0;
		}
	}
	ans = 10000;
	shu = 0;
	return;
}

int check()
{
	int i = 0;
	int j = 0;
	int black = 0;
	int white = 0;
	for (i = 0; i < 4;i++)
	{
		for (j = 0; j < 4;j++)
		{
			if ('b' == map[i][j])
			{
				black += 1;
			}
			else
			{
				white += 1;
			}
			if ((0 != black) && (0 != white))
			{
				return 0;
			}
		}
	}
	return 1;
}

void Reverse(int x, int y )
{
	int i = 0;
	if ((x < 0) || (x>3) || (y < 0) || (y>3)) return;
	//注意这个中心值
	if ('b' == map[x][y])
	{
		map[x][y] = 'w';
	}
	else
	{
		map[x][y] = 'b';
	}
	for (i = 0; i < 4;i++)
	{
		int x1 = x + dir[i][0];
		int y1 = y + dir[i][1];
		if ((x1 < 0) || (x1>3) || (y1 < 0) || (y1>3)) continue;
		if ('b' == map[x1][y1])
		{
			map[x1][y1] = 'w';
		}
		else
		{
			map[x1][y1] = 'b';
		}
	}
	return;
}

void dfs(int x, int y, int num) //num表示有多少个已经动过也就是步数
{
	int i = 0;
	int j = 0;
	int k = 0;
	//if ((x < 0) || (x>3) || (y < 0) || (y>3)) return;

	if (4 == y) return;//已经搜到最后一个点了，不再搜索了
	if (3 == x) //如果x搜索到最后一行，则重新开始，然后列增加
	{
		x = -1; //因为后面会给x+1的，如果这边x=0的话，那0行就错过了，这是不对的
		y += 1;
	}


	//重要的剪枝，如果走的步数已经要大于已经存的结果，直接return，后面的搜索无意义
	if (ans <= num)
	{
		return;
	}
	
	if (1 == check()) //check有没有都变成白色或黑色
	{	
		if (ans > num) ans = num;
		return;
	}

	//如果16个已经动过，那只能返回了，如果是全黑或全白前面就判断过了
	if (16 == num)  
	{
		return;
	}

	//这个写的都不对，第2个点不是从四个方向找的，可以随机选点的，这个一定要注意，前2次提交都是不对的
	/*for (i = 0; i < 4;i++)
	{
		int x1 = x + dir[i][0];
		int y1 = y + dir[i][1];
		if ((x1 < 0) || (x1>3) || (y1 < 0) || (y1>3)) continue;
		if (1 == visit[x1][y1]) continue;
		visit[x1][y1] = 1;
		dfs(x1,y1,num+1);
		//回溯
		visit[x1][y1] = 0;
	}*/

	/*这样写不对的原因在于有很多重复的场景存在，导致时间复杂度达到16!*/
	/*for (j = 0; j < 4; j++)
	{
		for (k = 0; k < 4; k++)
		{
			if (1 == visit[j][k]) continue;
			Reverse(j, k);
			visit[j][k] = 1;
			dfs(j, k, num+1); 
			printf("%d,j=%d,k=%d\n",shu++,j,k);
			//回溯
			visit[j][k] = 0;
			Reverse(j, k);
		}
	}*/
	dfs(x+1, y, num); //(x+1,y)不变

	Reverse(x + 1, y);
	dfs(x + 1, y, num+1); //(x+1,y)变
	Reverse(x + 1, y);

	return;
}

int main()
{
	int i = 0;
	int j = 0;
	int k = 0;
	int T = 0;
	freopen("input.txt","r",stdin);
	scanf("%d",&T);
	for (i = 0; i < T;i++)
	{
		init();
		for (j = 0; j < 4;j++)
		{
			scanf("%s",&map[j]);
		}
		//check是否存在已经是全黑或全白的情况
		if (0 == check())
		{
			/*for (j = 0; j < 4; j++)
			{
				for (k = 0; k < 4; k++)
				{
					Reverse(j, k);
					visit[j][k] = 1;
					dfs(j, k, 1); //第一个起点不一定是从0,0开始的，这个要注意的
					//printf("%d\n", shu++);
					//回溯
					visit[j][k] = 0;
					Reverse(j, k);
				}
			}*/
			//visit[0][0] = 1;
			dfs(0, 0, 0); //(0,0)不变
			//visit[0][0] = 0;

			//visit[0][0] = 1;
			Reverse(0, 0);
			dfs(0, 0, 1); //(0,0)变
			//visit[0][0] = 0;
			Reverse(0,0); //这边不回溯应该也没关系，因为也不会再用了，这样可以节省点时间
		}
		else
		{
			ans = 0;//说明有全黑或全白
		}

		if (10000 == ans)
		{
			printf("impossible\n");
		}
		else
		{
			printf("%d\n",ans);
		}
	}
	return 0;
}
 
<pre class="cpp" name="code">#include <stdio.h>
//一共就4*4所以可以用dfs来做
//第一次提交95/100,AC1第一次做的时候也犯过类似的错误
/*
if (y>=4)
{
x = x + 1;
y = 0; //这里写的y=1不对的，我们是从0开始的，哎，哎，这个1，0还是很容易弄错
}
*/
#define MAXINT 10
#define MAX 100000
char map[MAXINT][MAXINT];
int ans = MAX;

int dir[4][2] = { { 1, 0 }, { -1, 0 }, { 0, 1 }, {0,-1} };

void init()
{
	int i = 0;
	int j = 0;
	for (i = 0; i < MAXINT; i++)
	{
		for (j = 0; j < MAXINT; j++)
		{
			map[i][j] = '\0';
		}
	}
	ans = MAX;
	return;
}

int check()
{
	int i = 0;
	int j = 0;
	char test = map[0][0];
	for (i = 0; i < 4;i++)
	{
		for (j = 0; j < 4; j++)
		{
			if (test != map[i][j]) return 0;
		}
	}
	return 1;
}

void Revert(int x, int y)
{
	int i = 0;
	if ('b' == map[x][y])
	{
		map[x][y] = 'w';
	}
	else
	{
		map[x][y] = 'b';
	}
	for (i = 0; i < 4;i++)
	{
		int x1 = x + dir[i][0];
		int y1 = y + dir[i][1];
		if ((x1<0) || (x1 >= 4) || (y1<0) || (y1 >= 4)) continue;
		if ('b' == map[x1][y1])
		{
			map[x1][y1] = 'w';
		}
		else
		{
			map[x1][y1] = 'b';
		}
	}
	return;
}

void dfs(int x,int y,int step)
{
	int i = 0;
	if (1 == check())
	{
		if (ans > step)
		{
			ans = step;
		}
		return;
	}

	if (y>=4)
	{
		x = x + 1;
		y = 0; //这里写的y=1不对的，我们是从0开始的，哎，哎，这个1，0还是很容易弄错
	}

	if (x>=4)
	{
		return;
	}

	//这个点有2个选择，反还是不反
	for (i = 1; i <= 2;i++)
	{
		if (1 == i)  //这个点不动
		{
			dfs(x, y + 1, step);
		}
		else //取反
		{
			Revert(x, y);
			dfs(x, y + 1, step + 1);
			//回溯
			Revert(x, y);
		}
	}
	return;
}


int main()
{
	int i = 0;
	int j = 0;
	int k = 0;
	int T = 0;
	freopen("input.txt","r",stdin);
	scanf("%d",&T);
	for (i = 0; i < T;i++)
	{
		init();
		for (j = 0; j < 4;j++)
		{
			scanf("%s",&map[j]);
		}
		dfs(0, 0, 0);
		if (MAX != ans)
		{
			printf("%d\n", ans);
		}
		else
		{
			printf("impossible\n");
		}
	}
	return 0;
}


 


                

        

        

    

  


    

      

        

            

              
                
                  twinslizzy维
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
POJ1753-Flip Game

				
			

			

				

					07-29
				

			

		

		

			
				
两个解决方案的代码文件“POJ1753-Flip Game(BFS+bit).cpp”和“POJ1753-Flip Game(DFS+enum).cpp”分别实现了BFS和DFS策略。阅读这些代码可以帮助理解如何将理论转换为实际的程序实现。  五、文档说明 “POJ1753-...

			
		

	



                

              
                



	

		

			

				
					
POJ - 1753 DFS回溯法 类似八皇后问题 总感觉会超时就不敢写

				
			

			

				

					从你的全世界路过
				

				

					05-28
					
					145
					
				

			

		

		

			
				
题目

题解思路
时间复杂度 2 的16次方 。

啊这，我太高估它了！
对每个位置进行翻转或者不翻转的操作，翻转了记得回溯，当到遍历完所有位置时，检查有没有答案，如果有就更新，更新出来的答案还可以剪枝操作。
看来以后要先算算时间复杂度了！！！
AC代码
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#includ

			
		

	



                


  
              

                


	

		

			

				
					
poj 1753 Flip Game(dfs)

				
			

			

				

					JUST CODE IT
				

				

					08-30
					
					261
					
				

			

		

		

			
				
题目链接
题目大意：一个4*4的方格，上面黑白棋都有，可以任意翻转其中的一个旗子，但是这个旗子的上下左右都要跟着反转（白变黑，黑变白）
求最少次数使得棋谱全黑或全白


一个位置无非就是翻或者不翻，翻得话连动身边的一起翻，复杂度就是2^16*4，不大
果断深搜，要注意回溯，一个点翻转之后，要再次翻回来，避免一个状态的改变
#include
#include
#include
#inc

			
		

	





	

		

			

				
					
acm，poj中不容易发现的runtime error解决方法

					
热门推荐

				
			

			

				

					Aleac的工作室
				

				

					05-22
					
					1万+
					
				

			

		

		

			
				
acm，poj，runtime error 解决方法

			
		

	



		

			
		



	

		

			

				
					
POJ 1753 Flip Game (递归枚举)

				
			

			

				

					weixin_34062469的博客
				

				

					04-27
					
					132
					
				

			

		

		

			
				
POJ 1753，题目链接http://poj.org/problem?id=1753，翻译一下整个题目的大概意思：有4*4的正方形，每个格子要么是黑色，要么是白色，当把一个格子的颜色改变(黑-&gt;白或者白-&gt;黑)时，其周围上下左右(如果存在的话)的格子的颜色也被反转，问至少反转几个格子可以使4*4的正方形变为纯白或者纯黑？

主要思路如下：
1.对于每个格子，它要么反转0次，要么...

			
		

	





	

		

			

				
					
[POJ 1753]Flip Game

				
			

			

				

					ZhiyunXie的博客
				

				

					03-02
					
					271
					
				

			

		

		

			
				
POJ 1753
大意:
给定一个4*4的黑白棋盘,每次可以将一个棋子反转颜色,同时这个棋子的上下左右都会反转,问你最少反转几次,可以将整个棋盘变成同色的
时空限制:
1000ms/65536kB
输入格式:
共4行,每行4个字符,若是b表示是黑,w表示是白
输出格式:
1行，1个数字表示最少需要反转几次
数据范围:
无

一遍dfs,枚举每个点要不要选,时间复杂度O(216)
代码中把数组的0和...

			
		

	





	

		

			

				
					
POJ1753.rar_poj 1753_poj1753

				
			

			

				

					09-20
				

			

		

		

			
				
【描述】"POJ1753 Flip Game题目完整代码及报告" 暗示这个压缩包包含了对POJ1753问题的解答，不仅有代码实现，还有可能涉及问题分析、解题思路以及运行结果的详细报告。通常，这类资源对于学习和理解特定编程问题的...

			
		

	





	

		

			

				
					
poj1753枚举

				
			

			

				

					05-16
				

			

		

		

			
				
该题记录了本人研究该题的记录，有些是心得，希望能给大家帮助。

			
		

	





	

		

			

				
					
POJ1027-The Same Game

				
			

			

				

					07-31
				

			

		

		

			
				
- "POJ1027-The Same Game.cpp"：这是C++语言编写的源代码文件，包含了AC代码的实现。代码中可能会有详细的注释，解释每一步操作的逻辑。 - "POJ1027-The Same Game.doc"：这是一个文档文件，很可能包含了上述解题...

			
		

	





	

		

			

				
					
Poj1006题目ac代码

				
			

			

				

					12-01
				

			

		

		

			
				
标题"Poj1006题目ac代码"表明我们要讨论的是一个与编程竞赛相关的主题，具体是POJ（Programming Online Judge）平台上的问题1006。POJ是北京大学主办的一个在线编程竞赛系统，ACM（Association for Computing ...

			
		

	





	

		

			

				
					
POJ - 1753 Flip Game（枚举）

				
			

			

				

					MengHao的博客
				

				

					07-27
					
					212
					
				

			

		

		

			
				
Flip Game

Time Limit:1000MS
			
			Memory Limit:65536K
		Description

Flip game is played on a rectangular 4x4 field with two-sided pieces placed on...

			
		

	





	

		

			

				
					
PKU1579 Function Run Fun （DP水题）

				
			

			

				

					zonelight的专栏
				

				

					07-28
					
					704
					
				

			

		

		

			
				
/*  Function Run FunTime Limit: 1000MS        Memory Limit: 10000KTotal Submissions: 6329        Accepted: 3475DescriptionWe all love recursion! Dont we?Consider a three-paramet

			
		

	





	

		

			

				
					
poj1753（枚举）题解

				
			

			

				

					简 ---
				

				

					02-26
					
					3054
					
				

			

		

		

			
				
poj1753
题目
Flip game is played on a rectangular 4x4 field with two-sided pieces placed on each of its 16 squares. One side of each piece is white and the other one is black and each piece is lying eit...

			
		

	





	

		

			

				
					
POJ1753  Flip Game（仅思路）

				
			

			

				

					Yi__Xiao的博客
				

				

					03-19
					
					246
					
				

			

		

		

			
				
POJ1753

四乘四黑白棋盘。
翻转一个棋子，周围四个棋子都会变色。
input:棋盘初始情况
output：变成纯色的最小步数，不存在则为"impossible"
思路：选择一个棋子翻转有16种可能。
选择两个棋子翻转有120种可能。
以此类推，共有2的16次方个可能。
遍历所有可能同时记录步数。判断是否成为纯色，如果成为纯色，结束遍历，输出结果

...

			
		

	





	

		

			

				
					
安装windows和Ubuntu双系统

				
			

			

				

					dnye58520的博客
				

				

					11-22
					
					83
					
				

			

		

		

			
				
1.安装Windows。在硬盘分区中，预留一部分未分区空间，用作安装ubuntu系统。
2.用UltraISO把ubuntu的iso文件刻录到U盘，用U盘启动，进行安装Ubuntu。
3.安装完成后，重启系统，拔出U盘，可以看到Windows的启动选项已经被添加到启动选择项中了。
4.双系统时，会出现Windows系统时间不同步的问题，解决方法方法：关闭Ubuntu的UTC。
修...

			
		

	





	

		

			

				
					
POJ 1753 Flip Game（枚举+状态压缩BFS）

				
			

			

				

					weixin_30699463的博客
				

				

					03-30
					
					153
					
				

			

		

		

			
				
原题地址

http://poj.org/problem?id=1753


  题意：十六宫格的棋盘，每个棋子有黑白两面，已知翻转某个棋子会造成其四周（若存在）的棋子都翻转。给定一个棋面，计算最少需要多少次能使整个棋盘的棋子全黑或全白。




解题思路

声明：本题的算法不是我自己的思路，学习了大神的方法，觉得是一种非常好的处理简单状态变迁的枚举问题，在这里做下笔记今后可以...

			
		

	





	

		

			

				
					
嗯，在POJ上AC了100题了

				
			

			

				

					KidTech
				

				

					11-02
					
					1092
					
				

			

		

		

			
				
    RT，今天终于忍不住了，刷了两个简单题，从而在POJ上AC的题目数量达到100了。    以后不刷rank了，要潜心看书研究——主要是POJ上那种简单题目太多了，而且我应该过了连简单题目知道算法而写不出来的阶段。    以后就按类型做题，慢慢总结，刷rank的话，t刷到WOJ的第一——这个是tank对我开的玩笑，是难度比较大的事情，不过对提高水平有帮助（WOJ的题目少，本人基本上已

			
		

	





	

		

			

				
					
枚举算法思路训练：poj1753

				
			

			

				

					sdibt_xhx的博客
				

				

					07-14
					
					215
					
				

			

		

		

			
				
从知乎找到一份训练大纲，先按照这个练习吧
poj1753
大意是4×4的棋盘上，不断黑白面的翻转自己和上下左右（如果有棋子的话），如果有可能翻到只有一种颜色，那么算出来最少翻几个棋子就可以做到只有一种颜色
枚举的思想是不断地猜测，从可能的集合中一一尝试，然后再判断题目的条件是否成立。
oiwiki是这么说的。。。。
不过“从可能的集合中一一尝试”这段话引起了我的注意，原因后面再说
先说一下我的思路吧：
既然是4×4的棋盘，那么翻棋子最多可能就是16个棋子每个棋子都翻一遍
因为一个棋子翻两遍等于没翻
所以最初

			
		

	





	

		

			

				
					
POJ1753（Flip Game）

				
			

			

				

					a775189488的博客
				

				

					01-01
					
					603
					
				

			

		

		

			
				
题目连接点这里

题目大意
有一个4x4的网格上面有16个按钮。按钮只有黑白两种颜色。按其中一个按钮本身和其上下左右的按钮都会改变颜色。给出初始棋牌的状态，输出最少要按多少次按钮才可以让棋牌变为一种颜色。

解题思路
	思考阶段一：找规律，这种开关类题目大多数都是有某种规律（也许），然而看了10分钟啥也没发现，放弃。
		思考阶段二：暴力枚举，将所有情况枚举出来，选择点击次数最少的情况就好。（可能...

			
		

	





	

		

			

				
					
poj1753解题过程

					
最新发布

				
			

			

				

					03-26
				

			

		

		

			
				
POJ1753题目为"Flip Game"，题目给出了一个4x4的棋盘，每个格子有黑色或白色，每次翻转一个格子会同时翻转它上下左右四个格子的颜色，目标是把整个棋盘都变为同一种颜色，求把棋盘变成同种颜色的最小步数。...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值