HDU_1401——同步双向BFS,八进制位运算压缩,map存放hash

这个速度比分步快一点，内存占的稍微多一点

Problem Description

Solitaire is a game played on a chessboard 8x8. The rows and columns of the chessboard are numbered from 1 to 8, from the top to the bottom and from left to right respectively. There are four identical  pieces on the board. In one move it is allowed to: > move a piece to  an empty neighboring field (up, down, left or right), > jump over one  neighboring piece to an empty field (up, down, left or right).There are 4 moves  allowed for each piece in the configuration shown above. As an example let's  consider a piece placed in the row 4, column 4. It can be moved one row up, two  rows down, one column left or two columns right. Write a program  that: > reads two chessboard configurations from the standard  input, > verifies whether the second one is reachable from the first  one in at most 8 moves, > writes the result to the standard  output.

 

Input

Each of two input lines contains 8 integers a1, a2,  ..., a8 separated by single spaces and describes one configuration of pieces on  the chessboard. Integers a2j-1 and a2j (1 <= j <= 4) describe the position  of one piece - the row number and the column number respectively. Process to the  end of file.

 

Output

The output should contain one word for each test case -  YES if a configuration described in the second input line is reachable from the  configuration described in the first input line in at most 8 moves, or one word  NO otherwise.

 

Sample Input

4 4 4 5 5 4 6 5 2 4 3 3 3 6 4 6

 

Sample Output

YES

#include <iostream>
#include <algorithm>
#include <queue>
#include <map>
using namespace std;

const int dir[4][2] = {1,0,-1,0,0,1,0,-1};

struct point
{
    int x,y;
};
struct node
{
    point chess[4];
    
    bool check(int j)
    {
        if(chess[j].x>=0 && chess[j].x<=7 && chess[j].y>=0 && chess[j].y<=7)
        {
            for(int i=0;i<4;i++)
            {
                if(i!=j && chess[i].x==chess[j].x && chess[i].y==chess[j].y)
                {
                    return false;
                }
            }
            return true;
        }
        return false;
    }
}s,e;

bool cmp(const struct point& a,const struct point& b)
{
    if(a.x == b.x)
    {
        return a.y<b.y;
    }
    return a.x<b.x;
}
int gethash(node& a)
{
    sort(a.chess, a.chess+4, cmp);
    int hash = 0;
    for(int i=0; i<4; i++)
    {
        hash |= a.chess[i].x << (6*i);
        hash |= a.chess[i].y << (6*i+3);
    }
    return hash;
}

map<int,int>mapint;
map<int,int>::iterator it_1,it_2;

bool BFS(void)
{
    queue<node>que[2];
    
    que[0].push(s);
    que[1].push(e);
    mapint[gethash(s)] = 10*0+0;
    mapint[gethash(e)] = 10*1+0;
    
    int sign;
    while(!que[0].empty() || !que[1].empty())
    {
        if(que[0].size() < que[1].size())
        {
            sign = que[0].empty() ? 1:0;
        }
        else
        {
            sign = que[1].empty() ? 0:1;
        }
        
        node temp = que[sign].front();
        que[sign].pop();
        
        it_1 = mapint.find(gethash(temp));
        
        if((it_1->second)%10 >= 4)    //移动步数超过4步 
        {
            continue;
        }
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<4;j++)
            {
                node next = temp;
                next.chess[i].x += dir[j][0];
                next.chess[i].y += dir[j][1];
                
                if(!next.check(i))        //重叠或者越界 
                {
                    next.chess[i].x += dir[j][0];
                    next.chess[i].y += dir[j][1];
                    if(!next.check(i))    //重叠或者越界 
                    {
                        continue;
                    }
                }
                
                int hash = gethash(next);
                it_2 = mapint.find(hash);
                    
                if(it_2 == mapint.end())
                {
                    mapint[hash] = it_1->second + 1;
                    que[sign].push(next);
                }
                else if(it_2->second/10 == 1-sign)
                {
                    return true;
                }
            }
        }
    }
    return false;
}

int main()
{
    while(cin>>s.chess[0].x>>s.chess[0].y)
    {
        for(int i=1; i<4; i++)
        {
            cin>>s.chess[i].x>>s.chess[i].y;
        }
        for(int i=0; i<4; i++)
        {
            cin>>e.chess[i].x>>e.chess[i].y;
        }
        for(int i=0;i<4;i++)
        {
            s.chess[i].x--; s.chess[i].y--;
            e.chess[i].x--; e.chess[i].y--;
        }
        
        if(BFS())
        {
            cout<<"YES"<<endl;
        }
        else
        {
            cout<<"NO"<<endl;
        }
        mapint.clear();
    }
    return 0;
}