poj3279
别人的代码，方便学习。

#include <iostream>
#include <cstdio>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <set>
#include <sstream>
#define mod 1000000007
#define eps 1e-6
#define ll long long
#define INF 0x3f3f3f3f
#define MEM(x,y) memset(x,y,sizeof(x))
#define Maxn 20
using namespace std;
int result;
int n,m;
int mp[Maxn][Maxn];//原始地图
int tmp[Maxn][Maxn];//当前操作的地图
int ans[Maxn][Maxn];//最优解地图
int dt[][2] = { { -1, 0 }, { 1, 0 }, { 0, 0 }, { 0, -1 }, { 0, 1 } };//5个方向
int getcolor(int x,int y)//得到(x,y)的颜色
{
    int cnt=mp[x][y];
    for(int i=0; i<5; i++)
    {
        int tx=dt[i][0]+x;
        int ty=dt[i][1]+y;
        if(tx>=0&&tx<n&&ty>=0&&ty<m)
            cnt+=tmp[tx][ty];
    }
    return cnt%2;
}
int solve()
{
    int cnt=0;
    for(int i=1; i<n; i++)//从第二行开始检查是否需要翻转
        for(int j=0; j<m; j++)
            if(getcolor(i-1,j))
                tmp[i][j]=1;
    for(int i=0; i<m; i++)//检查最后一行是否全为0
        if(getcolor(n-1,i))
            return INF;
    for(int i=0; i<n; i++)//统计翻转次数
        for(int j=0; j<m; j++)
            cnt+=tmp[i][j];
    return cnt;
}
int main()
{
    result=INF;
    cin>>n>>m;
    for(int i=0; i<n; i++)
        for(int j=0; j<m; j++)
            cin>>mp[i][j];
    for(int i=0; i<1<<m; i++)//按照字典序枚举第一行所以翻转可能
    {
        MEM(tmp,0);//初始化地图
        for(int j=0; j<m; j++)
            tmp[0][j]= i>>(m-(j+1)) & 1;//第一行的状态
        int sum=solve();//翻转的次数
        if(sum<result)//更新地图
        {
            result=sum;
            memcpy(ans,tmp,sizeof tmp);//tmp数组复制到ans
        }
    }
    if(result==INF)
        cout<<"IMPOSSIBLE"<<endl;
    else//输出
    {
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<m; j++)
                cout<<ans[i][j]<<" ";
            cout<<endl;
        }
    }
}

附上自己的代码：（虽然差别不大+自己的理解）
先确定第一行的每一个是否翻转，该过程用二进制枚举的方法，因为每个位置只有0和1两种状态。
然后根据第一行的状态，对第二行的对应的每个格子是否翻转，其上一行的对应的格子的当前状态取决自己的原始状态和作为位置的是否翻转，自己是否翻转，并由其下一行的位置是否翻转来最终决定。
以此类推，直到处理到最后一行。
然后通过判断最后一行是否全为0来判断该方法是否可行。
如果可行，扫一遍当前的矩阵，记录翻转次数。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int g[20][20],tmp[20][20],ans[20][20];//方便用于保存原图，当前的答案，最终的答案
int dir[5][2]={{0,0},{1,0},{-1,0},{0,1},{0,-1}};
const int inf=0x3f3f3f3f;
int m,n;
void cpy()
{
    for(int i=0;i<m;i++)
        for(int j=0;j<n;j++)
            ans[i][j]=tmp[i][j];
}
int check(int x,int y)
{
    int cnt=g[x][y];//该格子的状态取决于其初始状态，自己是否翻转，作为是否翻转
    for(int i=0;i<5;i++)//包括自己五个格子
    {
        int tx=x+dir[i][0];
        int ty=y+dir[i][1];
        if(tx>=0&&tx<m&&ty>=0&&ty<n)
            cnt+=tmp[tx][ty];
    }
    return cnt%2;//经过多次翻转后确定最终的状态
}
int solve()
{
    int cnt=0;
    for(int i=1;i<m;i++)
    {
        for(int j=0;j<n;j++)
        if(check(i-1,j)==1)//每次pduan对当前的格子的状态进行判断是否翻转，根据其上一行的对应格子的状态
            tmp[i][j]=1;
    }
    for(int i=0;i<n;i++)
    {
        if(check(m-1,i)==1)
            return inf;
    }
    for(int i=0;i<m;i++)
        for(int j=0;j<n;j++)
            cnt+=tmp[i][j];
    return cnt;
}
int main()
{
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        memset(g,0,sizeof(g));
        memset(ans,0,sizeof(ans));
        for(int i=0;i<m;i++)
            for(int j=0;j<n;j++)
                scanf("%d",&g[i][j]);
        int res=inf;
        for(int i=0;i<(1<<n);i++)//枚举第一行的所有状态，用该数的二进制形式表示,从小到大枚举，满足字典序要求
        {
            memset(tmp,0,sizeof(tmp));
            for(int j=0;j<n;j++)
                tmp[0][j]=i>>(n-j-1)&1;//从高位开始取各位的值
            int tt=solve();//求解
            if(tt<res)
            {
                res=tt;//保存最小答案
                cpy();//保存最优的矩阵
            }
        }
        if(res<inf)
        {//输出
            for(int i=0;i<m;i++)
                for(int j=0;j<n;j++)
                    printf("%d%c",ans[i][j],j==n-1?'\n':' ');
        }
        else//无解
            printf("IMPOSSIBLE\n");
    }
    return 0;
}

POJ-3276（翻转问题+二分搜索）

POJ-3279（翻转问题+位操作）

POJ-1753（和3279没啥区别！）

POJ-2965