poj 2965

本来觉得和1753非常相似，但总是TLE，不知为何。讨论区里有高效解法，很神！贴过来学习。

我的代码：

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <queue>


using namespace std;


int table[16] = {1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768};


int flipPosition(int id,int position)
{
    id ^= table[position];


    for(int i = position - 4;i >= 0;i -= 4)
        id ^= table[i];


    for(int i = position + 4;i <= 15;i += 4)
        id ^= table[i];


    for(int i = position - 1;(i + 4) % 4 != 3;--i)
        id ^= table[i];


    for(int i = position + 1;i % 4 != 0;++i)
        id ^= table[i];


    return id;
}


int main()
{
    freopen("a.txt","w",stdout);


    /*char c;
    int id = 0;
    for(int i = 0;i < 16;i++)
    {
        scanf("%c",&c);
        if(c == '\n')
            scanf("%c",&c);


        int newSite;
        if(c == '-')
            newSite = 0;
        else
            newSite = 1;
        if(newSite)
            id += (newSite << i);
    }*/


    int id = 0;
    for(;id < 65536;id++)
    {
        int state[65536];//记录遍历高度
        memset(state,-1,sizeof(state));


        int flip[65536];//记录由谁翻过来的
        memset(flip,-1,sizeof(flip));


        state[id] = 0;
        flip[id] = 0;
        queue<int> ids;
        ids.push(id);


        int over = 0;
        while(!ids.empty())
        {
            int nowId = ids.front();
            ids.pop();
            for(int i = 0;i < 16;i++)
            {
                int nextId = flipPosition(nowId,i);


                if(nextId == 0)
                {
                    printf("%d\n",state[nowId] + 1);


                    int pos[65536];
                    memset(pos,-1,sizeof(pos));


                    int step = state[nowId] + 1;
                    int j;
                    for(j = 0;j < step;j++)
                    {
                        pos[j] = i;
                        i = flip[nowId];
                        if(j != step - 1)
                            nowId = flipPosition(nowId,i);
                    }


                    for(j = step - 1;j >= 0;j--)
                    {
                        printf("%d %d\n",pos[j] / 4 + 1,pos[j] % 4 + 1);
                    }
                    over = 1;
                    break;
                }


                if(state[nextId] == -1)
                {
                    state[nextId] = state[nowId] + 1;
                    flip[nextId] = i;
                    ids.push(nextId);
                }
            }
            if(over)
                break;
        }
    }


    return 0;
}

根本过不了。。。

高效解法：

先看一个简单的问题,如何把'+'变成'-'而不改变其他位置上的状态?答案是将该位置(i,j)及位置所在的行(i)和列(j)上所有的handle更新一次,结果该位置被更新了7次,相应行(i)和列(j)的handle被更新了6次,剩下的被更新了4次.被更新偶数次的handle不会造成最终状态的改变.因此得出高效解法,在每次输入碰到'+'的时候,自增该位置与相应的行和列,当输入结束后,遍历数组,所有为奇数的位置则是操作的位置,而奇数位置的个数之和则是最终的操作次数.

或者说：

参考高手的高效解法：
> 证明:要使一个为'+'的符号变为'-',必须其相应的行和列的操作数为奇数;可以证明,如果'+'位置对应的行和列上每一个位置都进行一次操作,则整个图只有这一'+'位置的符号改变,其余都不会改变.
> 设置一个4*4的整型数组,初值为零,用于记录每个点的操作数,那么在每个'+'上的行和列的的位置都加1,得到结果模2(因为一个点进行偶数次操作的效果和没进行操作一样,这就是楼上说的取反的原理),然后计算整型数组中一的
> 个数即为操作数,一的位置为要操作的位置(其他原来操作数为偶数的因为操作并不发生效果,因此不进行操作)
*********************************
此上证其可以按以上步骤使数组中值都为‘-’
********************************
在上述证明中将所有的行和列的位置都加1后，在将其模2之前,对给定的数组状态，将所有的位置操作其所存的操作数个次数，举例，如果a[i][j]==n,则对（i,j）操作n次，当所有的操作完后，即全为‘-’的数组。
其实就是不模2的操作，作了许多的无用功。
以上的操作次序对结果无影响，如果存在一个最小的步骤，则此步骤一定在以上操作之中。（简单说下：因为以上操作已经包含了所有可改变欲改变位置的操作了）
而模2后的操作是去掉了所有无用功之后的操作，此操作同样包含最小步骤。
但模2后的操作去掉任何一个或几个步骤后，都不可能再得到全为‘-’的。（此同样可证明：因为操作次序无影响，先进行最小步骤，得到全为‘-’，如果还剩下m步，则在全为‘-’的数组状态下进行这m步操作后还得到一个全为
‘-’的数组状态，此只能是在同一个位置进行偶数次操作，与前文模2后矛盾，所以m=0），因此模2后的操作即为最小步骤的操作。

#include <iostream>
using namespace std;

bool mark[4][4];
char s[4][4];

int main()
{
    int i,j,k;
    int ci[16],cj[16];
    int nas = 0;
    memset(mark,0,sizeof(mark));
	for(i = 0;i < 4;i++)
		cin >> s[i];
    for(i = 0;i < 4;i++)
        for(j = 0;j < 4;j++)
        {
            char c = s[i][j];
            if(c == '+')
            {
                mark[i][j] = !mark[i][j];
                for(k = 0;k < 4;k++)
                {
                    mark[i][k] = !mark[i][k];
                    mark[k][j] = !mark[k][j];
                }
            }

        }
    for(i = 0;i < 4;i++)
        for(j = 0;j < 4;j++)
            if(mark[i][j] == true)
            {
                ci[nas] = i + 1;
                cj[nas] = j + 1;
                nas ++;
            }
    printf("%d\n",nas);
    for(i = 0;i < nas;i++)
    {
        printf("%d %d\n",ci[i],cj[i]);
    }
    return 0;
}