poj3083_Children of the Candy Corn

原创 2013年12月05日 20:21:07
Children of the Candy Corn
Time Limit: 1000MS   Memory Limit: 65536K
Total Submissions: 8508   Accepted: 3729

Description

The cornfield maze is a popular Halloween treat. Visitors are shown the entrance and must wander through the maze facing zombies, chainsaw-wielding psychopaths, hippies, and other terrors on their quest to find the exit. 

One popular maze-walking strategy guarantees that the visitor will eventually find the exit. Simply choose either the right or left wall, and follow it. Of course, there's no guarantee which strategy (left or right) will be better, and the path taken is seldom the most efficient. (It also doesn't work on mazes with exits that are not on the edge; those types of mazes are not represented in this problem.) 

As the proprieter of a cornfield that is about to be converted into a maze, you'd like to have a computer program that can determine the left and right-hand paths along with the shortest path so that you can figure out which layout has the best chance of confounding visitors.

Input

Input to this problem will begin with a line containing a single integer n indicating the number of mazes. Each maze will consist of one line with a width, w, and height, h (3 <= w, h <= 40), followed by h lines of w characters each that represent the maze layout. Walls are represented by hash marks ('#'), empty space by periods ('.'), the start by an 'S' and the exit by an 'E'. 

Exactly one 'S' and one 'E' will be present in the maze, and they will always be located along one of the maze edges and never in a corner. The maze will be fully enclosed by walls ('#'), with the only openings being the 'S' and 'E'. The 'S' and 'E' will also be separated by at least one wall ('#'). 

You may assume that the maze exit is always reachable from the start point.

Output

For each maze in the input, output on a single line the number of (not necessarily unique) squares that a person would visit (including the 'S' and 'E') for (in order) the left, right, and shortest paths, separated by a single space each. Movement from one square to another is only allowed in the horizontal or vertical direction; movement along the diagonals is not allowed.

Sample Input

2
8 8
########
#......#
#.####.#
#.####.#
#.####.#
#.####.#
#...#..#
#S#E####
9 5
#########
#.#.#.#.#
S.......E
#.#.#.#.#
#########

Sample Output

37 5 5
17 17 9

分析:两个dfs,一个bfs。dfs如果用回溯的话,会超时。。。。。。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>

using namespace std;

char map[45][45];
bool visit[45][45];
int dd[4][2] = {{1, 0}, {0, -1}, {-1, 0}, {0, 1}};
int x_st, y_st, f;
int sum1, sum2, sum3;
int n, m;
int cot = 1;

struct Data
{
	int x, y, sum;
};

queue<Data>q;

void dfs(int x, int y, int num)
{
	if (f == 1)
		return ;
	if (map[x][y] == 'E')
	{
		f = 1;
		return ;
	}
	int i = (num + 3) % 4;
	for (int  j = 0; j < 4; j++, i = (i + 1) % 4)
	{
		if (f)
			return ;
		int k = x + dd[i][0];
		int l = y + dd[i][1];
		if (k >= 0 && l >= 0 && k < n && l < m && map[k][l] != '#')
		{
			cot++;
			dfs(k, l, i);
		}
	}
}

void dfs2(int x, int y, int num)
{
	if (f == 1)
		return ;
	if (map[x][y] == 'E')
	{
		f = 1;
		return ;
	}
	int i;
	for (int i = (num + 1) % 4,j = 0; j < 4; j++,i = (i + 3) % 4)
	{
		if (f)
			return ;
		int k = x + dd[i][0];
		int l = y + dd[i][1];
		if (k >= 0 && l >= 0 && k < n && l < m && map[k][l] != '#')
		{
			cot++;
			dfs2(k, l, i);
		}
	}
}


void bfs(int x, int y)
{
	visit[x][y] = 1;
	Data data, c;
	data.x = x;
	data.y = y;
	data.sum = 1;
	q.push(data);
	while (!q.empty())
	{
		data = q.front();
		q.pop();
		for (int i = 0; i < 4; i++)
		{
			c.x = data.x + dd[i][0];
			c.y = data.y + dd[i][1];
			if (c.x >= 0 && c.y >= 0 && c.x < n && c.y < m && !visit[c.x][c.y] && map[c.x][c.y] != '#')
			{
				if (map[c.x][c.y] == 'E')
				{
					f = 1;
					sum3 = data.sum + 1;
                    return ;
				}
				c.sum = data.sum + 1;
				visit[c.x][c.y] = 1;
				q.push(c);
			}
		}
	}
}

int main()
{
	int t;
    scanf("%d", &t);
	while (t--)
	{
		memset(map, 0, sizeof(map));
		memset(visit, 0, sizeof(visit));
        f = 0;
		cot = 1;
		scanf("%d%d", &m, &n);
		getchar();
		for (int i = 0; i < n; i++)
		{
			gets(map[i]);
			for (int j = 0; j < m; j++)
			{
				if (map[i][j] == 'S')
				{
					x_st = i;
					y_st = j;
				}
			}
		}
		int k;
		if (y_st == 0)
			k = 3;
		else if (x_st == 0)
			k = 0;
		else if (x_st == n - 1)
			k = 2;
		else if (y_st == m - 1)
			k = 1;
		dfs(x_st, y_st, k);
		sum1 = cot;
		memset(visit, 0, sizeof(visit));
		f = 0;
		cot = 1;
		dfs2(x_st, y_st, k);
		sum2 = cot;
		memset(visit, 0, sizeof(visit));
		f = 0;
		while (!q.empty())
			q.pop();
		bfs(x_st, y_st);
		printf("%d %d %d\n", sum1, sum2, sum3);
	}
	return 0;
}


版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

POJ 3083 Children of the Candy Corn

模拟+BFS ,应该没什么难度吧,注意向左或向右转的时候优先搜索路径的顺序就可以了。编写两个函数turnleft和turnright, 通过对当前朝向的判断来控制路径就能轻松AC了。另外这道题的代码写...

POJ 3083 Children of the Candy Corn

Children of the Candy Corn Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 9890  ...

POJ 3083 Children of the Candy Corn (DFS+BFS) -- 解题报告

题目链接题目大意给定一个二维迷宫, “#” 表示不可走的位置,“.” 表示可走的位置,起点为 “S”,终点为 “E”。问左手扶墙走、右手扶墙走和最短路线的步数各是多少。解题思路本题需要输入三种走迷宫的...

poj 3083Children of the Candy Corn

一道搜索题目,虽然挺简单,但很繁琐,在方向上纠结了好长时间。还好最后一遍AC。 #include #include using namespace std; int s_right(int d...
  • pkuEE
  • pkuEE
  • 2011-08-02 22:56
  • 63

poj 3083 Children of the Candy Corn dfs+bfs

Description The cornfield maze is a popular Halloween treat. Visitors are shown the entrance and mu...

POJ3083 Children of the Candy Corn 搜索

Problem Address:http://poj.org/problem?id=3083 【思路】 学到了广搜的一种新的存储。 假设某个点(i,j),则可以用整数x = (i...

POJ 3083 Children of the Candy Corn(走迷宫)

题目链接:POJ 3083 题意: 给一个迷宫,‘#’代表墙,'.'代表可行,’S‘代表入口,’E‘代表出口。分别求出: ①按左、上、右、下顺序前行从入口到出口的步数。 ②按右、上、左、下顺序前行从入...

POJ 3083 Children of the Candy Corn (BFS ,DFS) -- from lanshui_Yang

Description The cornfield maze is a popular Halloween treat. Visitors are shown the entrance and ...

poj3083——Children of the Candy Corn

题意:分别找出从S到E的左路优先、右路优先、最短路的step。思路:dfs+bfs.#include #include #include #include using namespace st...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)