对比DFS、BFS求连通块问题

许多连通块问题既可以用BFS求解也可以用DFS求解，两者各有优缺点。

BFS求解：可以求出最短路或者判断两者是否连通，不存在爆栈的风险，但空间相对用的多一些而且代码相对来说繁琐一些。

DFS求解：DFS代码简洁，相对好写一些，但存在爆栈的风险，而且不能求出最短路。

使用DFS、BFS实现Flood Fill

Acwing 1112. 迷宫

一天Extense在森林里探险的时候不小心走入了一个迷宫，迷宫可以看成是由 n∗n 的格点组成，每个格点只有2种状态，.和#，前者表示可以通行后者表示不能通行。

同时当Extense处在某个格点时，他只能移动到东南西北(或者说上下左右)四个方向之一的相邻格点上，Extense想要从点A走到点B，问在不走出迷宫的情况下能不能办到。

如果起点或者终点有一个不能通行(为#)，则看成无法办到。

注意：A、B不一定是两个不同的点。

输入格式

第1行是测试数据的组数 k，后面跟着 k 组输入。

每组测试数据的第1行是一个正整数 n，表示迷宫的规模是 n∗n 的。

接下来是一个 n∗n 的矩阵，矩阵中的元素为.或者#。

再接下来一行是 4 个整数 ha,la,hb,lb，描述 A 处在第 ha 行, 第 la 列，B 处在第 hb 行, 第 lb 列。

注意到 ha,la,hb,lb 全部是从 0 开始计数的。

输出格式

k行，每行输出对应一个输入。

能办到则输出“YES”，否则输出“NO”。

数据范围

1≤n≤100

输入样例：

2
3
.##
..#
#..
0 0 2 2
5
.....
###.#
..#..
###..
...#.
0 0 4 0

输出样例:

YES
NO 

通过以下代码的对比，显而易见，DFS更短，而且时间上基本相同。

BFS

//BFS实现
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>

#define x first
#define y second

using namespace std;
typedef pair<int, int> PII;

const int N = 110;
int n;
char g[N][N];
bool st[N][N];
int xa, ya, xb, yb;

int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};

bool bfs()
{
    if(g[xa][ya] == '#' || g[xb][yb] == '#') return false;
    
    queue<PII> q;
    q.push({xa, ya});
    st[xa][ya] = true;
    
    
    while(q.size())
    {
        PII t = q.front();
        q.pop();
        
              
        for(int i = 0 ;i < 4; i ++ )
        {
            int a = t.x + dx[i], b = t.y + dy[i];
            if(a < 0 || a >= n || b < 0 || b >= n ) continue;
            if(st[a][b] || g[a][b] == '#') continue;
            
            q.push({a, b});
            st[a][b] = true;
        }
        
        if(st[xb][yb] == true) return true;
       
    }
    return false;
}
int main()
{
    int T;
    cin >> T;
    while(T -- )
    {
        cin >> n;
        for(int i = 0; i < n; i ++ ) cin >> g[i];
        
        memset(st, 0, sizeof st);
        
        cin >> xa >> ya >> xb >> yb;
        
        if(bfs()) puts("YES");
        else puts("NO");
    }
    return 0;
}

DFS

//DFS实现
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
const int N = 110;
int xa, ya, xb, yb;
int n;
bool st[N][N];
char g[N][N];
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
bool dfs(int x, int y)
{
    if(g[x][y] == '#') return false;
    if(x == xb && y == yb) return true;

    st[x][y] = true;

    for(int i = 0; i < 4; i ++ )
    {
        int a = x + dx[i], b = y + dy[i];
        if(a < 0 || a >= n || b < 0 || b >= n) continue;
        if(st[a][b]) continue;

        if(dfs(a, b)) return true;
    }
    return false;
}
int main()
{
    int T;
    cin >> T;
    while(T -- )
    {
        cin >> n;
        for(int i = 0; i < n; i ++ ) cin >> g[i];

        memset(st, 0, sizeof st);

        cin >> xa >> ya >> xb >> yb;

        if(dfs(xa, ya)) puts("YES");
        else puts("NO");

    }
    return 0;
}