Holedox Moving--POJ 1324

1、题目类型：模拟、贪吃蛇游戏、哈希表、BFS。

2、解题思路：题意，给出活动空间大小、蛇身位置、空间中障碍物位置、目标位置，求解蛇的最少移动步数。难点，用进制的哈希对蛇身相对位置的保存。步骤，（1）根据输入记录Holedox的位置和stones的位置；（2）对Holedox的位置进行哈希状态压缩，哈希加密方式为Staten=Holedox位置的逐一相对位置的4进制*总行数*总列数+总行数*行位置+列位置（解密方式类似）；（3）BFS搜索目标情况，成功解密Holedox‘s head位置为（0,0）返回此时step，否则返回-1。

3、注意事项：哈希的构造方法必须唯一，且在int的控制范围以内否则TLE；BFS中常用变量尽量用全局变量，避免Runtime Error。

4、实现方法:

#pragma warning(disable:4786)
#include<iostream>
#include<queue>
#include<map>
using namespace std;

struct Node
{
    int state;
    int step;
};

Node Q[1000000];
int X[4]={0,1,0,-1};
int Y[4]={1,0,-1,0};
int R,C,L,state;
int sn[9][2],mat[30][30];
bool  vis[6800000];
map<int,int> S;

void Init()
{
    int i,n,a,b;
    for(i=0;i<L;i++)
    {
        scanf("%d%d",&sn[i][0],&sn[i][1]);
        sn[i][0]--;
        sn[i][1]--;
    }
    cin>>n;
    memset(mat,0,sizeof(mat));
    for(i=0;i<n;i++)
    {
        scanf("%d%d",&a,&b);
        a--;
        b--;
        mat[a][b]=1;
    }
    S.clear();
}

//获得Holedox相对位置
int GetDir(int now[2],int pre[2])
{
    if(now[1]==pre[1]+1)
        return 0;
    if(now[1]==pre[1]-1)
        return 2;
    if(now[0]==pre[0]+1)
        return 1;
    if(now[0]==pre[0]-1)
        return 3;
    return 0;
}

bool Judge(int ssn[][2],int sn[][2])
{
    int i;
    if(!(ssn[0][0]>=0&&ssn[0][0]<R&&ssn[0][1]>=0&&ssn[0][1]<C&&mat[ssn[0][0]][ssn[0][1]]==0))
        return false;
    for(i=0;i<L;i++)
    {
        if(ssn[0][0]==sn[i][0]&&ssn[0][1]==sn[i][1])
            return false;
    }
    return true;
} 

int BFS()
{
    int i,j,k,front=0,rear=0;    
    int head[2],tsn[9][2];
    Node tmp;
    memset(vis,0,sizeof(vis));
    tmp.state=state;
    tmp.step=0;
    Q[rear++]=tmp;
    vis[state]=1;
    while(front<rear)
    {
        tmp=Q[front];
        front=(front+1)%1000000;
        head[1]=tmp.state%(C*R)%C;
        head[0]=tmp.state%(C*R)/C;
        state=tmp.state/(C*R);
        sn[0][0]=head[0];
        sn[0][1]=head[1];
        for(i=1;i<L;i++)
        {
            sn[i][0]=sn[i-1][0]+X[state%4];
            sn[i][1]=sn[i-1][1]+Y[state%4];
            state/=4;
        }
        if(head[0]==0&&head[1]==0)
            return tmp.step;
        for(i=0;i<4;i++)
        {
            tsn[0][0]=sn[0][0]+X[i];
            tsn[0][1]=sn[0][1]+Y[i];            
            if(Judge(tsn,sn))
            {
                state=0;
                int s=1;
                for(j=1;j<L;j++)
                {
                    tsn[j][0]=sn[j-1][0];
                    tsn[j][1]=sn[j-1][1];
                }
                for(k=1;k<L;k++)
                {
                    state=state+GetDir(tsn[k],tsn[k-1])*s;
                    s*=4;
                }
                state=state*R*C+tsn[0][0]*C+tsn[0][1];
                if(!vis[state])
                {
                    Node N;
                    N.state=state;
                    N.step=tmp.step+1;
                    vis[state]=1;
                    Q[rear]=N;
                    rear=(rear+1)%1000000;
                }
            }
        }
    }
    return -1;
}

void Solve(int ca)
{
    int i,s=1;
    state=0;
    for(i=1;i<L;i++)
    {
        state=state+GetDir(sn[i],sn[i-1])*s;
        s*=4;
    }
    state=state*R*C+sn[0][0]*C+sn[0][1];
    cout<<"Case "<<ca++<<": ";
    cout<<BFS()<<endl;
}

int main()
{
    int ca=1;
    while(scanf("%d%d%d",&R,&C,&L))
    {
        if(R==0&&C==0&&L==0)
            break;
        Init();
        Solve(ca++);
    }
    return 0;
}