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[]={-1,1,0,0};
const int dy[]={0,0,-1,1};

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=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            cin>>a[i][j];
        }
    }
}

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

void solve()
{
    int minn=INF;
    for(int state=0;state<(1<<m);state++)
    {
        memset(cnt,0,sizeof(cnt));
        memcpy(t,a,sizeof(int)*MAX_N*MAX_N);
        int tot=0;
        for(int j=0;j<m;j++)
        {
            int pos=m-j-1;
            if((state>>pos)&1)
            {
                t[0][j]^=1;
                cnt[0][j]=1;
                tot++;
                for(int k=0;k<4;k++)
                {
                    int x=dx[k];
                    int y=j+dy[k];
                    if(is_legal(x,y)) t[x][y]^=1;
                }
            }
        }
        for(int i=1;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(t[i-1][j])
                {
                    t[i][j]^=1;
                    cnt[i][j]=1;
                    tot++;
                    for(int k=0;k<4;k++)
                    {
                        int x=i+dx[k];
                        int y=j+dy[k];
                        if(is_legal(x,y)) t[x][y]^=1;
                    }
                }
            }
        }
        bool is_white=true;
        for(int j=0;j<m;j++)
        {
            if(t[n-1][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=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            cout<<ans[i][j];
            if(j!=m-1) cout<<" ";
        }
        cout<<endl;
    }
}

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