hdu 1401 双向广搜+8进制压缩状态

// hdu 1491.cpp : 定义控制台应用程序的入口点。
/*
题目询问能否能从一个状态到另外一个状态而少于8步移动。
每个状态为4个不同的点，即8个坐标。由于从初始状态到目标状态，和目标状态到初始状态的效果是一样，所以可以采用双向广搜。
每次选取节点比较少的队列进行扩展，直到发生重合。
由于坐标的区间为[1,8]，转化为[0,7]后，可用8进制进行状态压缩。最大的状态为8^8 - 1=16777215。在内存的限制内,事实上所有的状态只有
C(64,4)种，大概为635376种。
*/

#include "stdafx.h"
#include <algorithm>
#include <queue>
#include <iostream>
using namespace std;

int dir[4][2] = {1,0,-1,0,0,1,0,-1};
int pow[] = {1,8,64,512,4096,32768,262144,2097152};  //8进制权值
char hash[18000000];  //当hash[i]的值为[0,8]时表示该状态是从起始状态扩展而来的移动步数
					 //当hash[i]的值为[10,18]时表示该状态是从目标状态扩展而来的移动步数

struct Point
{
	int x;
	int y;
};

struct State
{
	Point p[4];
};


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;
}

State s,e;

//8进制压缩状态
int getState(State& A)
{
	sort(A.p,A.p+4,cmp);
	int sum = 0;
	for(int i=0; i<4; i++)
	{
		sum += A.p[i].x * pow[2*i];
		sum += A.p[i].y * pow[2*i+1];
	}
	return sum;
}

//判断该点是否已经存在
bool used(int x, int y, State temp)
{
	if(x >=0 && x < 8 && y >= 0 && y < 8)
	{
		for(int i=0; i<4; i++)
		{
			if(x == temp.p[i].x && y == temp.p[i].y)
			{
				return true;
			}
		}
		return false;
	}
	return true;
}

int bfs()
{
	queue<struct State>Q[2];//Q[0]保存从起点扩展的状态，Q[1]保存的是从终点扩展的状态
	int a = getState(s);
	int b = getState(e);
	int x,y;
	if(a == b)
	{
		return 1;
	}
	Q[0].push(s);
	hash[a] = 0;
	Q[1].push(e);
	hash[b] = 10;

	int sign = 0;
	while(!Q[0].empty() || !Q[1].empty())
	{
		//选取队内元素少的队列
		if(Q[0].size() > Q[1].size())
		{
			if(!Q[1].empty())
			{
				sign = 1;
			}
			else
			{
				sign = 0;
			}
		}
		else
		{
			if(!Q[0].empty())
			{
				sign = 0;
			}
			else
			{
				sign = 1;
			}
		}
		State flag;
		State temp = Q[sign].front();
		b = getState(temp);
		Q[sign].pop();
		for(int i=0; i<4; i++)  //4个方向进行扩展
		{
			for(int j=0; j<4; j++)  //4个点进行扩展
			{
				flag = temp;
				x = temp.p[j].x + dir[i][0];
				y = temp.p[j].y + dir[i][1];
				//如果该点已经存在，向前走一步
				if(used(x,y,temp))
				{
					x = x + dir[i][0];
					y = y + dir[i][1];
				}
				//如果该点合法且可以走
				if(!used(x,y,temp))
				{
					flag.p[j].x = x;
					flag.p[j].y = y;
					a = getState(flag);
					//该状态尚未被访问过
					if(hash[a] == -1)
					{
						hash[a] = hash[b] + 1;
						if(hash[a] % 10 == 8)  //如果已经超出了8步
						{
							continue;
						}
						Q[sign].push(flag);
					}
					else
					{
						//同样是从起点开始搜索得到的点
						if(hash[a] >= 0 && hash[a] <= 8 && hash[b] >= 0 && hash[b] <= 8)
						{
							continue;
						}
						//同样是从终点开始搜素得到的点
						if(hash[a] >= 10 && hash[a] <= 18 && hash[b] >= 10 && hash[b] <= 18)
						{
							continue;
						}
						//一个是以起点为初始状态搜索得到的点，一个是从终点搜索得到的点
						if(hash[a] % 10 + hash[b] % 10 + 1 <= 8)  //满足条件 
						{
							return 1;
						}
					}
				}
			}
		}
	}
	return 0;
}

int main()
{
	while(cin>>s.p[0].x>>s.p[0].y)
	{
		memset(hash,-1,sizeof(hash));
		s.p[0].x--;
		s.p[0].y--;
		for(int i=1; i<4; i++)
		{
			cin>>s.p[i].x>>s.p[i].y;
			s.p[i].x--;
			s.p[i].y--;
		}
		for(int i=0; i<4; i++)
		{
			cin>>e.p[i].x>>e.p[i].y;
			e.p[i].x--;
			e.p[i].y--;
		}

		if( bfs() )
		{
			cout<<"YES"<<endl;
		}
		else
			cout<<"NO"<<endl;
	}
	return 0;
}