POJ 3279 Fliptile （dfs+二进制）

Description

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

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <cmath>
 #include <iostream>
 using namespace std;
 #define inf 0x3f3f3f3f
 int map[][],flip[][],ans[][],preans[][];
 //preans表示中间的得到的可行的答案，每次比较步数取最优
 int n,m;
 int calc (int s)
 {
     for (int i=;i<m;++i)
     {
         if (s&(<<i))
         {
             preans[][i]=;
             flip[][i]^=;//x^=1由于异或特性完美模拟翻块！！！0^1=1,1^1=0
             if (<n) flip[][i]^=;//如果其他相邻块在界内，翻过去
             if (i->=) flip[][i-]^=;
             if (i+<m) flip[][i+]^=;
         }
     }
     for (int i=;i<n;++i)
     {
         for (int j=;j<m;++j)
         {
             if (flip[i-][j])//如果某个块的正上面的块是1，那么反转这个块
             {
                 preans[i][j]=;
                 flip[i][j]^=;
                 flip[i-][j]^=;
                 if (i+<n) flip[i+][j]^=;
                 if (j->=) flip[i][j-]^=;
                 if (j+<m) flip[i][j+]^=;
             }
         }
     }
     for (int i=;i<m;++i)
     {
         if (flip[n-][i])
         return inf;
     }
     int res=;//统计当前情况的步数
     for (int i=;i<n;++i)
         for (int j=;j<m;++j)
             res+=flip[i][j];
     return res;
 }
 int main()
 {
     //freopen("de.txt","r",stdin);
     while (~scanf("%d%d",&n,&m))
     {
         for (int i=;i<n;++i)
             for (int j=;j<m;++j)
             cin>>map[i][j];
         int res=inf;
         memset(ans,,sizeof ans);
         for (int i=;i< <<m;++i)//用二进制的方法表示状态
         {
             memcpy(flip,map,sizeof map);
             memset(preans,,sizeof preans);
             int temp=calc(i);
             if (temp<res)//更新最少的ans状态
             {
                 res=temp;
                 for (int i=;i<n;++i)
                     for (int j=;j<m;++j)
                     ans[i][j]=preans[i][j];
             }
         }
         if (res==inf)
         {
             printf("IMPOSSIBLE\n");
         }
         else
         {
             for (int i=;i<n;++i)
             {
                 for (int j=;j<m;++j)
                 {
                     printf("%d",ans[i][j]);
                     if (j!=m-)
                     printf(" ");
                 }
                 printf("\n");
             }
         }
     }
     return ;
 }

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

讲道理这个题感觉不算dfs，算了无所谓。
题意就是给你一个n*m的图，1表示黑色，0表示白色，你可以翻转一些块，是这个块和它周围的块（上下左右，如果不出界）1变成0，0变成1。
问最少几步，能全变成0，输出翻转了那些块，否则IMPOSSIBLE.
讲一下思路，枚举第一行状态每个块都有翻与不翻两种情况，一共1<<m种状态。
对于上述每一种状态，接下来怎么做？考虑到每翻转一个块，它的上下左右块都受到影响，先按照这个翻转策略：如果这个块的上面的那个块是1那么
就翻转这个块。这样思考每一次都能解决上一行的问题。我们最后只要看一下最后一行是否都是0就行了！
PS：这个题一开始写了发600+ms，结果看还有70ms过的，打开看看用了异或1来模拟状态，后来改了改200+ms过的。
代码如下：