走迷宫（dfs与bfs）

描述

给一张个迷宫，问能否从起点走到终点，只能往上下左右走，不能斜着走

输入

多组测试数据，每组第一行两个正整数，分别为n和m

表示n这个迷宫有n行m列(0

接着是n行m列，

'#'表示路

‘*’表示墙

‘S’表示起点

‘T’表示终点

输出

每组测试数据输出一个结果，如果能从S走到T，输出“YES”,否则输出“NO”

输入样例 1 

2 2
S*
#T
3 3
S*#
#*T
##*

输出样例 1

YES
NO

DFS代码（递归）

#include 

using namespace std;
const int Max=15;
int vist[Max][Max];  \\记录是否访问过
char Map[Max][Max];  
int dx[]= {-1,0,0,1};  \\访问左右
int dy[]= {0,1,-1,0};  \\访问上下
int flag,n,m;

void dfs(int x,int y)
{
    vist[x][y]=1;
    if (Map[x][y]=='T')
    {
        flag=1;
        return ;
    }
    for (int i=0; i<4; i++)
    {
        int tx=dx[i]+x;
        int ty=dy[i]+y;
        if(tx>=0&&tx=0&&vist[tx][ty]==0&&Map[tx][ty]!='*')  \\未访问过
        {                                                                \\并且可以访问
            dfs(tx,ty);
        }
    }
}

int main()
{
    while (cin>>n>>m)
    {
        flag=0;
        memset(vist,0,sizeof(vist));
        memset(Map,'*',sizeof(Map));
        for (int i=0; i>Map[i];
        }
        int a,b;
        for (int i=0; i

BFS代码（队列）

#include 
using namespace std;

const int Max=20;
int dx[]= {-1,0,1,0};
int dy[]= {0,-1,0,1};
char mp[Max][Max];
int flag,n,m;

struct point
{
    int x,y;
};

void bfs(int a,int b)
{
    queue  q;
    point start,next; \\起始点和下一点
    start.x=a;
    start.y=b;
    q.push(start);
    while(!q.empty())
    {
        start=q.front();
        q.pop();
        for(int i=0; i<4; i++)
        {
            next.x=start.x+dx[i];
            next.y=start.y+dy[i];
            if(mp[next.x][next.y]=='T')
            {
                flag=1;
                break;
            }
            if(next.x=0&&next.y=0&&mp[next.x][next.y]=='#')
            {
                mp[next.x][next.y]='*';
                q.push(next);
            }
        }
    }
}


int main()
{
    while(cin>>n>>m)
    {
        memset(mp,'*',sizeof(mp));
        for(int i=0; i>mp[i];
        int a,b;
        for(int i=0; i