bnu 51641 Certain Maze（bfs）（北师16校赛）

最近，无聊的过河船同学发现了一种无聊的迷宫生成算法。

算法过程如下： 一个的矩形区域可以看作个单位网格组成。在每个网格中，随机生成一个从右上角到左下角的L型障碍或者从左上角到右下角的R型障碍（障碍可以被看作一条线段）。

图1：两种障碍

这样便可以生成一个大小为的迷宫，如图2所示。

图2：无聊的迷宫

然后过河船同学想知道，是否存在迷宫内的从迷宫上边界到达迷宫的下边界的路径。于是无聊的过河船同学花了一夜的时间，终于找到一条路径。

图3：过河船同学辛辛苦苦找到的道路

痛苦的过河船同学不想再伤害自己的眼睛，他想直接知道，对于给定的迷宫，是否存在这样的路径。

请注意，路径只能从迷宫内部穿过，除起点和终点外不得离开迷宫区域。

Input

第一行是一个正整数，表示测试数据的组数，

对于每组测试数据，

第一行是两个整数和，表示迷宫的行数和列数，

接下来行，每行是一个长为的只包含'L'和'R'的字符串，'L'表示一个L型障碍，'R'表示一个R型障碍。

Output

对于每组测试数据，如果存在一条可以从迷宫的上边界到达迷宫的下边界的路径，输出"Yes"（不含引号），否则输出"No"（不含引号）。

Sample Input

2
2 2
LR
LR
2 2
LL
RR

Sample Output

No
Yes

Hint

样例中的迷宫形状分别为：

Source

第十四届北京师范大学程序设计竞赛决赛

Author

zhan723284893

题目大意：

       给定一个迷宫，迷宫的墙都是格子的对角线，问是否能从迷宫上边界走到迷宫下边界。
题目解法：

      每个格子选出四个关键点，两种墙分别对应两种关键点之间的连边方式，建出图之后跑一遍BFS或者用并查集维护连通性均可，复杂度O(n^2)或者O(n^2*ɑ(n))或者O(n^2*logn)，总之都能过。

（队友写的，码力好强！）

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<map>
#include<string.h>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<set>
#define C(a) memset(a,0,sizeof a)
#define C_1(a) memset(a,-1,sizeof a)
#define C_I(a) memset(a,0x3f,sizeof a)
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int maxn = 120;
int n, m;
char ma[maxn][maxn];
bool vis[maxn][maxn][3];
struct node
{
	int x, y, f;
	node(int a, int b, int c)
	{
		x = a; y = b; f = c;
	}
};
int main()
{
	int T; cin >> T;
	while (T--)
	{
		C(vis);
		scanf("%d%d", &n, &m);
		for (int i = 0; i<n; i++)scanf("%s", ma[i]);
		queue<node> q;
		for (int i = 0; i<m; i++) {
			q.push(node(0, i, 0));
			vis[0][i][0] = 1;
		}
		int X, Y, F, x, y, f;
		int flag = 0;
		while (!q.empty())
		{
			x = q.front().x;
			y = q.front().y;
			f = q.front().f;
			//printf("%d %d %d\n",x,y,f);
			if (x == n - 1 && f == 1)
			{
				flag = 1;
				break;
			}
			q.pop();
			if (f == 0 && ma[x][y] == 'R')
			{
				X = x - 1;
				Y = y;
				F = 1;
				if (X<0 || X >= n || Y<0 || Y >= m || vis[X][Y][F]);
				else {
					q.push(node(X, Y, F));
					vis[X][Y][F] = 1;
				}
				X = x; Y = y + 1;
				if (X<0 || X >= n || Y<0 || Y >= m);
				else
				{
					if (ma[X][Y] == 'L')
					{
						F = 0;
						if (vis[X][Y][F]);
						else {
							q.push(node(X, Y, F));
							vis[X][Y][F] = 1;
						}
					}
					else {
						F = 1;
						if (vis[X][Y][F]);
						else {
							q.push(node(X, Y, F));
							vis[X][Y][F] = 1;
						}
					}
				}
			}
			else if (f == 0 && ma[x][y] == 'L') {
				X = x - 1;
				Y = y;
				F = 1;
				if (X<0 || X >= n || Y<0 || Y >= m || vis[X][Y][F]);
				else {
					q.push(node(X, Y, F));
					vis[X][Y][F] = 1;
				}
				X = x; Y = y - 1;
				if (X<0 || X >= n || Y<0 || Y >= m);
				else
				{
					if (ma[X][Y] == 'L')
					{
						F = 1;
						if (vis[X][Y][F]);
						else {
							q.push(node(X, Y, F));
							vis[X][Y][F] = 1;
						}
					}
					else {
						F = 0;
						if (vis[X][Y][F]);
						else {
							q.push(node(X, Y, F));
							vis[X][Y][F] = 1;
						}
					}
				}
			}
			else if (f == 1 && ma[x][y] == 'L') {
				X = x + 1;
				Y = y;
				F = 0;
				if (X<0 || X >= n || Y<0 || Y >= m || vis[X][Y][F]);
				else {
					q.push(node(X, Y, F));
					vis[X][Y][F] = 1;
				}
				X = x; Y = y + 1;
				if (X<0 || X >= n || Y<0 || Y >= m);
				else
				{
					if (ma[X][Y] == 'L')
					{
						F = 0;
						if (vis[X][Y][F]);
						else {
							q.push(node(X, Y, F));
							vis[X][Y][F] = 1;
						}
					}
					else {
						F = 1;
						if (vis[X][Y][F]);
						else {
							q.push(node(X, Y, F));
							vis[X][Y][F] = 1;
						}
					}
				}
			}
			else if (f == 1 && ma[x][y] == 'R') {
				X = x + 1;
				Y = y;
				F = 0;
				if (X<0 || X >= n || Y<0 || Y >= m || vis[X][Y][F]);
				else {
					q.push(node(X, Y, F));
					vis[X][Y][F] = 1;
				}
				X = x; Y = y - 1;
				if (X<0 || X >= n || Y<0 || Y >= m);
				else
				{
					if (ma[X][Y] == 'L')
					{
						F = 1;
						if (vis[X][Y][F]);
						else {
							q.push(node(X, Y, F));
							vis[X][Y][F] = 1;
						}
					}
					else {
						F = 0;
						if (vis[X][Y][F]);
						else {
							q.push(node(X, Y, F));
							vis[X][Y][F] = 1;
						}
					}
				}
			}
		}
		if (flag)printf("Yes\n");
		else printf("No\n");
	}
	return 0;
}