NYOJ 迷宫寻宝（一）

迷宫寻宝（一）
时间限制：1000 ms | 内存限制：65535 KB
难度：4
描述
一个叫ACM的寻宝者找到了一个藏宝图，它根据藏宝图找到了一个迷宫，这是一个很特别的迷宫，迷宫里有N个编过号的门（N<=5)，它们分别被编号为A,B,C,D,E.为了找到宝藏，ACM必须打开门，但是，开门之前必须在迷宫里找到这个打开这个门所需的所有钥匙（每个门都至少有一把钥匙），例如：现在A门有三把钥匙，ACM就必须找全三把钥匙才能打开A门。现在请你编写一个程序来告诉ACM，他能不能顺利的得到宝藏。



输入
输入可能会有多组测试数据（不超过10组）。
每组测试数据的第一行包含了两个整数M,N(1<N,M<20)，分别代表了迷宫的行和列。接下来的M每行有N个字符，描述了迷宫的布局。其中每个字符的含义如下：
.表示可以走的路
S:表示ACM的出发点
G表示宝藏的位置
X表示这里有墙，ACM无法进入或者穿过。
A,B,C,D,E表示这里是门，a,b,c,d,e表示对应大写字母的门上的钥匙。
注意ACM只能在迷宫里向上下左右四个方向移动。

最后，输入0 0表示输入结束。
输出
每行输出一个YES表示ACM能找到宝藏，输出NO表示ACM找不到宝藏。
样例输入
4 4
S.X.
a.X.
..XG
....
3 4
S.Xa
.aXB
b.AG
0 0
样例输出
YES

NO

 

这一题写了一天。。。遍历图其实有两种方法，一种是bfs(宽度优先搜索)，另一种dfs(深度优先搜索)，像这种图的遍历一般建议用bfs,两种方法具体实现没法跟你讲，自己查资料或浏览以下AC代码。本题的思路是这样的，先从‘S’出发调用bfs，实时判断是否到达‘G’，找到了最好，如果未找到怎么办呢？就是得判断有没有出现过无法通过的门。所以这就需要用数组记录下之前无法通过的门，然后再遍历这些门，如果遇到一些门找到钥匙则以该门为起点继续调用bfs，如此往复。所以这是个好题。代码以注释

 

AC代码：
 

 

/*以下代码在下原创，如有不足多多指正*/
 
# include <stdio.h>
# include <string.h>
# include <ctype.h>
# include <stdlib.h>
# include <queue>
using namespace std;  

queue<int> q;

int m, n;
int vis[50][50];
int a[200];
int des[200];
char g[50][50];
//这个结构体的作用就是用来记录当时遇到门时，没足够钥匙的门
struct node{
	int r;
	int c;
	int flage;//先前遇到打不开的门，还未处理时记为1 ，处理后记为零
};
 
int x[4]={0, 0, 1, -1};
int y[4]={1, -1, 0, 0};
int cnt, Find, Flage;
struct node s[410];
//init()函数进行初始化，就是在外围加一圈'X' 
//这样做感觉便于操作，不用判断边界 
void init(){
	for(int i=0; i<=n+1; i++){
		g[0][i]='X';
	}
	for(int i=1; i<=m; i++){
		g[i][0]='X';g[i][n+1]='X';
	}
	for(int i=0; i<=n+1; i++){
		g[m+1][i]='X';
	}
} 
void bfs(){//宽度优先搜索函数 
	int r, c, num;
	while(!q.empty()){
	    num=q.front(); 
	    q.pop();
	    r=num/n+1;
	    c=num%n;
	    if(c==0){
	    	r--;
	    	c=n;
		}
		for(int i=0; i<=3; i++){
			if(g[r+x[i]][c+y[i]]=='G'){
				Find=1;//找到'G' 
				return;
			}
			if(!vis[r+x[i]][c+y[i]]){
				if(isalpha(g[r+x[i]][c+y[i]])){//g[i][j]为字母 
				    if(g[r+x[i]][c+y[i]]>='a'){//找到一把钥匙 
				    	a[g[r+x[i]][c+y[i]]]++;//总数加一 
				    	g[r+x[i]][c+y[i]]='.';//化为'.' ,即可行的路 
				    	vis[r+x[i]][c+y[i]]=1;
				    	q.push((r+x[i]-1)*n+c+y[i]);
					}
				    else if(g[r+x[i]][c+y[i]]<='E'){//遇到门 
				    	if(a[g[r+x[i]][c+y[i]]+32]==des[g[r+x[i]][c+y[i]]+32]){
				    		//如果钥匙数已经够可以开门 
				    		g[r+x[i]][c+y[i]]='.';
				    		vis[r+x[i]][c+y[i]]=1;
				    		q.push((r+x[i]-1)*n+c+y[i]);
						}
						else{
							//如果钥匙数还不够，记录一下门的位置 
							s[cnt].r=r+x[i];s[cnt].c=c+y[i];s[cnt].flage=1;
							cnt++;
						}
					}
				    
				}
				else{
					vis[r+x[i]][c+y[i]]=1;
					q.push((r+x[i]-1)*n+c+y[i]);
				}
			}
		}
	}
	return;
}
int main(){
	int i, j, k, b_r, b_c, temp1, temp2, no;
	while(scanf("%d%d", &m, &n)){
		getchar();
		if(m==0&&n==0){
			break;
		}
		for(i=1; i<=m; i++){
			scanf("%s", g[i]+1);
		}
		init();
		while(!q.empty()){//队列初始化清空 
			q.pop();
		}
		memset(vis, 0, sizeof(vis));
		memset(a, 0, sizeof(a));
		memset(des, 0, sizeof(des));
		cnt=0;Find=0;Flage=1;
		for(i=1; i<=m; i++){
			for(j=1; j<=n; j++){
				if(g[i][j]=='S'){
					b_r=i;b_c=j;
				}
				if(isalpha(g[i][j])&&g[i][j]>='a'){
					des[g[i][j]]++;//记录门对应的钥匙总数 
				}
			}
		}
		g[b_r][b_c]='.';
		vis[b_r][b_c]=1;
		no=(b_r-1)*n+b_c;
		q.push(no);
		bfs();//从'S'点开始调用bfs 
		while(!Find&&Flage){
			//Find！=1时表示还没找到'G'；
			// Flage==1时表示之前有一个无法通过的门现在找到钥匙
			//则以这个门为起点再次调用bfs 
			Flage=0;
			for(i=0; i<=cnt-1; i++){
				temp1=s[i].r;temp2=s[i].c;
				if(g[temp1][temp2]>='A'&&g[temp1][temp2]<='E'&&s[i].flage&&a[g[temp1][temp2]+32]==des[g[temp1][temp2]+32]){
					s[i].flage=0;
					Flage=1;
					break;
				}
			}
			if(Flage){
				memset(vis, 0, sizeof(vis));
				g[temp1][temp2]='.';
				vis[temp1][temp2]=1;
				while(!q.empty()){
					q.pop();
				}
				q.push((temp1-1)*n+temp2);
				bfs();
			}
		}
		if(Find){//Find==1表示找到 
			printf("YES\n");
		}
		else{
			printf("NO\n");
		}
	}
	return 0;
}