对比dfs与bfs解决迷宫题目的区别

一天蒜头君掉进了一个迷官里面，蒜头君想逃出去，可怜的蒜头君连迷官是否有能逃出去的路都不知道。看在蒜头君这么可怜的份上,就请聪明的你告诉蒜头君是否有可以逃出去的路。

输入格式

第一行输入两个整数n和m,表示这是一个n X m的迷宫。
接下来的输入一个n行m列的迷宫。其中’S’ 表示蒜头君的位置’*’ 表示墙,蒜头君无法通过，’. ‘表示路,蒜头君可以通过’.'移动，‘T’ 示迷宫的出口(蒜头君每次只能移动到四个与他相邻的位置一上， 下, 左，右)。

输出格式
输出一个字符串，如果蒜头君可以逃出迷宫输出"yes"，否则输出"no"。

输入样例1：

3 4
S**.
..*.
***T

输出样例1：

no

输入样例2：

3 4
S**.
....
***T

输出样例2：

yes

深度优先搜索：

#include <iostream>
using namespace std;
int n, m;
bool vis[15][15];
char s[15][15];
int dir[4][2] = {{1, 0}, {-1, 0}, {0, -1}, {0, 1}};
bool flag;
bool in(int x, int y)
{
	return 0 <= x && x < m && 0 <= y && y < n;
}
void dfs(int x, int y)
{
	if (s[x][y] == 'T')
	{
		flag = 1;
		return;
	}
	vis[x][y] = 1;
	for (int i = 0; i < 4; i++)
	{
		int tx = x + dir[i][0];
		int ty = y + dir[i][1];
		if (!vis[tx][ty] && in(tx, ty) && s[x][y] != '*')
		{
			dfs(tx, ty);
		}
	}
}
int main()
{
	cin >> m >> n;
	for (int i = 0; i < m; i++)
	{
		scanf("%s", s[i]);
	}
	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j < n; j++)
		{
			if (s[i][j] == 'S')
			{
				dfs(i, j);
				break;
			}
		} 
	}
	if (flag)
	{
		cout << "yes" << endl;
	}
	else
	{
		cout << "no" << endl;
	}
	return 0;
}

广度优先搜索：

#include <iostream>
#include <queue>
using namespace std;
//使用结构体传递变量的值，相当于dfs中形参传递变量的值 
struct node {
    int x, y;
    node(int xx, int yy)
    {
        x = xx;
        y = yy;
    }
};
int dir[4][2] = {{1, 0}, {-1, 0}, {0, -1}, {0, 1}};
char s[15][15];
bool vis[15][15];
bool flag;
int n, m;
bool in(int x, int y)
{
	return 0 <= x && x < m && 0 <= y && y < n;
}
void bfs(int sx, int sy)
{
	queue<node> q;
	q.push(node(sx, sy));//以上两行充当dfs形参传递x, y变量的值 
	vis[sx][sy] = 1;
	while (!q.empty())
	{
		node now = q.front();
		q.pop();//访问当前位置并删除 
		for (int i = 0; i < 4; i++)//向四个方向搜索 
		{
			int tx = now.x + dir[i][0];
            int ty = now.y + dir[i][1];
            if (in(tx, ty) && s[tx][ty] != '*' && !vis[tx][ty])//满足条件 
            {
            	if (s[tx][ty] == 'T')//到达终点 
				{
					flag = 1;
					return;
				}
				else
				{
					vis[tx][ty] = 1;//标记下一个位置 
					q.push(node(tx, ty));//充当dfs的形参传值，下一次循环相当于dfs的递归调用 
				}
			}
		}
	}
}
int main()
{
	cin >> m >> n;
	for (int i = 0; i < m; i++)
	{
		scanf("%s", s[i]);
	}
	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j < n; j++)
		{
			if (s[i][j] == 'S')
			{
				bfs(i, j);
				break;
			}
		} 
	}
	if (flag)
	{
		cout << "yes" << endl;
	}
	else
	{
		cout << "no" << endl;
	}
	return 0;
}

说到底，两种方法本质上是区别只有一点。
一个利用栈实现，一个利用队列实现。
因为函数本质上就是栈，而dfs递归调用自己就是不断把下一次搜索压入栈中，bfs通过队列利用循环，把下一次搜索放入队列中（只要有符合条件的情况，就删除目前状态，即树的层次遍历，因而常用来求最短路径）。
我觉得我可能没有描述清楚，希望各位大佬不要取笑我。
OTL