POJ -3279 Fliptile(二进制枚举， 搜索）

POJ 3279

题目大意：

有一个 M * N 的格子，每个格子可以翻转正反面，它们有一面是黑色，另一面是白色。黑色翻转之后变成白色，白色翻转之后则变成黑色。游戏要做的是把所有的格子翻转为白色。不过因为牛蹄很大，所以每次翻转一个格子，与它上下左右相邻接的格子也会被翻转。求用最小的步数完成时，每个格子的翻转次数。最小步数的解有多个时，输出字典序最小的一组；解不存在的话，则输出IMPOSSIBLE

分析：

第一眼就能看到的暴力的做法是遍历所有的可能，也就是每个格子都有两种可能：翻与不翻，这样时间复杂度为O(2^n*m)，显然超时。因此我们换一种思维，如果确定第一行的开关操作，那么每一行都可以由上一行确定，原因是（一个格子被翻只有两种可能，1.翻这个格子 2.翻她上面的格子），如果第 i 行操作确定，那么第 i 行状态也已经确定，那么为了让第 i 行还没有变白的格子变白，就必须翻她正下方的格子，也就是说，第i+1 行操作确定了，循环，最后判断一下最后一行的状态即可。此时复杂度降到了O(2^n)，只枚举第一行所有状态。

值得注意的是，题目要求输出字典序的最优解，所以要将第一行状态按字典序枚举，有一个小技巧，在代码里可以看到。

#include <cstdio>
#include <vector>
#include <queue>
#include <cstring>
#include <cmath>
#include <map>
#include <set>
#include <string>
#include <iostream>
#include <algorithm>
#include <functional>
#include <stack>
#include <ctime>
#include <cstdlib>
//#pragma comment (linker, "/STACK:256000000")
using namespace std;
#define db(x) cout<<x<<endl

typedef long long ll;
const int N = 15 + 10;
const int INF = 0x3f3f3f;

int n, m;
int ori[N][N], tem[N][N];
int oper[N][N], ans[N][N];
int step = 0, minstep = INF;

void press(int x, int y) //异或两次同一个数，等于没有异或。
{
    tem[x][y] ^= 1;
    tem[x+1][y] ^= 1;
    tem[x-1][y] ^= 1;
    tem[x][y+1] ^= 1;
    tem[x][y-1] ^= 1;
}

bool solve()	//按第一行操作遍历全图
{
    memcpy(tem, ori, sizeof(ori));
    for (int i = 1; i <= n; i++){
        if(oper[1][i]){
            press(1, i);
            step++;
        }
    }

    for(int i = 2; i <= m; i++){
        for (int j = 1; j <= n; j++){
            if(tem[i-1][j]){
                oper[i][j] = 1;
                press(i, j);
                step++;
            }
        }
    }
    for (int i = 1; i <= n; i++){
        if(tem[m][i])
            return 0;
    }
    return 1;
}
int main()
{
    scanf("%d%d", &m, &n);
    for (int i = 1; i <= m; i++){
        for (int j = 1; j <= n; j++){
            scanf("%d", &ori[i][j]);
        }
    }
    for (int i = 0; i < (1 << n); i++){	//枚举第一行状态，按字典序枚举
        memset(oper, 0, sizeof(oper));
        step = 0;
        for (int j = 0; j < n; j++){
            oper[1][n - j] = (i >> j & 1);
        }
        if(solve() && step > 0 && step < minstep){	//判断是否有解及更新最优解
            minstep = step;
            memcpy(ans, oper, sizeof(oper));
        }
    }
    if(minstep < INF){
        for (int i = 1; i <= m; i++){
            for(int j = 1; j <= n; j++){
                printf("%d ", ans[i][j]);
            }
            printf("\n");
        }
    }else{
        printf("IMPOSSIBLE\n");
    }
    return 0;
}

// n = 5;
// int x[n][n];
// for (int i = 0; i < (1 << n); i++)
// {
//     for (int j = 0; j < n; j++)
//     {
//         x[1][n - j] = (i >> j & 1);
//     }
//     for (int k = 1; k <= n; k++)
//     {
//         cout << x[1][k] << " ";
//     }
//     cout << endl;
// }