poj 3221 六边形上的广搜 反向广搜所有状态 哈希映射

题目要求从目标状态变到终点状态至少需要几步，数据较小，而且终点状态是一样的，

所以直接从终点状态开始反向广搜，把所有的状态都搜出来记录一下就好了

记录状态可以用哈希，把一个状态映射成一个7进制的数同时用一个数组记录一下所走的步数

广搜的方向

#include<cstdio>
#include<queue>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<iostream>
using namespace std;
int head[10];
int tot=0;
bool vis[6000000];
int step[6000000];
struct EDGE{
    int v,next;
}edge[50];
struct node {
    int g[7];
    int s;
}q[100000],tnode;
void add(int s,int t)
{
    edge[tot].v=t;
    edge[tot].next=head[s];
    head[s]=tot++;
}
int Hash(node x)
{
    int sum=0;
    for(int i=0;i<7;i++)
        sum=sum*7+x.g[i];
    return sum;
}
void bfs()
{
    memset(vis,false,sizeof(false));
    queue<node> Q;
    int i;
    for(i=0;i<7;i++)
        tnode.g[i]=i;
    int tmp=Hash(tnode);
    vis[tmp]=true;
    tnode.s=0;
    step[tmp]=0;
    Q.push(tnode);
    while(!Q.empty())
    {
        node st=Q.front();Q.pop();
        int s;
        for(i=0;i<7;i++)
        {
            if(st.g[i]==0)
            {
                s=i;
            break;
            }
        }
        for(i=head[s];i!=-1;i=edge[i].next)
        {
            int t=edge[i].v;
            node tt=st;
            swap(tt.g[s],tt.g[t]);
            tmp=Hash(tt);
            if(!vis[tmp])
            {
                vis[tmp]=true;
                step[tmp]=tt.s=tt.s+1;
                Q.push(tt);
            }
        }
    }
}
void init()
{
    memset(head,-1,sizeof(head));
    memset(step,-1,sizeof(step));
    int a[]={0,1,2,1,6,0,2,0,4,0,6,2,1,2,3,2,0,3,2,3,4,4,0,4,3,4,5,5,6,5,4,6,0,6,1,6,5};
    for(int i=1;i<=36;i++)
    {
       if(i%2==1)
         add(a[i],a[i+1]);
    }
}
int main()
{
    init();
    bfs();
    int n,i;
    char s[10];
    scanf("%d",&n);
    while(n--)
    {
        scanf("%s",s);
        for(i=0;i<=6;i++)
        {
            tnode.g[i]=s[i]-'0';
        }
        printf("%d\n",step[Hash(tnode)]);
    }
    return 0;
}

题目中已经有提示了