loj 1165(bfs+康托展开）

题目链接：http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=26879

思路：题目意思很简单，就是通过一些位置的交换，最后变成有序数列，对于一组序列，我们可以用康托展开然后hash判重。

然后就是普通的bfs,稍微留意一下细节即可。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
int is_prime[]={0,0,1,1,0,1,0,1,0,0,0,1,0,1,0,0,0,1};
int fac[]={1,1,2,6,24,120,720,5040,40320};

struct Point{
    int num,flag;
};

struct Node{
    Point state[10];
    int step;
}st;

bool mark[400000];

int Get_Hash(Node &node)
{
    int a[10],val=0,cnt;
    for(int i=0;i<8;i++)a[i]=abs(node.state[i].num);
    for(int i=0;i<8;i++){
        cnt=0;
        for(int j=0;j<i;j++){
            if(a[j]>a[i])cnt++;
        }
        val+=cnt*fac[i];
    }
    return val;
}

bool Judge(Node &node)
{
    for(int i=0;i<7;i++){
        if(abs(node.state[i].num)>abs(node.state[i+1].num))
            return false;
    }
    return true;
}

Node Get_Node(Node &p,int pos1,int pos2,int dir)
{
    //pos1->pos2 left
    if(dir==0){
        if(pos1<pos2){
            int tmp=p.state[pos1].num,flag=p.state[pos1].flag;
            for(int i=pos1;i<=pos2-2;i++){
                p.state[i].num=p.state[i+1].num;
                p.state[i].flag=p.state[i+1].flag;
            }
            p.state[pos2-1].num=tmp;
            p.state[pos2-1].flag=flag;
        }else {
            int tmp=p.state[pos1].num,flag=p.state[pos1].flag;
            for(int i=pos1;i>pos2;i--){
                p.state[i].num=p.state[i-1].num;
                p.state[i].flag=p.state[i-1].flag;
            }
            p.state[pos2].num=tmp,p.state[pos2].flag=flag;
        }
    }else if(dir==1){   //pos1->pos2 right
        if(pos1<pos2){
            int tmp=p.state[pos1].num,flag=p.state[pos1].flag;
            for(int i=pos1;i<=pos2-1;i++){
                p.state[i].num=p.state[i+1].num;
                p.state[i].flag=p.state[i+1].flag;
            }
            p.state[pos2].num=tmp,p.state[pos2].flag=flag;
        }else {
            int tmp=p.state[pos1].num,flag=p.state[pos1].flag;
            for(int i=pos1;i>=pos2+2;i--){
                p.state[i].num=p.state[i-1].num;
                p.state[i].flag=p.state[i-1].flag;
            }
            p.state[pos2+1].num=tmp,p.state[pos2+1].flag=flag;
        }
    }
    return p;
}


void bfs()
{
    memset(mark,false,sizeof(mark));
    queue<Node>que;
    que.push(st);
    mark[Get_Hash(st)]=true;
    while(!que.empty()){
        Node q,pp,p=que.front();
        que.pop();
        if(Judge(p)){
            printf("%d\n",p.step);
            return ;
        }
        for(int i=0;i<8;i++){
            for(int j=0;j<8;j++)if(i!=j){
                if(p.state[i].flag!=p.state[j].flag&&is_prime[abs(p.state[i].num)+abs(p.state[j].num)]){
                    for(int k=0;k<2;k++){
                        pp=p;
                        q=Get_Node(pp,i,j,k);
                        int val=Get_Hash(q);
                        q.step=p.step+1;
                        if(!mark[val]){
                            mark[val]=true;
                            que.push(q);
                        }
                    }
                }
            }
        }
    }
    puts("-1");
}


int main()
{
    int _case,t=1;
    scanf("%d",&_case);
    while(_case--){
        for(int i=0;i<8;i++){
            scanf("%d",&st.state[i].num);
            st.state[i].flag=(st.state[i].num>0?1:-1);
        }
        st.step=0;
        printf("Case %d: ",t++);
        bfs();
    }
    return 0;
}