BTTCOJ 问题 B: 迷宫 广度优先搜索

题目描述

Johon在迷宫内游玩，现在他需要从A点出发，按顺序经过B,C,D……，到达迷宫内的最后一个字母所在的点，最后再回到A点。迷宫内有些障碍，请问Johon至少走几步才能完成？
游玩规则和条件：
迷宫用二维字符矩阵表示。并且只含有大写字母、0和2这几种符号。其中，2表示障碍不可以行走，0表示可以走。大写字母也可以走。
Johon开始的时候会在A字母的位置。
Johon每次只能向四个直接相邻的某个的方向走一步（即上、下、左、右。前提是如果可以走）。
数据保证每个字母在每组测试数据中最多出现一次。
Johon必须依次从A到B，然后从B到C，然后…，然后从某字母再到A。也就是说，如果字母序列是间断的（例如ABC FGH），Johon将无法完成游玩。
从某字母到另一个字母的行走过程中，可以路过其他字母。例如A到B时候可以路过C。

输入格式

第一行有二个数n，m表示迷宫有n行，m列(1<=n<=100，1<=m<=100)。
第2行到第n+1行，每行输入m个字符，可能是大写字母、符号2或者符号0。

输出格式

输出至少走几步可以按规定走完，如果不行，输出“Impossible”。

输入样例

5 5
A002B
022C0
000D0
00222
0000E

输出样例

26

解题思路

感觉就是一道普通的广搜，结果做的时候wa了好几次才发现细节还不少，要注意数据范围，有A和没有A的情况，每次搜完都要保证清空之前的数据

AC代码

#include <bits/stdc++.h>
using namespace std;
const int maxn=105;
int N,M;
char mp[maxn][maxn];
int book[maxn][maxn];//标记走过的路
int dir[4][2]={1,0,-1,0,0,1,0,-1};
struct cp{int x,y,flog;}zm[27];//字母数组，注意每次使用要初始化
int ans,k;//k用来标记总字母数
struct st{int x;int y;int t;st(int xx,int yy,int tt):x(xx),y(yy),t(tt){}};
queue <st> myq;
bool check_Impossible()//判断字母连贯性
{
    int temp=0;
    for(int i=26;i>=0;i--)
    {
        if(zm[i].flog==1&&temp==0)
        {
            k=i+1;
            temp=1;
        }
        if(temp==1&&zm[i].flog==0)
        {
            return true;
        }
    }
    return false;
}
int bfs(int x,int y,int fx,int fy)
{
    while(!myq.empty())
    {
        myq.pop();
    }
    myq.push(st(x,y,0));
    book[x][y]=1;
    while(!myq.empty())
    {
        struct st temp=myq.front();
        myq.pop();
        for(int i=0;i<4;i++)
        {
            int tx=temp.x+dir[i][0];
            int ty=temp.y+dir[i][1];
            if(tx<0||ty<0||tx>=N||ty>=M||mp[tx][ty]=='2'||book[tx][ty]==1)
            {
                continue;
            }
            if(tx==fx&&ty==fy)
            {
                return temp.t+1;
            }
            book[tx][ty]=1;
            myq.push(st(tx,ty,temp.t+1));
        }
    }
    return -1;
}
int main()
{
    while(cin>>N>>M)
    {
        int i=0;i<27;i++)//初始化字母
            zm[i].flog=0;
        for(int i=0;i<N;i++)
            for(int j=0;j<M;j++)
            {
                cin>>mp[i][j];
                if(mp[i][j]>='A'&&mp[i][j]<='Z')
                {
                    zm[mp[i][j]-'A'].x=i;
                    zm[mp[i][j]-'A'].y=j;
                    zm[mp[i][j]-'A'].flog=1;
                }
            }
        if(!check_Impossible())//可以尝试走
        {
            if(k==1)//如果只有一个A的情况
            {
                cout<<0<<endl;
                continue;
            }
            ans=0;//统计总步数
            int v=1;
            for(int i=0;i<=k-2;i++)
            {
                memset(book,0,sizeof(book));
                int tt=bfs(zm[i].x,zm[i].y,zm[i+1].x,zm[i+1].y);//搜索A-N
                if(tt!=-1)
                {
                    ans+=tt;
                }
                else
                {
                    cout<<"Impossible"<<endl;
                    v=0;
                    break;
                }
            }
            if(v==0)
            {
                continue;
            }
            else
            {
                memset(book,0,sizeof(book));
                int tt=bfs(zm[k-1].x,zm[k-1].y,zm[0].x,zm[0].y);//搜索N-A
                if(tt==-1)
                {
                    cout<<"Impossible"<<endl;
                    continue;
                }
                else
                ans+=tt;
            }
            cout<<ans<<endl;
        }
        else//字母不连贯，不能走
        {
            cout<<"Impossible"<<endl;
        }
    }
    return 0;
}