WHUST 2017 Div.2 Day 1

A - 迷宫问题

POJ - 3984

题目大意

定义一个二维数组：

int maze[5][5] = {

	0, 1, 0, 0, 0,

	0, 1, 0, 1, 0,

	0, 0, 0, 0, 0,

	0, 1, 1, 1, 0,

	0, 0, 0, 1, 0,

};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

Input

一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。

Output

左上角到右下角的最短路径，格式如样例所示。

Sample Input

0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

Sample Output

(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

做法

BFS求最短路径模板题，

用queue进行遍历（BFS函数开始时应确定队列Q为空），

因为要输出路径，所以定义一个二维数组pre储存每个点的父节点坐标，用stack遍历输出路径，

用数组dx，dy存储向量，来完成遍历时对一个点的多种操作，vis数组标记是否被访问过（如果题设要求多次求解应该在循环结尾memset数组为0）

AC-Code (C++)

Time: 0 ms Memory: 0.2 MB

#include<iostream>
#include<queue>
#include<stack>
using namespace std;
int maze[5][5], vis[5][5] = { 0 };

int dx[4] = { -1, 1, 0, 0 };
int dy[4] = { 0, 0, -1, 1 };

struct Node {
	int x, y;
	Node(int x, int y) :x(x), y(y){}
	Node(){}
}pre[5][5];

queue<Node> Q;

void BFS() {
	vis[0][0] = 1;
	//原点初始已被访问 
	Q.push(Node(0, 0));
	while (!Q.empty())  {
		Node node = Q.front(); Q.pop();
		int x = node.x, y = node.y;
		for (int d = 0; d<4; d++)  {
			int nx = x + dx[d];
			int ny = y + dy[d];
			if (nx >= 0 && nx<5 && ny >= 0 && ny<5 && vis[nx][ny] == 0 && maze[nx][ny] == 0)  {
				//在格子内，没有被访问过，不是墙壁 
				vis[nx][ny] = 1;
				Q.push(Node(nx, ny));
				//把新的点放进队列 
				pre[nx][ny] = Node(x, y);
				if (nx == 4 && ny == 4) return;
			}
		}
	}
}

int main()
{
	for (int i = 0; i<5; i++)
	for (int j = 0; j<5; j++)
		cin >> maze[i][j];

	BFS();

	stack<Node> S;

	int cur_x = 4, cur_y = 4;

	while (1){
		S.push(Node(cur_x, cur_y));
		if (cur_x == 0 && cur_y == 0) break;
		int x = cur_x, y = cur_y;
		cur_x = pre[x][y].x;
		cur_y = pre[x][y].y;
	}

	while (!S.empty())
	{
		Node node = S.top();
		cout << '(' << node.x << ", " << node.y << ')' << endl;
		S.pop();
	}

	return 0;
}

B - Dungeon Master

POJ - 2251

题目大意

你被困在一个3D的迷宫里面，

给定迷宫的行、列、层，以及地图，

地图上标记了起点和终点，'.'表示能走，'#'表示不能走，

求最短路径长度（即被困时间长度），

如果走不出来输出Trapped！

Sample Input

3 4 5
S....
.###.
.##..
###.#

#####
#####
##.##
##...

#####
#####
#.###
####E

1 3 3
S##
#E#
###

0 0 0

Sample Output

Escaped in 11 minute(s).
Trapped!

做法

BFS模板题，与上题不同之处在于：

        1.没有预设起点和终点，

        2.坐标和方向向量是三维的，

        3.不一定有解，要判断是否无解（此处判别遍历完毕之后终点有没有被访问过），

        4.需要多次输入，每次结束时要将vis和dist置空，每次BFS开始时要将队列Q置空，

AC-Code (C++)

Time: 0 msMemory: 0.6 MB

#include<iostream>
#include<string>
#include<queue>
#include<stack>
#include<stdio.h>

using namespace std;

const int MAXN = 31;

int maze[MAXN][MAXN][MAXN];
int vis[MAXN][MAXN][MAXN] = { 0 };
int dist[MAXN][MAXN][MAXN];
char hang[MAXN];

int dx[6] = { -1, 1, 0, 0, 0, 0 };
int dy[6] = { 0, 0, 1, -1, 0, 0 };
int dz[6] = { 0, 0, 0, 0, 1, -1 };

int L, R, C;

struct Node{
	int x, y, z;
	Node(int x, int y,int z) :x(x), y(y),z(z){}
	Node(){}
};

Node start, ending;

queue<Node> Q;

void BFS(void)
{
	while (!Q.empty())	Q.pop();
	Q.push(start);
	while (!Q.empty())
	{
		Node node = Q.front();
		Q.pop();
		for (int i = 0; i < 6; i++)
		{
			int nx = node.x + dx[i];
			int ny = node.y + dy[i];
			int nz = node.z + dz[i];
			if (nx >= 0 && nx < L&&ny >= 0 && ny < R&&nz >= 0 && nz < C&&vis[nx][ny][nz] == 0 && maze[nx][ny][nz] == 0)
				//在界内，没访问过，可以走
			{
				vis[nx][ny][nz] = 1;
				dist[nx][ny][nz] = dist[node.x][node.y][node.z] + 1;
				Q.push(Node(nx, ny, nz));
				if (nx == ending.x&&ny == ending.y&&nz == ending.z)
					return;
			}
		}
	}
}

void Start(int a, int b, int c)
{
	maze[a][b][c] = 0;
	start.x = a;
	start.y = b;
	start.z = c;
	vis[a][b][c] = 1;
	dist[a][b][c] = 0;
}

void Ending(int a, int b, int c)
{
	maze[a][b][c] = 0;
	ending.x = a;
	ending.y = b;
	ending.z = c;
}


int main()
{
	while (scanf("%d %d %d", &L, &R, &C) && L && R && C)
	{
		for (int i = 0; i < L; i++)
		{
			for (int j = 0; j < R; j++)
			{
				scanf("%s", hang);
				for (int k = 0; k < C; k++)
				{
					switch (hang[k])
					{
					case '.':maze[i][j][k] = 0; break;
					case '#':maze[i][j][k] = 1; break;
					case 'S':Start(i, j, k);break;
					case 'E':Ending(i, j, k);break;
					}
				}
			}
		}

		BFS();
		
		if (vis[ending.x][ending.y][ending.z] == 0)
			cout << "Trapped!" << endl;
		else
			cout << "Escaped in " << dist[ending.x][ending.y][ending.z] << " minute(s)." << endl;
		memset(vis, 0, sizeof(vis));
		memset(dist, 0, sizeof(dist));
		memset(maze, 1, sizeof(maze));
	}

	return 0;

}