poj 2965 The Pilots Brothers' refrigerator

题意：给出一个4x4的矩阵，只有 + 和 - 两种符号，每一步可以任取一行和一列然后把符号取反，问最少需要多少步把所有符号变成 - 和对应的方案。

分析：可以直接用16位整数，保存矩阵的状态，然后bfs即可。由于要取反一行一列的符号，一个个取反比较费时，预处理一下就好了。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

typedef pair<int,int> pii;
const int inf = 0x3f3f3f3f;
const int N = 70000;
int dis[N], flip[4][4];
int path[N], q[1000000], qin, qout, top = -1;
pii id[N], stk[N];

void init() {
    bool lock[4][4];
    for(int i = 0; i < 4; i++)
        for(int j = 0; j < 4; j++) {
            memset(lock, false, sizeof(lock));
            for(int k = 0; k < 4; k++)
                lock[i][k] = lock[k][j] = true;
            flip[i][j] = 0;
            for(int x = 3; x >= 0; x--)
                for(int y = 3; y >= 0; y--)
                    flip[i][j] = flip[i][j] << 1 | lock[x][y];
        }
}

int input() {
    int sta = 0;
    char s[10];
    for(int i = 0; i < 4; i++) {
        scanf("%s", s);
        for(int j = 0; j < 4; j++) {
            if(s[j] == '+')
                sta |= 1 << ((i << 2) + j);
        }
    }
    return sta;
}

void solve(int s) {
    qin = qout = 0;
    memset(path, -1, sizeof(path));
    memset(dis, inf, sizeof(dis));
    q[qin++] = s;
    dis[s] = 0;

    while(qin != qout) {
        s = q[qout++];
        for(int i = 0; i < 4; i++)
            for(int j = 0; j < 4; j++) {
                int ns = s ^ flip[i][j];
                if(dis[ns] > dis[s] + 1) {
                    dis[ns] = dis[s] + 1;
                    path[ns] = s;
                    id[ns] = pii(i, j);
                    q[qin++] = ns;
                }
            }
    }

    printf("%d\n", dis[0]);
    for(int p = 0; path[p] != -1; p = path[p])
        stk[++top] = id[p];
    while(top != -1)
        printf("%d %d\n", stk[top].first + 1, stk[top].second + 1),
        top--;
}

int main() {
    init();
    solve(input());
    return 0;
}

参考高手的高效解法：

证明:要使一个为’+’的符号变为’-‘,必须其相应的行和列的操作数为奇数;可以证明,如果’+’位置对应的行和列上每一个位置都进行一次操作,则整个图只有这一’+’位置的符号改变,其余都不会改变.
设置一个4*4的整型数组,初值为零,用于记录每个点的操作数,那么在每个’+’上的行和列的的位置都加1,得到结果模2(因为一个点进行偶数次操作的效果和没进行操作一样,这就是楼上说的取反的原理),然后计算整型数组中一的
个数即为操作数,一的位置为要操作的位置(其他原来操作数为偶数的因为操作并不发生效果,因此不进行操作)

---

此上证其可以按以上步骤使数组中值都为‘-’

---

在上述证明中将所有的行和列的位置都加1后，在将其模2之前,对给定的数组状态，将所有的位置操作其所存的操作数个次数，举例，如果a[i][j]==n,则对（i,j）操作n次，当所有的操作完后，即全为‘-’的数组。
其实就是不模2的操作，作了许多的无用功。
以上的操作次序对结果无影响，如果存在一个最小的步骤，则此步骤一定在以上操作之中。（简单说下：因为以上操作已经包含了所有可改变欲改变位置的操作了）
而模2后的操作是去掉了所有无用功之后的操作，此操作同样包含最小步骤。
但模2后的操作去掉任何一个或几个步骤后，都不可能再得到全为‘-’的。（此同样可证明：因为操作次序无影响，先进行最小步骤，得到全为‘-’，如果还剩下m步，则在全为‘-’的数组状态下进行这m步操作后还得到一个全为
‘-’的数组状态，此只能是在同一个位置进行偶数次操作，与前文模2后矛盾，所以m=0），因此模2后的操作即为最小步骤的操作。

#include<stdio.h>

char lock[5];
bool flip[4][4];
int fx[20], fy[20];

int main() {
    for(int i = 0; i < 4; i++) {
        scanf("%s", lock);
        for(int j = 0; j < 4; j++) {
            if(lock[j] == '+') {
                flip[i][j] = !flip[i][j];
                for(int k = 0; k < 4; k++) {
                    flip[i][k] = !flip[i][k];
                    flip[k][j] = !flip[k][j];
                }
            }
        }
    }

    int ans = 0;
    for(int i = 0; i < 4; i++)
        for(int j = 0; j < 4; j++) {
            if(flip[i][j]) {
                fx[ans] = i + 1;
                fy[ans++] = j + 1;
            }
        }

    printf("%d\n", ans);
    for(int i = 0; i < ans; i++)
        printf("%d %d\n", fx[i], fy[i]);

    return 0;
}