HDU 1728

逃离迷宫

Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 26486    Accepted Submission(s): 6451

Problem Description

　　给定一个m × n (m行, n列)的迷宫，迷宫中有两个位置，gloria想从迷宫的一个位置走到另外一个位置，当然迷宫中有些地方是空地，gloria可以穿越，有些地方是障碍，她必须绕行，从迷宫的一个位置，只能走到与它相邻的4个位置中,当然在行走过程中，gloria不能走到迷宫外面去。令人头痛的是，gloria是个没什么方向感的人，因此，她在行走过程中，不能转太多弯了，否则她会晕倒的。我们假定给定的两个位置都是空地，初始时，gloria所面向的方向未定，她可以选择4个方向的任何一个出发，而不算成一次转弯。gloria能从一个位置走到另外一个位置吗？

 

Input

　　第1行为一个整数t (1 ≤ t ≤ 100),表示测试数据的个数，接下来为t组测试数据，每组测试数据中，
　　第1行为两个整数m, n (1 ≤ m, n ≤ 100),分别表示迷宫的行数和列数，接下来m行，每行包括n个字符，其中字符'.'表示该位置为空地，字符'*'表示该位置为障碍，输入数据中只有这两种字符，每组测试数据的最后一行为5个整数k, x ₁, y ₁, x ₂, y ₂ (1 ≤ k ≤ 10, 1 ≤ x ₁, x ₂ ≤ n, 1 ≤ y ₁, y ₂ ≤ m),其中k表示gloria最多能转的弯数，(x ₁, y ₁), (x ₂, y ₂)表示两个位置，其中x ₁，x ₂对应列，y ₁, y ₂对应行。

 

Output

　　每组测试数据对应为一行，若gloria能从一个位置走到另外一个位置，输出“yes”，否则输出“no”。

 

Sample Input

  
  

   
   2
5 5
...**
*.**.
.....
.....
*....
1 1 1 1 3
5 5
...**
*.**.
.....
.....
*....
2 1 1 1 3
  
  

 

Sample Output

  
  

   
   no
yes
  
  

 

思路：

对每个方向，比如向东的方向，就一直向东走，把向东可以走的格子都走完，那么下次比如向南方走，就一定会转弯。我采用的是BFS。

花了大半天时间没做出来，不知道怎么存储转弯数，最后看了别人题解才搞定，智商捉急

参考：http://blog.csdn.net/zhuhuangjian/article/details/8262561和http://blog.csdn.net/luomingjun12315/article/details/43344025

欢迎交流：

//方法一：
#include <iostream>  
#include <queue>  
#include <cstring>  
#define MAXN 100 + 10  
using namespace std;

typedef pair<int, int> P;

const int INF = 0x3f3f3f3f;


char maze[MAXN][MAXN];
int d[MAXN][MAXN];//从起点到该点需转弯数
int dx[4] = { 1, 0, -1, 0 }, dy[4] = { 0, 1, 0, -1 };  //位移参量  

int main(){
	int t, m, n, k, x1, y1, x2, y2;
	scanf("%d", &t);
	while (t--)
	{
		scanf("%d%d", &m, &n);

		memset(maze, 0, sizeof(maze));

		for (int i = 0; i <m; i++)//i存储y方向的值
		for (int j = 0; j < n; j++)//j存储x方向的值
			d[i][j] = INF;

		for (int i = 0; i < m; i++)
			scanf("%s", maze[i]);
		cin >> k >> x1 >> y1 >> x2 >> y2;

		queue<P>que;



		que.push(P(y1 - 1, x1 - 1)); //将起始点推入队列，迷宫不是从1行1列而是0行0列开始存储，所以横纵坐标要减1
		d[y1 - 1][x1 - 1] = -1;//因为第一次遍历会把转弯数多加一，所以将开始的值初始为-1  

		int flag = 0;
		while (que.size()){
			P p = que.front();
			que.pop();
			if (p.first == y2 - 1 && p.second == x2 - 1 && d[p.first][p.second] <= k)//迷宫不是从1行1列而是0行0列开始存储，所以横纵坐标要减1
			{
				flag = 1; break;
			}

			int nx, ny;
			for (int i = 0; i<4; i++){
				nx = p.first + dx[i], ny = p.second + dy[i];         //进行四个方向遍历  
				while (nx >= 0 && nx < m && ny >= 0 && ny < n && maze[nx][ny] != '*'){    //搜完一个方向 
					if (d[nx][ny] == INF){

						d[nx][ny] = d[p.first][p.second] + 1;//因为前面搜完了一个方向，就肯定会拐弯，所以要+1，也因此起点的k初始化为-1;  
						que.push(P(nx, ny));

					}
					nx += dx[i];
					ny += dy[i];
				}
			}
		}
		if (flag)
			cout << "yes" << endl;
		else
			cout << "no" << endl;

	}
	return 0;
}



//方法二：
//把que.push(P(y1 - 1, x1 - 1));改为que.push(P(x1 - 1, y1 - 1));以及更改相应的操作

#include<cstdio>
#include<queue>
#include<string.h>
#include<algorithm>
using namespace std;

typedef pair<int, int> P;
const int MAXN = 110, INF = 0x3f3f3f;
char maze[MAXN][MAXN + 1];
int d[MAXN][MAXN];//从起点到该点需转弯数



int main()
{
	int t, m, n, k, x1, y1, x2, y2;
	scanf("%d", &t);
	while (t--)
	{
		memset(maze, 0, sizeof(maze));

		scanf("%d%d", &m, &n);
		for (int i = 0; i < m; i++)
			scanf("%s", maze[i]);

		for (int i = 0; i < n; i++)
		for (int j = 0; j < m; j++)
			d[i][j] = INF;

		scanf("%d%d%d%d%d", &k, &x1, &y1, &x2, &y2);

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

		queue<P> que;
		que.push(P(x1 - 1, y1 - 1));//把1行1列转换到0行0列
		d[x1 - 1][y1 - 1] = -1;//最开始的一行或一列不需要转弯，为了d[p.first][p.second] + 1后为0，使d[x1-1][y1-1]初始化为-1


		int flag = 0;

		while (que.size())
		{

			P p = que.front(); que.pop();

			if (p.first == x2 - 1 && p.second == y2 - 1 && d[p.first][p.second] <= k)
			{
				flag = 1; break;
			}

			int nx, ny;
			for (int i = 0; i < 4; i++)
			{
				nx = p.first + dx[i], ny = p.second + dy[i];
				while (0 <= nx&&nx < n && 0 <= ny&&ny < m && maze[ny][nx] != '*') //搜完一个方向 
				{
					if (d[nx][ny] == INF)
					{
						que.push(P(nx, ny));
						d[nx][ny] = d[p.first][p.second] + 1;//因为前面搜完了一个方向，就肯定会拐弯，所以要+1，也因此起点的k初始化为-1;  

					}
					nx += dx[i], ny += dy[i];

				}
			}

		}
		if (flag) printf("yes\n");
		else printf("no\n");

	}

	return 0;
}