hoj 1868 八数码(双广+hash)

据说这题的数据不是很强，直接bfs+hash判重即可过。

这里我打算拿它练习一下双广搜索。

用了两个队列，分别从始态和终态进行bfs。

队列中保存的是每一个状态，每一个状态是用一个一维数组保存的。

hash时，把它转化成一个9位的整数，质数取余，拉链法判重。

hash表开成两维的，分别储存两个队列的搜索结果，同时还保存搜到每一个状态所用的step。

每当向hash表的一维里插入新状态时，判断在另一维的这个位置是否已经访问到，如果已经访问到，则说明相遇了，输出两个step之和即为结果。

其实双广用一个队列也可以实现，注意把两种状态用标记区分开即可。

另外，这题还有两点有注意的地方：

1.如果初状态和末状态的逆序数的奇偶性不同，则无解，直接输出-1。证明方法网上有。

2.如果初状态与末状态一样，直接输出0。不要再用双广，双广的话输出结果会是2(显然)。

双广时，两个队列交替进行扩展，且每次要扩展一层(一圈一圈的向外扩展，直到两个圈相遇)。第一次相遇，获得的一定是最短的路径了。

代码如下：

    #include <iostream>
    #include <cstdio>
    #include <cstring>
    #include <algorithm>
    #include <queue>

    #define PRIME 455809
    using namespace std;

    struct node
    {
        node(unsigned int t)
        {
            s=t;
            next=NULL;
        }
        unsigned int s;
        int step;
        node *next;
    };
    node *hashtable[460000][2];
    struct State
    {
        int map[10];
        int pos;
        int step;
    } states,statee;

    void hinsert(State s,bool ty)
    {
        unsigned int i,st=0;
        for(i=1; i<=9; i++)
            st=st*10+s.map[i];
        node *f=new node(st);
        f->step=s.step;
        f->next=hashtable[st%PRIME][ty];
        hashtable[st%PRIME][ty]=f;
    }
    bool exist(State s,bool ty,int &res)
    {
        unsigned int i,st=0;
        for(i=1; i<=9; i++)
            st=st*10+s.map[i];
        node *f=hashtable[st%PRIME][ty];
        while(f)
        {
            if(f->s==st)
            {
                res=f->step;
                return true;
            }
            f=f->next;
        }
        return false;
    }
    int transfer(State t,queue <State>&Q,bool ty)
    {
        State s;
        int res;
        s=t;
        if((s.pos-3)>0)
        {
            swap(s.map[s.pos],s.map[s.pos-3]);
            s.step++;
            s.pos-=3;
            if(exist(s,!ty,res))
            {
                return (s.step+res);
            }
            if(!exist(s,ty,res))
            {
                Q.push(s);
                hinsert(s,ty);
            }
        }
        s=t;
        if(s.pos+3<10)
        {
            swap(s.map[s.pos],s.map[s.pos+3]);
            s.step++;
            s.pos+=3;
            if(exist(s,!ty,res))
            {
                return (s.step+res);
            }
            if(!exist(s,ty,res))
            {
                Q.push(s);
                hinsert(s,ty);
            }
        }
        s=t;
        if((s.pos+1)%3!=1)
        {
            swap(s.map[s.pos],s.map[s.pos+1]);
            s.step++;
            s.pos+=1;
            if(exist(s,!ty,res))
            {
                return (s.step+res);
            }
            if(!exist(s,ty,res))
            {
                Q.push(s);
                hinsert(s,ty);
            }
        }
        s=t;
        if((s.pos-1)%3!=0)
        {
            swap(s.map[s.pos],s.map[s.pos-1]);
            s.step++;
            s.pos-=1;
            if(exist(s,!ty,res))
            {
                return (s.step+res);
            }
            if(!exist(s,ty,res))
            {
                Q.push(s);
                hinsert(s,ty);
            }
        }
        return 0;
    }

    queue<State>Qs;
    queue<State>Qe;
    int reversenum(State a)
    {
        int res=0;
        for(int i=1; i<=9; i++)
        {
            if(a.map[i]==0)continue;
            for(int j=i-1; j>=1; j--)
            {
                if(a.map[j]>a.map[i])res++;
            }
        }
        return res;
    }
    bool prejudge(State a,State b)
    {
        int t1=reversenum(states);
        int t2=reversenum(statee);
        if((t1+t2)%2!=0)
        {
            printf("-1\n");
            return true;
        }
        bool tflag=0;
        for(int i=1; i<=9; i++)
        {
            if(a.map[i]!=b.map[i])
            {
                tflag=1;
                break;
            }
        }
        if(!tflag)
        {
            printf("0\n");
            return true;
        }
        else return false;
    }
    int main()
    {
        int tcases;
        scanf("%d",&tcases);
        while(tcases--)
        {
            memset(hashtable,0,sizeof(hashtable));
            for(int i=1; i<=9; i++)
            {
                scanf("%d",&states.map[i]);
                if(states.map[i]==0)states.pos=i;
            }
            statee.step=0;
            for(int i=1; i<=9; i++)
            {
                scanf("%d",&statee.map[i]);
                if(statee.map[i]==0)statee.pos=i;
            }
            states.step=0;

            hinsert(states,0);
            hinsert(statee,1);
            if(prejudge(states,statee))continue;

            bool endflag=0;
            while(!Qs.empty())Qs.pop();
            while(!Qe.empty())Qe.pop();
            Qs.push(states);
            Qe.push(statee);
            while(!Qs.empty()||!Qe.empty())
            {
                int ns=Qs.size(); //这个是处于同一层的状态的数量
                int ne=Qe.size();
                if(ns<ne||ne==0) //选择元素个数较少的队列进行扩展
                {
                    for(int i=0; i<ns; i++)//扩展s队列。一次扩展一层，这是双广正确性(得到最优解)的重要保证
                    {
                        State cur;
                        cur=Qs.front();
                        Qs.pop();
                        int res=transfer(cur,Qs,0);
                        if(res)
                        {
                            printf("%d\n",res);
                            endflag=1;
                            break;
                        }
                    }
                }
                else
                {
                    for(int i=0; i<ne; i++)
                    {
                        State cur;
                        cur=Qe.front();
                        Qe.pop();
                        int res=transfer(cur,Qe,1);
                        if(res)
                        {
                            printf("%d\n",res);
                            endflag=1;
                            break;
                        }
                    }
                }
                if(endflag)break;
            }
        }
        return 0;
    }