Description
The Maze Makers is a publisher of puzzle books. One of their most popular series is maze books. They have a program that generates rectangular two-dimensional mazes like the one shown in Figure 1. The rules for these mazes are: (1) A maze has exactly two exterior
cell walls missing, opening to two distinct terminal cells, (2) starting from any one cell, all other cells are reachable, (3) between any two cells in the maze there is exactly one simple path. Formally, a path is a sequence of cells where each cell and its
successor on the path share an edge without a wall. A simple path is a path that never repeats a cell.
The Maze Maker program uses hexadecimal digits to encode the walls and passages of a maze. For each cell in the maze there is a corresponding hex digit. As shown in Figure 2, the 1‘s and 0‘s in the 4 digit binary representation of a hex digit correspond to
the walls (1‘s) and passages (0‘s) for each cell in the maze. For example, the binary encoding for the hex digit B is 1011. Starting at the top of the cell and moving clockwise around it, this digit represents a cell with a wall at the top, a passage to the
right and walls at the bottom and to the left. A path between two maze cells successively moves one cell up, down, left or right, going through passages only.
Figure 1: Sample Maze
Figure 2: Hex Code for Walls and Passageways
Figure 3: Maze with Cell Labels
Figure 3 shows the sample maze with the hexadecimal labels in each cell. For example, the hexadecimal digit E in the top-right cell indicates that it has a wall above it, to its right, below it, yet a passageway to its left. The hexadecimal digit 8 to its left
indicates that its cell has only a wall above it. The inputs will always be self-consistent, in that the hexadecimal digits in neighboring cells will agree on whether they share a wall or passageway, and each input will always have precisely two terminal cells,
each with one missing exterior wall.
Our sample maze is a legitimate maze in that all cells are reachable and there is a unique simple path between any pairs of cells in the maze. Your goal is to write a program that reads the hexadecimal descriptions of a potential maze and tests to determine
if it is legitimate. If there is a problem, your program must report only the first problem, as detailed below in the section titled "Output".
Input
The input consists of the descriptions of one or more candidate mazes. Each maze description will start with two integers, H and W, indicating the height and width of the maze, respectively, such that 1 ≤ H ≤ 50 and 2 ≤ W ≤ 50. Following this first line will
be H rows of hexadecimal digits, with each row consisting of W digits. The input is terminated with a line displaying a pair of zeros.
Output
For each candidate maze, the program should output the first one of the following statements that applies:
NO SOLUTION
UNREACHABLE CELL
MULTIPLE PATHS
MAZE OK
The classification statements are defined formally as follows:
NO SOLUTION - There is no path through the interior of the maze between the two exterior openings.
UNREACHABLE CELL - There is at least one cell in the maze that is not reachable by following passageways from either of the openings in the exterior walls of the maze.
MULTIPLE PATHS - There exists a pair of cells in the maze that have more than one simple path between them. Two simple paths are considered to be distinct if any part of the paths differ.
MAZE OK - None of the above problems exist.
Note well that for the second case given in the following examples, there is no path between the start and finish and there is an unreachable cell; the correct output should simply be NO SOLUTION, because that error message is listed first in the above list.
Similarly, in the fourth example given, UNREACHABLE CELL is reported because that error has priority over the multiple paths.
Sample Input
6 7 9A8C98E 2E5753C 980A496 553C53C 53C75D5 3E3E363 3 3 F9A D3E 3AC 1 8 3AAA8AAE 6 3 9AC 3C5 A24 9A6 5BC 3C7 5 4 8A8E 592C 5186 161C 3A63 5 4 8AAE 59AC 5386 1E1C 3A63 0 0
Sample Output
MAZE OK NO SOLUTION MAZE OK UNREACHABLE CELL MULTIPLE PATHS MULTIPLE PATHS
HINT
Source
题意：题意不难，就是看在构造迷宫后，对各种状况的判定，这题难度就在于构图吧，不过这个问题可以用二进制解决，每个方向的位左，下，右，上分别对应1,2,4,8,使用二进制1代表可行，0代表不可行即可
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <math.h>
#include <algorithm>
using namespace std;
#define ls 2*i
#define rs 2*i+1
#define up(i,x,y) for(i=x;i<=y;i++)
#define down(i,x,y) for(i=x;i>=y;i--)
#define mem(a,x) memset(a,x,sizeof(a))
#define w(a) while(a)
#define LL long long
const double pi = acos(-1.0);
#define Len 100005
int n,m;
int maze[65][65],sx,sy,ex,ey,flag;
char str[1000];
int to[4][3] = {1,0,2,-1,0,8,0,1,4,0,-1,1},vis[65][65];
struct node
{
int x,y;
};
int main()
{
int i,j,k;
while(~scanf("%d%d",&n,&m))
{
if(!n&&!m) break;
mem(vis,0);
up(i,1,n)
{
scanf("%s",str+1);
up(j,1,m)
{
vis[i][j];
if(str[j]>='0'&&str[j]<='9') maze[i][j] = str[j]-'0';
else maze[i][j]=str[j]-'A'+10;
maze[i][j]=~maze[i][j];//按位取反之后，除了不能走的路是0之外，其他位都是1了
}
}
sx = 0;
up(i,1,n)//对于每一行，我们看其左右边界，也就是和1,4相与的结果，为1的话证明这里是入口或者出口
{
if(maze[i][1]&1)
{
if(!sx) sx=i,sy=1;
else ex=i,ey=1;
}
if(maze[i][m]&4)
{
if(!sx) sx=i,sy=m;
else ex=i,ey=m;
}
}
up(i,1,m)//同上，不过这里是对于每一行看上下边界
{
if(maze[1][i]&8)
{
if(!sx) sx=1,sy=i;
else ex=1,ey=i;
}
if(maze[n][i]&2)
{
if(!sx) sx=n,sy=i;
else ex=n,ey=i;
}
}
int mul=0;
queue<node> Q;
node a,next;
a.x = sx;
a.y = sy;
Q.push(a);
vis[sx][sy] = 16;
while(!Q.empty())
{
a = Q.front();
Q.pop();
up(i,0,3)
{
if(vis[a.x][a.y]==to[i][2])continue;//所在点往to[i][2]方向已经访问过了
if(maze[a.x][a.y]&to[i][2])//该方向能够访问
{
next.x = a.x+to[i][0];
next.y = a.y+to[i][1];
if(next.x>=1 && next.x<=n && next.y>=1 && next.y<=m)
{
if(vis[next.x][next.y]) mul=1;
else
{
if(to[i][2]==1) vis[next.x][next.y] = 4;
else if(to[i][2]==4) vis[next.x][next.y] = 1;
else if(to[i][2]==2) vis[next.x][next.y] = 8;
else if(to[i][2]==8) vis[next.x][next.y] = 2;
Q.push(next);
}
}
}
}
}
if(vis[ex][ey])//能走到出口
{
flag = 0;
up(i,1,n)
{
up(j,1,m)
{
if(!vis[i][j])
{
flag = 1;
break;
}
}
if(flag)
break;
}
if(flag)//有一个点没访问到
printf("UNREACHABLE CELL\n");
else
{
if(mul) printf("MULTIPLE PATHS\n");//能出处并且有一个点能被重复访问，则输出多路
else printf("MAZE OK\n");//只有一条路
}
}
else//走不到出口
printf("NO SOLUTION\n");
}
return 0;
}