GESP七级图论：DFS与BFS算法详解与应用

1. 项目概述

作为一名长期从事算法教学和竞赛辅导的C++开发者，我发现很多准备GESP七级考试的学生在图论基础部分存在明显的知识断层。图论作为计算机科学的核心基础，在GESP七级考试中占据重要地位，特别是图的遍历算法DFS（深度优先搜索）和BFS（广度优先搜索）更是必考重点。本文将系统梳理考试大纲要求的图论知识体系，并结合典型考题分析遍历算法的实现要点。

2. 图论基础概念解析

2.1 图的定义与分类

图(Graph)是由顶点(Vertex)和边(Edge)组成的非线性数据结构，数学上表示为G=(V,E)。在C++实现中，我们通常用以下两种方式表示图：

1. 邻接矩阵：适用于稠密图

cpp复制const int MAXN = 100;
int graph[MAXN][MAXN];  // 矩阵元素表示边权

2. 邻接表：适用于稀疏图

cpp复制vector<vector<int>> adjList;  // 每个顶点维护一个邻居列表

根据边的特性，图可分为：

• 无向图：边没有方向性
• 有向图：边有明确方向
• 加权图：边带有权值

2.2 图的基本术语

理解以下术语对解题至关重要：

• 度(Degree)：与顶点相连的边数
• 路径(Path)：顶点序列使得相邻顶点间都有边
• 连通图：任意两顶点间都存在路径
• 完全图：每对顶点之间都有边相连

3. 图的遍历算法详解

3.1 深度优先搜索(DFS)

DFS采用"一条路走到黑"的策略，使用栈结构（递归隐式使用调用栈）实现：

cpp复制void dfs(int node, vector<bool>& visited, const vector<vector<int>>& graph) {
    visited[node] = true;
    for (int neighbor : graph[node]) {
        if (!visited[neighbor]) {
            dfs(neighbor, visited, graph);
        }
    }
}

典型应用场景：

• 拓扑排序
• 寻找连通分量
• 检测图中环的存在

注意：递归实现可能导致栈溢出，对于大型图建议使用显式栈的非递归实现

3.2 广度优先搜索(BFS)

BFS采用"层层推进"的策略，使用队列结构实现：

cpp复制void bfs(int start, vector<bool>& visited, const vector<vector<int>>& graph) {
    queue<int> q;
    q.push(start);
    visited[start] = true;
    
    while (!q.empty()) {
        int node = q.front();
        q.pop();
        for (int neighbor : graph[node]) {
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                q.push(neighbor);
            }
        }
    }
}

典型应用场景：

• 最短路径问题（无权图）
• 社交网络中的好友推荐
• 网页爬虫的URL抓取

4. 算法对比与选择策略

4.1 DFS与BFS对比

4.2 选择策略

根据问题特点选择合适算法：

1. 需要探索所有可能性（如排列组合）→ DFS
2. 寻找最短路径（无权图）→ BFS
3. 检测环路 → DFS+访问状态记录
4. 连通分量统计 → 两者皆可，DFS通常更节省空间

5. 常见问题与调试技巧

5.1 内存溢出问题

当处理大型图时，递归DFS可能导致栈溢出。解决方案：

1. 改用非递归DFS实现
2. 增加栈空间（不推荐，考试环境可能限制）
3. 使用BFS替代

5.2 访问标记重置

在多轮遍历时容易忘记重置visited数组，导致错误结果。建议：

cpp复制vector<bool> visited(n, false);  // 每次遍历前重新初始化

5.3 特殊输入处理

考试中常见边界情况：

• 空图（0个顶点）
• 单顶点图
• 完全图
• 不连通图

6. 典型考题分析

6.1 连通分量计数

题目要求：给定无向图，计算连通分量数量

解法：对每个未访问顶点执行DFS/BFS

cpp复制int countComponents(int n, vector<vector<int>>& edges) {
    vector<vector<int>> graph(n);
    for (auto& e : edges) {
        graph[e[0]].push_back(e[1]);
        graph[e[1]].push_back(e[0]);
    }
    
    vector<bool> visited(n, false);
    int count = 0;
    for (int i = 0; i < n; ++i) {
        if (!visited[i]) {
            dfs(i, visited, graph);
            ++count;
        }
    }
    return count;
}

6.2 拓扑排序

题目要求：判断有向图是否能完成拓扑排序（无环）

解法：DFS+访问状态标记

cpp复制bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
    vector<vector<int>> graph(numCourses);
    for (auto& p : prerequisites) {
        graph[p[1]].push_back(p[0]);
    }
    
    vector<int> visited(numCourses, 0);  // 0:未访问, 1:访问中, 2:已访问
    for (int i = 0; i < numCourses; ++i) {
        if (hasCycle(i, visited, graph)) {
            return false;
        }
    }
    return true;
}

bool hasCycle(int node, vector<int>& visited, vector<vector<int>>& graph) {
    if (visited[node] == 1) return true;
    if (visited[node] == 2) return false;
    
    visited[node] = 1;
    for (int neighbor : graph[node]) {
        if (hasCycle(neighbor, visited, graph)) {
            return true;
        }
    }
    visited[node] = 2;
    return false;
}

7. 性能优化技巧

1. 邻接表优于邻接矩阵：除非题目明确要求或图非常稠密
2. 预分配内存：避免vector动态扩容带来的性能损耗
3. 减少函数调用：简单图操作可内联实现
4. 位运算优化：对于小规模图，可用bitset代替bool数组

我在实际教学中发现，很多学生容易混淆DFS和BFS的应用场景。一个简单的记忆方法是：当问题需要"深入挖掘"时用DFS，需要"广泛覆盖"时用BFS。例如，寻找迷宫出口的最短路径用BFS，而枚举所有可能的迷宫路径则用DFS。