魔板[S]

好的分层思想会使代码简单许多。
用了康拓展开，再次感觉到了数学的力量。
bfs的判定边界条件的时候，一般可以分为在得到新的状态的时候判定是否重复，也可以在拿出来的时候判定。总体而言在得到的时候判定会减少一层判定树的高度，但是要额外注意最开始的初始情况。
在TSOj中由于不能用stl中的数据，即必须自己手写队列，保存状态等，但是可以用stl的时候用简单了不少。

#include <stdio.h>
#include <string>
#include <string.h>
#include <iostream>
#include <queue>
using namespace std;
int const maxn = 100000;
int fact[8]={1,1,2,6,24,120,720,5040};
int g_n;
int g_ch[2][4];
int vis[maxn];
struct board {
    int val;
    int ch[2][4];
    string operation;
    int GetHash() {
        int tmp[8],pt=0;
        for (int i=0;i<2;i++) 
         for (int j=0;j<4;j++) {
            tmp[pt++] = this->ch[i][j];
         }
         int gval=0;
         for(int i=0;i<8;i++) {
            int rank = 0;
            for (int j=i+1;j<8;j++) {
                if(tmp[i]>tmp[j])  rank++;
            }
            gval+=rank*fact[7-i];
         }
         this->val = gval;
         return gval;
    }
    board operate(int i) {
         board l_tmp;
         switch (i) {
            case 0:
                for (int i=0;i<2;i++) {
                    for (int j=0;j<4;j++) {
                         l_tmp.ch[i][j] = this->ch[1-i][j]; 
                    }
                }
                 l_tmp.GetHash();
                 l_tmp.operation = this->operation + "A";
                 return l_tmp;
             case 1:
                for(int i=0;i<2;i++) {
                    for (int j=0;j<4;j++) {
                        l_tmp.ch[i][(j+1)%4] = this->ch[i][j];
                    }
                }
                 l_tmp.GetHash();
                 l_tmp.operation = this->operation + "B";
                 return l_tmp;
             case 2:
                for(int i=0;i<2;i++) {
                    for (int j=0;j<4;j++) {
                        l_tmp.ch[i][j] = this->ch[i][j];
                    }
                }
                l_tmp.ch[0][1] = this->ch[1][1];
                l_tmp.ch[0][2] = this->ch[0][1];
                l_tmp.ch[1][1] = this->ch[1][2];
                l_tmp.ch[1][2] = this->ch[0][2];
                 l_tmp.GetHash();
                 l_tmp.operation = this->operation + "C";
                 return l_tmp;
         }

    }
};

bool match(board tmp) {
    for (int i=0;i<2;i++) {
        for (int j=0;j<4;j++) {
            if(tmp.ch[i][j]!=g_ch[i][j]) return false;
        }
    }
    return true;
}

void bfs() {
    board tmp;
    for (int i=0;i<4;i++) {
       tmp.ch[0][i]=i+1;
       tmp.ch[1][i]=8-i; }
    tmp.operation = "";
    tmp.GetHash();
    memset(vis,0,sizeof(vis));
    if(match(tmp)) {
        cout<<0<<endl;
        return;
    }
    queue<board> Q;
    Q.push(tmp);
    vis[tmp.val] = 1;
    while(!Q.empty()) {
        board l_var = Q.front();
        Q.pop();
        for (int i=0;i<3;i++) {
            board l_tmp = l_var.operate(i);
            if(l_tmp.operation.size()>g_n) {
                cout<<-1<<"\n";
                return ;
            }
            if(match(l_tmp)) {
                cout<<l_tmp.operation.size()<<" "<<l_tmp.operation<<endl;
                return ;
            }

            if(!vis[l_tmp.val]) {
                vis[l_tmp.val]=1;
                Q.push(l_tmp);
            }
        }
    } 
}



int main() {
//  freopen("input.txt","r",stdin);
    while(cin>>g_n&&g_n!=-1) {
        for (int i=0;i<2;i++) 
         for (int j=0;j<4;j++) cin>>g_ch[i][j];
         bfs(); 
    }
    return 0;
}