1. 广度优先搜索与深度优先搜索基础解析
在算法领域，广度优先搜索（BFS）和深度优先搜索（DFS）是两种最基础的图遍历算法。它们就像探索迷宫的两种不同策略：BFS会逐层向外扩展，像水波一样均匀扩散；而DFS则会沿着一条路径一直走到底，直到无路可走才回头尝试其他分支。
这两种算法在解决连通性问题时尤为有效，比如计算图中的连通分量数量、寻找最短路径等。下面我们通过两个实际案例来深入理解它们的应用场景和实现细节。
2. 湖泊计数问题：BFS的经典应用
2.1 问题描述与算法选择
题目要求统计二维矩阵中'W'字符组成的连通区域数量（每个连通区域代表一个湖泊）。这类"岛屿计数"问题非常适合使用BFS解决，因为：
- BFS能够系统地探索一个节点的所有相邻节点
- 可以确保不重复访问已探索的区域
- 算法时间复杂度为O(n×m)，与矩阵大小成线性关系
2.2 代码实现详解
cpp复制#include<iostream>
#include<vector>
#include<queue>
using namespace std;
int n, m;
int cnt = 0;
vector<vector<char>> arr;
// 8个方向数组：上、下、左、右、左上、右上、左下、右下
int dx[8] = { -1, 1, 0, 0, -1, -1, 1, 1 };
int dy[8] = { 0, 0, -1, 1, -1, 1, -1, 1 };
queue<pair<int, int>> q;
void bfs() {
while (!q.empty()) {
int x = q.front().first;
int y = q.front().second;
q.pop();
for (int i = 0; i < 8; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
// 边界检查+有效性检查
if (nx >= 1 && nx <= n && ny >= 1 && ny <= m && arr[nx][ny] == 'W') {
arr[nx][ny] = '.'; // 标记为已访问
q.push({nx, ny});
}
}
}
}
int main() {
cin >> n >> m;
arr.resize(n + 5, vector<char>(m + 5, '.'));
// 输入处理
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> arr[i][j];
}
}
// 主逻辑
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (arr[i][j] == 'W') {
q.push({i, j});
arr[i][j] = '.'; // 立即标记为已访问
bfs();
cnt++; // 找到一个新湖泊
}
}
}
cout << cnt;
return 0;
}
2.3 关键点解析
- 方向数组技巧：使用dx/dy数组表示8个相邻方向，比写8个if语句更简洁
- 访问标记：将访问过的'W'立即改为'.'，防止重复访问
- 队列使用：队列保证了按"广度优先"的顺序处理节点
- 边界检查：确保不会访问越界的位置
注意：在实际编程竞赛中，建议将方向数组定义为全局常量，避免重复初始化带来的性能损耗。
3. 字符串矩阵中的连通区域计数
3.1 问题变体与调整
第二个问题与第一个类似，但有几点关键区别：
- 输入使用字符串数组而非字符矩阵
- 索引从0开始而非1开始
- 只考虑4个方向（上、下、左、右）的连通性
3.2 代码实现对比
cpp复制#include<iostream>
#include<vector>
#include<queue>
using namespace std;
int n, m;
int cnt = 0;
queue<pair<int, int>> q;
vector<string> arr;
// 4个方向数组：上、下、左、右
int dx[4] = { 1, -1, 0, 0 };
int dy[4] = { 0, 0, 1, -1 };
void bfs() {
while (!q.empty()) {
int x = q.front().first;
int y = q.front().second;
q.pop();
for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
// 边界检查+有效性检查
if (nx >= 0 && nx < n && ny >= 0 && ny < m && arr[nx][ny] != '0') {
arr[nx][ny] = '0'; // 标记为已访问
q.push({nx, ny});
}
}
}
}
int main() {
cin >> n >> m;
arr.resize(n);
// 输入处理
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
// 主逻辑
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i][j] != '0') {
q.push({i, j});
arr[i][j] = '0'; // 立即标记为已访问
bfs();
cnt++;
}
}
}
cout << cnt;
return 0;
}
3.3 重要差异点
- 索引处理：字符串数组通常从0开始索引，需要调整边界条件
- 访问标记：使用'0'代替'.'作为标记字符
- 连通性定义：4连通与8连通会导致不同的计数结果
- 输入方式：直接读取字符串行，比逐个字符读取更高效
4. DFS实现方案与比较
4.1 DFS递归实现
虽然上述例子使用BFS，但这类问题同样可以用DFS解决。以下是DFS的递归实现：
cpp复制void dfs(int x, int y) {
arr[x][y] = '.'; // 标记为已访问
for (int i = 0; i < 8; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (nx >= 1 && nx <= n && ny >= 1 && ny <= m && arr[nx][ny] == 'W') {
dfs(nx, ny);
}
}
}
4.2 BFS与DFS的选择考量
| 特性 | BFS | DFS |
|---|---|---|
| 实现方式 | 队列 | 栈/递归 |
| 空间复杂度 | O(最大宽度) | O(最大深度) |
| 适用场景 | 最短路径问题 | 拓扑排序、连通性检查 |
| 递归深度 | 不适合极深结构 | 可能栈溢出 |
| 代码复杂度 | 略高 | 更简洁 |
提示：对于网格较大的情况，DFS递归实现可能导致栈溢出，此时应使用显式栈的迭代实现。
5. 常见问题与优化技巧
5.1 易错点排查
- 忘记标记已访问节点：会导致无限循环和重复计数
- 边界检查错误：数组越界是这类问题的常见错误
- 方向数组定义错误：漏掉某些方向或方向值错误
- 输入处理不当：特别是当使用不同索引起点时
5.2 性能优化建议
- 使用更紧凑的数据表示：对于大型矩阵，用bitset或位运算压缩存储
- 并行化处理：对于超大网格，可以考虑分块并行处理
- 循环展开：对方向循环进行展开优化
- 输入输出优化：使用更快的IO方法，如关闭同步、使用getchar等
5.3 变种问题扩展
- 统计每个连通区域的大小：在遍历时维护一个计数器
- 标记不同连通区域：用不同字符或数字标记不同区域
- 动态连通性问题：支持动态添加/删除障碍物
- 三维空间中的连通区域：扩展方向数组为6或26个方向
在实际编程竞赛中，这类连通性问题经常以各种形式出现。掌握BFS/DFS的核心思想并能够灵活变通，是解决许多图论问题的基础。我个人的经验是，先确保写出正确的基础实现，然后再考虑优化。过早优化往往会导致难以调试的错误。