百度之星2017 初赛 迷宫出逃(HDU 6111)

Posted 晓风微微

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了百度之星2017 初赛 迷宫出逃(HDU 6111)相关的知识,希望对你有一定的参考价值。

转自本人的csdn博客: http://blog.csdn.net/xfww123/article/details/77131236

迷宫出逃

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 15    Accepted Submission(s): 1


Problem Description
小明又一次陷入了大魔王的迷宫,在无人机的帮忙下,小明获得了整个迷宫的草图。


不同于一般的迷宫,魔王在迷宫里安置了机关,一旦触碰,那么四个方向所在的格子,将翻转其可达性(原先可通过的格子不可通过,反之亦然,机关可以反复触发)。为了防止小明很容易地出逃,魔王在临走前把钥匙丢在了迷宫某处,只有拿到钥匙,小明才能开门在出口处离开迷宫。

万般无奈之下,小明想借助聪明的你,帮忙计算是否有机会离开这个迷宫,最少需要多少时间。(每一单位时间只能向四邻方向走一步)
 


Input
第一行为 T,表示输入数据组数。

下面 T 组数据,对于每组数据:

第一行是两个数字 n, m(2 < n * m <= 64),表示迷宫的长与宽。

接下来 n 行,每行 m 个字符,‘.’表示空地可以通过,‘x’表示陷阱,‘*’表示机关,‘S’代表起点,‘E’代表出口,‘K’表示钥匙(保证存在且只有一个)。
 


Output
对第 i 组数据,输出

Case #i:

然后输出一行,仅包含一个整数,表示最少多少步能够拿到钥匙并走出迷魂阵,如果不能则打出-1。
 


Sample Input
5 5 7 ...*x.. ...x... xEx.... *x...K. .x*...S 5 7 K..*x.. ...x... xEx.... *x..... .x*...S 5 7 ..K*x.. ..*x*.. xEx.... *x..... .x*...S 5 7 ..K*x.. .*xx*.. *E*.... xx..... .x*...S 4 4 S*.. **.. ...E ...K
 


Sample Output
Case #1: 11 Case #2: 13 Case #3: 13 Case #4: 11 Case #5: -1
 


Source

题目分析:
M*N最大64,很容易就想到状态压缩,又因为是找到终点的最近距离,那么肯定使用BFS。
状态压缩也很基础,假设N行M列,从第一行第一列是二进制第一位,第一行第二列是二进制第二位,第一行第三列是二进制第三位
,第二行第一列是二进制第M+1位,第x行第y列是二进制的第(x-1)*m+y位。每一位是1表示状态反转,每一位状态是0表示状态正常。
如此,就可以很轻松的,把状态用一个64位的无符号整数储存下来了。
然后有没有钥匙是2种状态,0表示有,1表示没有。
找到出口看钥匙状态是0还是1即可
每一位能不能走看那个位置原本的图,和状态是否改变即可。
那么问题来了,bfs必须要判重,也就是要有一个哈希表,存储这个状态到底有没有被访问过。单纯的反转状态就有2^64次方个,那么,用一个数组去裸存肯定不行。比赛时,我就想到了map,结果超了内存。内存限制32MB,太小了。
然后评测机就一直卡着,然后比赛就这么结束了。
其实,比赛完之后仔细想想,状态绝对不会出现很多,因为图太小了,我就写了个hash表,建立了一个10000的queue数组,取每个状态的坐标,反转状态和钥匙状态的和,mod 10000作为hash值插入相应数组的位置,然后判重时遍历数组即可。

附代码:

 

#include<iostream>
using namespace std;
#include<cstdio>
#include<queue>
#include<cstring>
#include<vector>
int tx[] = { -1,1,0,0 };//上下左右移动x的改变量 
int ty[] = { 0,0,-1,1 };//上下左右移动y的改变量 
int ii = 0;
typedef unsigned long long LL;
struct datatype//队列中状态信息 
 {
	int bs;//步数 
	LL zt1;//第一个状态,储存每个点的状态是否反转 
	LL zt2;//第二个状态,储存是否有钥匙 
	int x;//所在的x坐标 
	int y;//所在的y坐标 
	datatype()//初始化 
	{
		bs = 0;
		zt1 = 0;
		x = 0;
		y = 0;
		zt2 = 0;
	}
};
queue<datatype> team;//BFS所用的队列 
int maps[70][70];//初始的地图图信息 
struct mapdata {//hash判重所用的信息类型 
	int x, y;//x,y坐标 
	LL zt1;//第一个状态 
	int zt2;//第二个状态 
	LL count()//每个状态的和 mod 10000,取得hash值 
	{
		LL ans = zt1 % 10000;
		ans = (ans + zt2) % 10000;
		ans = (ans + x) % 10000;
		ans = (ans + y) % 10000;
		return ans;
	}
	bool operator<(const mapdata &b)const//重载 
	{
		if (this->x != b.x) return this->x< b.x;
		if (this->y != b.y) return this->y< b.y;
		if (this->zt1 != b.zt1) return this->zt1 < b.zt1;
		return this->zt2 < b.zt2;
	}
	bool operator==(const mapdata &b)const//重载 
	{
		if (this->x != b.x) return this->x == b.x;
		if (this->y != b.y) return this->y == b.y;
		if (this->zt1 != b.zt1) return this->zt1 == b.zt1;
		return this->zt2 == b.zt2;
	}
};
char s[70][100];//最初读入得字符串地图信息 
vector<mapdata> has[10010];//hash判重用到得vector数组 
void deal() 
{
	memset(s, 0, sizeof(s));//初始化 
	memset(maps, 0, sizeof(maps));//初始化 
	int n, m; 
	while (!team.empty()) team.pop();//清空队列 
	datatype pt;//一个读取队列状态的变量 
	cin >> n >> m;//读取n,m,地图长,宽 
	for (int i = 0; i <= 10000; i++)
		has[i].clear();//清空hash表 
	for (int i = 1; i <= n; i++)
	{
		scanf("%s", s[i] + 1);//读取地图信息 
	}
	int qdx, qdy;//保存起点x,y坐标 
	for (int i = 1; i <= n; i++)//处理地图 
	{
		for (int j = 1; j <= m; j++)
		{
			if (s[i][j] == ‘.‘) maps[i][j] = 1;//可行为1 
			if (s[i][j] == ‘x‘) maps[i][j] = 0;//不可行为0 
			if (s[i][j] == ‘E‘) maps[i][j] = -666;//出口为-666 
			if (s[i][j] == ‘*‘) maps[i][j] = -10;//机关为-10 
			if (s[i][j] == ‘K‘) maps[i][j] = -66;//钥匙为-66 
			if (s[i][j] == ‘S‘) {//找到起点,将起点入队 
				maps[i][j] = 1, qdx = i, qdy = j;
				pt.bs = 0, pt.zt1 = 0, pt.zt2 = 0, pt.x = qdx, pt.y = qdy;
				team.push(pt);
			}
		}
	}
	datatype pd;
	int ans = -1;//初始化答案变量 
	while (!team.empty())//BFS 
	{
		pt = team.front();//取队首元素 
		team.pop();//队首元素出队 
		if (maps[pt.x][pt.y] == -666)//如果是出口,且有钥匙,找到答案,退出搜索 
		{
			if (pt.zt2 == 1)
			{
				ans = pt.bs;
				break;
			}
		}
		for (int i = 0; i < 4; i++)//向当前位置的x,y轴移动 
		{
			pd.bs = pt.bs + 1;//更新步数 
			pd.zt1 = pt.zt1; 
			pd.zt2 = pt.zt2;
			pd.x = pt.x + tx[i];//更新x坐标 
			pd.y = pt.y + ty[i];//更新y坐标 
			if (pd.x <= 0 || pd.y <= 0 || pd.x > n || pd.y > m) continue;//超出边界,舍弃这个位置 
			LL cj = (LL)(m)*(pd.x - 1) + pd.y;//看当前坐标是地图横着数第几个位置,也就是状态压缩后的第几位,式子:(x-1)*m+y 
			LL zt = ((pd.zt1 >> (LL)(cj - 1)) & (LL)1);//看当前坐标是否受机关影响 
			if (zt == 0 && maps[pd.x][pd.y] == 0) continue;//不受影响,原本不可行,舍弃这个位置 
			if (zt == 1) 
			{
				if (maps[pd.x][pd.y] != 0) continue;//受机关影响,原本可行,舍弃这个位置 
			}
			LL ws1, ws2, ws3, ws4;//储存上下左右四点 ,是地图横着数第几个位置,也就是状态压缩后的第几位
			ws1 = 0; ws2 = 0; ws3 = 0; ws4 = 0;
			ws1 = (pd.x - 2)*(m)+pd.y;
			ws2 = (pd.x)*m + (pd.y);
			ws3 = (pd.x - 1)*m + (pd.y - 1);
			ws4 = (pd.x - 1)*m + (pd.y + 1);
			if (maps[pd.x][pd.y] == -10)//如果这个点是机关,就更新上下左右四点的反转状态 
			{
				if (pd.x - 1 > 0)//判断向上走超不超过边界 
				{
					if ((pd.zt1 >> (ws1 - (LL)1)) & (LL)1)//对应位置的翻转状态 
						pd.zt1 = pd.zt1 - ((LL)1 << (ws1 - (LL)1));//是1变成0 
					else
						pd.zt1 = pd.zt1 + ((LL)1 << (ws1 - (LL)1));//是0变成1 
				}
				/*后面的以此类推*/ 
				if (pd.x + 1 <= n)
				{
					if ((pd.zt1 >> (ws2 - (LL)1)) & (LL)1)
						pd.zt1 = pd.zt1 - ((LL)1 << (ws2 - (LL)1));
					else
						pd.zt1 = pd.zt1 + ((LL)1 << (ws2 - (LL)1));
				}
				if (pd.y - 1 > 0)
				{
					if ((pd.zt1 >> (ws3 - (LL)1)) & (LL)1)
						pd.zt1 = pd.zt1 - ((LL)1 << (ws3 - (LL)1));
					else
						pd.zt1 = pd.zt1 + ((LL)1 << (ws3 - (LL)1));
				}
				if (pd.y + 1 <= m)
				{
					if ((pd.zt1 >> (ws4 - (LL)1)) & (LL)1)
						pd.zt1 = pd.zt1 - ((LL)1 << (ws4 - (LL)1));
					else
						pd.zt1 = pd.zt1 + ((LL)1 << (ws4 - (LL)1));
				}
			}
			if (maps[pd.x][pd.y] == -66)//该点存在钥匙,钥匙状态设为1 
			{
				pd.zt2 = 1;
			}
			mapdata h;//建立一个hash信息的变量 
			h.x = pd.x; h.y = pd.y; h.zt1 = pd.zt1; h.zt2 = pd.zt2;//变量赋值 
			int zzt = h.count();//计算hash值 
			int vvv = 0;//判断访问与否的变量 
			for (int k = 0; k < has[zzt].size(); k++)//遍历所在hash表中的节点 
			{
				if (has[zzt][k] == h)//该状态已存在,标记已访问 
				{
					vvv = 1;
					break;
				}
			}
			if (vvv) continue;//如果标记访问,舍弃该状态 
			has[zzt].push_back(h);//未访问,hash信息入表 
			team.push(pd);//状态信息入队 
		}
	}
	/*输出答案*/ 
	printf("Case #%d:\n", ii); 
	cout << ans << endl;
}
int main()
{
	int t;
	cin >> t;
	while (t--)
	{
		ii++;
		deal();
	}
	return 0;
}

 

以上是关于百度之星2017 初赛 迷宫出逃(HDU 6111)的主要内容,如果未能解决你的问题,请参考以下文章

HDU 6118 2017百度之星初赛B 度度熊的交易计划(费用流)

(最小费用流)hdu 6118(2017百度之星初赛B 1005) 度度熊的交易计划

HDU 6109 数据分割 并查集 (2017"百度之星"程序设计大赛 - 初赛(A))

HDU 6114 Chess 组合数(2017"百度之星"程序设计大赛 - 初赛(B))

HDU 6122 今夕何夕 数学公式 (2017"百度之星"程序设计大赛 - 初赛(A))

HDU 6113 度度熊的01世界 DFS(2017"百度之星"程序设计大赛 - 初赛(A))