最近,无聊的过河船同学发现了一种无聊的迷宫生成算法。
算法过程如下: 一个的矩形区域可以看作个单位网格组成。在每个网格中,随机生成一个从右上角到左下角的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
题目大意:
给定一个迷宫,迷宫的墙都是格子的对角线,问是否能从迷宫上边界走到迷宫下边界。
题目解法:
每个格子选出四个关键点,两种墙分别对应两种关键点之间的连边方式,建出图之后跑一遍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;
}