hdu 1401 Solitaire 双向bfs

#include <cstdio>
#include <cstring>
#include <cmath>
#include <string>
#include <queue>
#include <iostream>
#include <algorithm>
using namespace std;
#define LL __int64
struct point{
    int a,b;
};
struct node{
    point f[4];
    int num;
};
char vis[8][8][8][8][8][8][8][8];
int map[8][8];
int dir[4][2]={{-1,0},{0,-1},{1,0},{0,1}};
int cmp(point x,point y)
{
    if(x.a==y.a)
        return x.b<y.b;
    return x.a<y.a;
}
void work(node aa,char bb)
{
    vis[aa.f[0].a][aa.f[0].b][aa.f[1].a][aa.f[1].b][aa.f[2].a][aa.f[2].b][aa.f[3].a][aa.f[3].b]=bb;
}
int visit(node aa)
{
    return vis[aa.f[0].a][aa.f[0].b][aa.f[1].a][aa.f[1].b][aa.f[2].a][aa.f[2].b][aa.f[3].a][aa.f[3].b];
}
int bfs(node aa,node bb)
{
    int i,j,k,xx,yy;
    node u,v,e,g;
    memset(vis,0,sizeof(vis));
    queue<node>q;
    aa.num=0;
    work(aa,'1');
    work(bb,'2');
    q.push(aa);
    while(!q.empty())
    {
        e=q.front();
        q.pop();
        if(e.num==4)break;
        memset(map,0,sizeof(map));
        map[e.f[0].a][e.f[0].b]=map[e.f[1].a][e.f[1].b]=1;
        map[e.f[2].a][e.f[2].b]=map[e.f[3].a][e.f[3].b]=1;
        for(i=0;i<4;i++)
        {
            for(j=0;j<4;j++)
            {
                xx=e.f[i].a+dir[j][0];
                yy=e.f[i].b+dir[j][1];
                if(xx<0||yy<0||xx>=8||yy>=8)continue;
                if(map[xx][yy])
                {
                    xx+=dir[j][0];
                    yy+=dir[j][1];
                    if(xx<0||yy<0||xx>=8||yy>=8)continue;
                }
                u=e;
                u.f[i].a=xx;u.f[i].b=yy;
                sort(u.f,u.f+4,cmp);
                if(visit(u)=='1')continue;
                if(visit(u)=='2')return 1;
                work(u,'1');
                u.num=e.num+1;
                q.push(u);
            }
        }
    }
    while(!q.empty())q.pop();
    bb.num=0;
    q.push(bb);
    while(!q.empty())
    {
        e=q.front();
        q.pop();
        if(e.num==4)break;
        memset(map,0,sizeof(map));
        map[e.f[0].a][e.f[0].b]=map[e.f[1].a][e.f[1].b]=1;
        map[e.f[2].a][e.f[2].b]=map[e.f[3].a][e.f[3].b]=1;
        for(i=0;i<4;i++)
        {
            for(j=0;j<4;j++)
            {
                xx=e.f[i].a+dir[j][0];
                yy=e.f[i].b+dir[j][1];
                if(xx<0||yy<0||xx>=8||yy>=8)continue;
                if(map[xx][yy])
                {
                    xx+=dir[j][0];
                    yy+=dir[j][1];
                    if(xx<0||yy<0||xx>=8||yy>=8)continue;
                }
                u=e;
                u.f[i].a=xx;u.f[i].b=yy;
                sort(u.f,u.f+4,cmp);
                if(visit(u)=='2')continue;
                if(visit(u)=='1')return 1;
                work(u,'2');
                u.num=e.num+1;
                q.push(u);
            }
        }
    }
    return -1;
}
int main()
{
    int a,b;
    node x,y;
    while(cin>>a>>b)
    {
        int i,j,k;
        x.f[0].a=a-1;
        x.f[0].b=b-1;
        for(i=1;i<4;i++)
        {
            cin>>a>>b;
            x.f[i].a=a-1;
            x.f[i].b=b-1;
        }
        for(i=0;i<4;i++)
        {
            cin>>a>>b;
            y.f[i].a=a-1;
            y.f[i].b=b-1;
        }
        int ans=bfs(x,y);
        if(ans==-1)cout<<"NO"<<endl;
        else cout<<"YES"<<endl;
    }
}
/*
    如果不考虑双向，这题就是一道普通的bfs题，只不过有四个棋子，每个可以上下左右移动，所以需要有16种状态。
而状态需要用8维数组vis存，8^8=2^24,1.6*10^7,用int话，内存不够，所以用char节约空间。
    双向bfs：又本题知道起点终点，可以正反向一起推，每个动4次，共8次，如果出现4点相遇，则可以到达终点。这样
可以减少很多浪费，不至于超时和超空间。单向的最坏情况，可以有16^8=2^32=2*10^9次，而双向16^4*2=2^17=10^5
*/