HDU-2102 A计划 BFS

A计划

Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 4156    Accepted Submission(s): 936

Problem Description

可 怜的公主在一次次被魔王掳走一次次被骑士们救回来之后，而今，不幸的她再一次面临生命的考验。魔王已经发出消息说将在T时刻吃掉公主，因为他听信谣言说吃 公主的肉也能长生不老。年迈的国王正是心急如焚，告招天下勇士来拯救公主。不过公主早已习以为常，她深信智勇的骑士LJ肯定能将她救出。
现据密探 所报，公主被关在一个两层的迷宫里，迷宫的入口是S（0，0，0），公主的位置用P表示，时空传输机用#表示，墙用*表示，平地用.表示。骑士们一进入时 空传输机就会被转到另一层的相对位置，但如果被转到的位置是墙的话，那骑士们就会被撞死。骑士们在一层中只能前后左右移动，每移动一格花1时刻。层间的移 动只能通过时空传输机，且不需要任何时间。

 

Input

输入的第一行C表示共有C个测试数据，每个测试数据的前一行有三个整数N，M，T。 N，M迷宫的大小N*M（1 <= N,M <=10)。T如上所意。接下去的前N*M表示迷宫的第一层的布置情况，后N*M表示迷宫第二层的布置情况。

 

Output

如果骑士们能够在T时刻能找到公主就输出“YES”，否则输出“NO”。

 

Sample Input

1
5 5 14
S*#*.
.#...
.....
****.
...#.

..*.P
#.*..
***..
...*.
*.#..

 

Sample Output

YES

 　　

　　简单BFS，题目虽说是在T时刻解救公主，但其实只要在小于T时刻的时间内解救了公主就可以了，因为题并没有说走过的边不能够往回走，所以时间变成了小于等于T。

　　代码如下：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <queue>
using namespace std;

char map[2][15][15], hash[2][15][15];

int sx, sy, ex, ey, sk, ek, S;

inline bool legal( char c )
{
	if( c== '.'|| c== 'S'|| c== '#'|| c== '*'|| c== 'P' )
	{
		return true;
	}
	return false;
}

inline void gchar( char &c )
{
	char t;
	while( t= getchar(), !legal( t ) ) ;
	c= t;
} 

struct Node
{
	int x, y, k, step;
}info;

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

bool BFS(  )
{
	memset( hash, 0, sizeof( hash ) ); // 不能单纯的判断某一点是否走过，而是该点是否有更优的解
	queue< Node >q;
	info.x= sx, info.y= sy, info.k= sk, info.step= 0;
	hash[sk][sx][sy]= 1;
	q.push( info );
	int cnt= 0;
	while( !q.empty() )
	{
		Node pos= q.front();
		q.pop();
		if( map[pos.k][pos.x][pos.y]== 'P'&& pos.step<= S )
		{
		//	printf( "step= %d\n", pos.step );
			return true;
		}
		for( int i= 0; i< 4; ++i )
		{
			int x= pos.x+ dis[i][0], y= pos.y+ dis[i][1], k= pos.k, step= pos.step;
			if( map[k][x][y]!= 0&& map[k][x][y]!= '*' )
			{
				if( map[k][x][y]!= '#'&& !hash[k][x][y]&& step< S )
				{// 其已走步数不能已经到达了S步
					info.x= x, info.y= y, info.k= k, info.step= step+ 1;
					hash[k][x][y]= 1;
					q.push( info );
				}
				else if( map[k][x][y]== '#'&& map[ ( k+ 1 )% 2 ][x][y]!= '*'&& map[ ( k+ 1 )% 2 ][x][y]!= '#'&& !hash[ ( k+ 1 )% 2 ][x][y]&& step< S )
				{// 进行图之间的转化，但是不能够对应在下一个图中的墙
					info.x= x, info.y= y, info.k= ( k+ 1 )% 2, info.step= step+ 1;
					hash[ ( k+ 1 )% 2 ][x][y]= 1;
					q.push( info );
				}
			}
		}
	}
	return false;
}

int main(  )
{
	int T;
	scanf( "%d", &T );
	while( T-- )
	{
		int N, M;
		scanf( "%d %d %d", &N, &M, &S );
		memset( map, 0, sizeof( map ) );
		for( int k= 0; k< 2; ++k )
		{
			for( int i= 1; i<= N; ++i )
			{
				for( int j= 1; j<= M; ++j )
				{
					gchar( map[k][i][j] );
					if( map[k][i][j]== 'S' )
					{
						sx= i, sy= j, sk= k;
					}
					if( map[k][i][j]== 'P' )
					{
						ex= i, ey= j, ek= k;
					}
				}
			}
		}
		printf( BFS(  )? "YES\n": "NO\n" );
	}
}