BZOJ 1647 [Usaco2007 Open]Fliptile 翻格子游戏：部分枚举 位运算

题目链接：http://www.lydsy.com/JudgeOnline/problem.php?id=1647

题意：

　　在一个n*m(1 <= n,m <= 15)的棋盘上，每一个格子里都有一个可以翻转的棋子。

　　棋子的一面是黑色，一面是白色。

　　若翻转一个棋子，则它周围的四个棋子也会被翻转。

　　问你最少需要多少次翻转，使所有的棋子都变成白面向上。

　　如果可以做到，输出字典序最小的结果（将结果当成字符串处理）。如果不能做到，输出“IMPOSSIBLE”。

题解：

　　首先有一个结论：

　　　　如果第i-1行第j列的棋子为黑，那么第i行j列的棋子一定会被翻转，因为只有这样上一行的黑棋子才能变成白棋子。

　　　　所以，如果上一行的棋子状态已经确定，那么当前行的翻转方案是唯一确定的。

　　因此，如果第1行的棋子状态确定，接下来2到n行的方案也都唯一确定了。

　　所以只用枚举第1行的棋子状态，复杂度O(2^15)。

　　注：如果用状态压缩state枚举表示第一行的状态的话，state的第0位代表棋盘的第m-1列。

　　　　因为要按字典序从小到大枚举。

AC Code:

 #include <iostream>
 #include <stdio.h>
 #include <string.h>
 #define MAX_N 20
 #define INF 10000000

 using namespace std;

 const int dx[]={-,,,};
 const int dy[]={,,-,};

 int n,m;
 int a[MAX_N][MAX_N];
 int t[MAX_N][MAX_N];
 int cnt[MAX_N][MAX_N];
 int ans[MAX_N][MAX_N];
 bool failed=false;

 void read()
 {
     cin>>n>>m;
     for(int i=;i<n;i++)
     {
         for(int j=;j<m;j++)
         {
             cin>>a[i][j];
         }
     }
 }

 inline bool is_legal(int x,int y)
 {
     return x>= && x<n && y>= && y<m;
 }

 void solve()
 {
     int minn=INF;
     for(int state=;state<(<<m);state++)
     {
         memset(cnt,,sizeof(cnt));
         memcpy(t,a,sizeof(int)*MAX_N*MAX_N);
         int tot=;
         for(int j=;j<m;j++)
         {
             int pos=m-j-;
             if((state>>pos)&)
             {
                 t[][j]^=;
                 cnt[][j]=;
                 tot++;
                 for(int k=;k<;k++)
                 {
                     int x=dx[k];
                     int y=j+dy[k];
                     if(is_legal(x,y)) t[x][y]^=;
                 }
             }
         }
         for(int i=;i<n;i++)
         {
             for(int j=;j<m;j++)
             {
                 if(t[i-][j])
                 {
                     t[i][j]^=;
                     cnt[i][j]=;
                     tot++;
                     for(int k=;k<;k++)
                     {
                         int x=i+dx[k];
                         int y=j+dy[k];
                         if(is_legal(x,y)) t[x][y]^=;
                     }
                 }
             }
         }
         bool is_white=true;
         for(int j=;j<m;j++)
         {
             if(t[n-][j])
             {
                 is_white=false;
                 break;
             }
         }
         if(is_white && tot<minn)
         {
             memcpy(ans,cnt,sizeof(int)*MAX_N*MAX_N);
             minn=tot;
         }
     }
     if(minn==INF) failed=true;
 }

 void print()
 {
     if(failed)
     {
         cout<<"IMPOSSIBLE"<<endl;
         return;
     }
     for(int i=;i<n;i++)
     {
         for(int j=;j<m;j++)
         {
             cout<<ans[i][j];
             if(j!=m-) cout<<" ";
         }
         cout<<endl;
     }
 }

 int main()
 {
     read();
     solve();
     print();
 }