【简单搜索】FlipTile

FlipTile

问题描述

Farmer John knows that an intellectually satisfied cow is a happy cow
who will give more milk. He has arranged a brainy activity for cows in
which they manipulate an M × N grid (1 ≤ M ≤ 15; 1 ≤ N ≤ 15) of square
tiles, each of which is colored black on one side and white on the
other side.

As one would guess, when a single white tile is flipped, it changes to
black; when a single black tile is flipped, it changes to white. The
cows are rewarded when they flip the tiles so that each tile has the
white side face up. However, the cows have rather large hooves and
when they try to flip a certain tile, they also flip all the adjacent
tiles (tiles that share a full edge with the flipped tile). Since the
flips are tiring, the cows want to minimize the number of flips they
have to make.

Help the cows determine the minimum number of flips required, and the
locations to flip to achieve that minimum. If there are multiple ways
to achieve the task with the minimum amount of flips, return the one
with the least lexicographical ordering in the output when considered
as a string. If the task is impossible, print one line with the word
“IMPOSSIBLE”.

Input

Line 1: Two space-separated integers: M and N Lines 2… M+1: Line i+1
describes the colors (left to right) of row i of the grid with N
space-separated integers which are 1 for black and 0 for white

Output

Lines 1… M: Each line contains N space-separated integers, each
specifying how many times to flip that particular location.

Sample Input

4 4
1 0 0 1
0 1 1 0
0 1 1 0
1 0 0 1

Sample Output

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

思路

通过翻转第i行的瓷砖，将第i-1行的瓷砖全部翻转成白色。
而第i-1行第j个瓷砖的状态受它四周及本身的翻转次数影响。

• 翻转次数之和加上自身状态是偶数，则不需要翻转
• 翻转次数之和加上自身状态是奇数，则不需要翻转

从第二行开始翻转，翻转完倒数第二行后，检验最后一行瓷砖的状态

• 如果最后一行全白，则该方案可行
• 如果最后一行中仍有黑色的瓷砖，则该方案不可行

由于是从第二行开始翻转的，在上述动作中未对第一行操作。所以我们可以在最开始对第一行可能出现的情况进行枚举，即进行所有可能的翻转操作（2^N种）。
为了方便，这里采用的是二进制枚举。

for(int j=0; j<N; j++){
			flip[0][N-j-1]=i>>j&1;
			/*
			** i>>j&1 means
			** i>>j's last bit==1, return 1
			** i>>j's last bit==0, return 0
			*/
	}

枚举时是由右向左枚举的，所以最终给出的方案即是字典序最小的。

代码样例

//D-Fliptile
#include<iostream>
#include<cstring>
using namespace std;
#define MAXN 20
int M, N;
int direction[5][2]={{0,0},{1,0},{-1,0},{0,1},{0,-1}};
int tiles[MAXN][MAXN], flip[MAXN][MAXN], final_tiles[MAXN][MAXN];
/*
** tiles[i][j]==0, white
** tiles[i][j]==1, black
**
** flip[i][j]==0, don't flip
** flip[i][j]==1, flip
*/
int turn_over(int raw, int column){
	int temp=tiles[raw][column];
	for(int i=0; i<5; i++){
		int _raw=raw+direction[i][0];
		int _column=column+direction[i][1];
		if(_raw<0||_column<0||_raw>=M||_column>=N){
			continue;
		}
		temp+=flip[_raw][_column];
	}
	return temp%2;
}
/*
** turn_over(i-1, j)==1, flip[i][j]=1
** turn_over(i-1, j)==0, flip[i][j]=0
*/
int dfs(){
	for(int i=1; i<M; i++){
		for(int j=0; j<N; j++){
			if(turn_over(i-1, j)){
				flip[i][j]=1;
			}
		}
	}
	for(int i=0; i<N; i++){
		if(turn_over(M-1, i)){
			//when the last line tiles are not at all white
			return -1;
		}
	}
	int step=0;
	for(int i=0; i<M; i++){
		for(int j=0; j<N; j++){
			step+=flip[i][j];
		}
	}
	return step;
}
int main(void){
	cin>>M>>N;
	for(int i=0; i<M;i++){
		for(int j=0; j<N; j++){
			cin>>tiles[i][j];
		}
	}	
	bool flag=false;
	int ans=0x3f3f3f3f;	//0x3f3f3f3f equals to 1061109567, a number large enough but not the largest
	for(int i=0; i<1<<N; i++){	//1<<N equals to 2^N
		memset(flip, 0, sizeof(flip));
		for(int j=0; j<N; j++){
			flip[0][N-j-1]=i>>j&1;
			/*
			** i>>j&1 means
			** i>>j's last bit==1, return 1
			** i>>j's last bit==0, return 0
			*/
		}
		int step=dfs();
		if(step>=0 && step<ans){
			flag=true;
			ans=step;
			memcpy(final_tiles, flip, sizeof(flip));
		}
	}
	if(!flag){
		cout<<"IMPOSSIBLE"<<endl;
	}
	else{
		for(int i=0; i<M; i++){
			for(int j=0; j<N; j++){
				if(j!=0){
					cout<<" ";
				}
				cout<<final_tiles[i][j];
			}
			cout<<endl;
		} 
	}
	return 0;
}

• 1605集训计划第4天任务
• 延期2天完成