POJ2965 BFS(自己写队列)+状态压缩 OR 偶数格子的棋盘规律

方法1（500多ms），BFS（自己写队列，不用STL，因为速度不够）+状态压缩 

bfs+状态压缩：不能用STL的queue，要自己用数组写一个queue，其次作为记录路径的数组不能放在每一个struct中，这样每一次操作之前复制一遍当前的结构体在此基础上进行操作，不但耗费了很多时间而且相当于保存了每一种路径，这没有必要并且也浪费时空开销。而因为visted数组的存在，保证了每一种状态只出现一次，所以结构体中只存储上一个state，在外面开x和y的数组，存储每一个state的x和y即可。
#include <iostream>
//#include <queue>

using namespace std;
int flag;
struct Boards{
    int state;//等同于下标
    int step;
    int father;
    //int pre_x[20];
    //int pre_y[20];
}board[65536];//下标就是状态
int ini_state;
int pre[65536];//根据father
int pre_x[65536];
int pre_y[65536];
int every_state[16]={4383,8751,17487,34959,4593,8946,17652,35064,7953,12066,20292,36744,61713,61986,62532,63624};
int visted[65536]={0};
int q[65536];
int head=0;
int tail=0;
//queue <struct Boards> q;

void Bfs(){
    board[ini_state].state=ini_state;
    board[ini_state].step=0;
    q[tail++]=ini_state;
    visted[board[ini_state].state]=1;
    while(true){
        int cur_state;
        cur_state=q[head++];
        for(int i=1;i<=4;i++){
            for(int j=1;j<=4;j++){
                //struct Boards next_board=board[cur_state];如果结构体内有数组，复制过来是比较慢的
                struct Boards next_board;
                next_board.state=cur_state^every_state[(i-1)*4+j-1];//异或，不同为1，相同为0，模拟下子。
                if(visted[next_board.state]==1) continue;
                next_board.step=board[cur_state].step+1;
                next_board.father=cur_state;
                pre_x[next_board.state]=i;
                pre_y[next_board.state]=j;
                board[next_board.state]=next_board;///next_board作为中介
                q[tail++]=next_board.state;
                visted[next_board.state]=1;
                if(next_board.state==0){
                    cout<<next_board.step<<endl;
                    int star=0;
                    int star_state=next_board.state;
                    while(star_state!=ini_state){
                        pre[star++]=star_state;
                        star_state=board[star_state].father;
                    }
                    for(int l=star-1;l>=0;l--){
                        cout<<pre_x[pre[l]]<<"  "<<pre_y[pre[l]]<<endl;
                        //cout<<"state:"<<l<<"---"<<next_board.ope_x<<endl;
                    }
                    return ;
                }
            }
        }
    }
    return ;
}
int main()
{

   ///ini
    char piece;
    ini_state=0;
    for(int i=1;i<=4;i++){
        for(int j=1;j<=4;j++){
            cin>>piece;
            if(piece=='+'){
                ini_state|=( 1<<( (i-1)*4+j-1) );// 按位或 |= （转换成二进制，同一位两个数都是0才是0，有一个为1则为1，最后结果再转换为十进制数）相当于 +=
            }
        }
    }

   ///bfs
   Bfs();

    return 0;
}

计算every_state：

int Col(int i,int j){
    int sum=0;
    for(int j2=1;j2<=4;j2++){
        sum+=( (1<<( (i-1)*4+j2-1) ) );
    }
    for(int i2=1;i2<=4;i2++){
        sum+=( (1<<( (i2-1)*4+j-1) ) );
    }
    sum-=( (1<<( (i-1)*4+j-1) ) );
    return sum;
}
void Ini(){
    for(int i=1;i<=4;i++){
        for(int j=1;j<=4;j++){
            every_state[(i-1)*4+j-1]=Col(i,j);
        }
    }
    return ;
}

方法二（30多ms），本质是利用了在棋盘上，下两个点得到的最终结果与下这两个点的顺序无关。其次，在偶数棋盘下，每下一个子，假若在这个子的行、列上的其他点也都下一个子，最终抵消后得到的结果就是，只有这个点下了一个子。所以我们把所有‘+’的点以及这个点的行、列上的所有点下一次，那么必然得到全部为‘-’的棋盘。而重复下偶数次的地方是相当于下一次，重复下奇数次的地方相当于下一次。那么前后的思想就是，把所有步数下出来，然后去重。 

#include <iostream>

using namespace std;
int mmat[5][5]={0};
int x[20];
int y[20];
void Flip(int x,int y){
    for(int i=1;i<=4;i++){
        mmat[i][y]++;
    }
    for(int j=1;j<=4;j++){
        mmat[x][j]++;
    }
    mmat[x][y]--;
}
int main(){
    char check;
    int sum=0;
    //cout<<mmat[1][2]<<endl;
    for(int i=1;i<=4;i++){
        for(int j=1;j<=4;j++){
            cin>>check;
            if(check=='+'){
                Flip(i,j);
            }

        }
    }
    for(int i=1;i<=4;i++){
        for(int j=1;j<=4;j++){
            mmat[i][j]%=2;
            if(mmat[i][j]){
                sum+=mmat[i][j];
                x[sum]=i;
                y[sum]=j;
            }

        }
    }
    cout<<sum<<endl;
    for(int i=1;i<=sum;i++){
        cout<<x[i]<<"  "<<y[i]<<endl;
    }
}