张辰LMY1. 图的遍历基础概念
图（Graph）是数据结构中最复杂也最有趣的一种形式，它由顶点（Vertex）和边（Edge）组成，能够表示现实世界中各种复杂关系。在解决P3916这类题目时，我们首先需要明确几个关键概念：
图的遍历是指从图中某一顶点出发，按照某种搜索策略系统地访问图中所有顶点，且每个顶点仅被访问一次的过程。与树形结构的遍历不同，图的遍历面临两个特殊挑战：
- 图中可能存在环路，需要避免重复访问
- 非连通图中某些顶点可能无法从起始顶点到达
在算法竞赛和实际工程中，最常用的两种遍历方法是深度优先搜索（DFS）和广度优先搜索（BFS）。选择哪种方法往往取决于具体问题的需求：
- DFS适合寻找路径、检测环路、拓扑排序等场景
- BFS适合最短路径、层级遍历等场景
实际编程中，图的表示方式会极大影响遍历效率。邻接表（Adjacency List）因其空间效率和高查询性能，成为大多数场景的首选，特别是对于稀疏图。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 深度优先搜索（DFS）实现细节
2.1 递归实现方案
递归实现DFS是最直观的方式，代码简洁但需要注意栈溢出风险。以下是标准实现模板：
cpp复制vector<int> adj[MAXN]; // 邻接表存储图
bool visited[MAXN]; // 访问标记数组
void dfs(int u) {
visited[u] = true;
// 处理顶点u的业务逻辑
for(int v : adj[u]) {
if(!visited[v]) {
dfs(v);
}
}
}
关键细节说明：
- 使用
visited数组避免重复访问，对于顶点编号不连续的情况可改用unordered_set - 邻接表的构建要注意题目给出的边是否有方向
- 递归深度过大时（约>1e5层）可能引发栈溢出
2.2 非递归实现方案
使用显式栈替代函数调用栈，既避免了递归深度限制，又便于控制遍历过程：
cpp复制void dfs_iterative(int start) {
stack<int> s;
s.push(start);
visited[start] = true;
while(!s.empty()) {
int u = s.top();
s.pop();
// 处理顶点u
for(int v : adj[u]) {
if(!visited[v]) {
visited[v] = true;
s.push(v);
}
}
}
}
实际测试表明，非递归版本在处理大规模图时（顶点数>1e5）性能更稳定。在竞赛中建议准备两种实现方式。
3. 广度优先搜索（BFS）核心实现
3.1 标准BFS模板
BFS天然适合求解无权图的最短路径问题，以下是经典实现：
cpp复制void bfs(int start) {
queue<int> q;
q.push(start);
visited[start] = true;
while(!q.empty()) {
int u = q.front();
q.pop();
// 处理顶点u
for(int v : adj[u]) {
if(!visited[v]) {
visited[v] = true;
q.push(v);
}
}
}
}
3.2 层级记录技巧
在解决类似P3916的问题时，经常需要记录每个顶点的访问层级（即距离起始点的边数）。改进版BFS：
cpp复制int dist[MAXN]; // 记录每个顶点的距离
void bfs_level(int start) {
queue<int> q;
q.push(start);
visited[start] = true;
dist[start] = 0; // 起始点距离为0
while(!q.empty()) {
int u = q.front();
q.pop();
for(int v : adj[u]) {
if(!visited[v]) {
visited[v] = true;
dist[v] = dist[u] + 1;
q.push(v);
}
}
}
}
这个变种在解决"从某点出发能到达的最远顶点"等问题时非常有用。
4. P3916题目的特殊解法
4.1 反向图构建技巧
P3916题目要求的是对于每个顶点v，求从v出发能够到达的编号最大的顶点。直接正向处理需要对每个顶点做一次遍历，时间复杂度O(N^2)无法通过大规模测试。
高效解法是构建反向图，然后按顶点编号从大到小进行遍历：
- 建立原图的反向边（即所有边方向反转）
- 初始化所有顶点的答案为自身编号
- 按编号从大到小依次访问顶点u：
- 如果u未被访问，从u开始BFS/DFS
- 遍历过程中所有到达的顶点v，其答案更新为max(ans[v], u)
cpp复制vector<int> adj[MAXN]; // 原图邻接表
vector<int> radj[MAXN]; // 反向图邻接表
int ans[MAXN];
void solve() {
// 初始化ans数组
for(int i = 1; i <= N; ++i) {
ans[i] = i;
}
// 按编号降序处理
for(int u = N; u >= 1; --u) {
if(!visited[u]) {
stack<int> s;
s.push(u);
visited[u] = true;
while(!s.empty()) {
int cur = s.top();
s.pop();
for(int v : radj[cur]) {
if(!visited[v]) {
visited[v] = true;
ans[v] = max(ans[v], u);
s.push(v);
}
}
}
}
}
}
4.2 算法正确性证明
这种解法之所以正确，基于以下观察：
- 在反向图中，如果u能到达v，意味着在原图中v能到达u
- 按编号降序处理，确保每个顶点被其能到达的最大编号顶点标记
- 每个顶点只需处理一次，时间复杂度优化为O(N+M)
4.3 性能优化实践
在实际编码中，还需要注意以下优化点：
- 使用更快的输入输出方式（如C风格的scanf/printf）
- 对于稠密图，考虑使用邻接矩阵的位压缩表示
- 合理预估数组大小，避免越界访问
- 在OJ系统中，全局变量会自动初始化为0，但本地测试时需要手动初始化
cpp复制// 快速IO示例
void fast_io() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
}
int main() {
fast_io();
// 读取输入
cin >> N >> M;
for(int i = 0; i < M; ++i) {
int u, v;
cin >> u >> v;
radj[v].push_back(u); // 构建反向图
}
solve();
// 输出结果
for(int i = 1; i <= N; ++i) {
cout << ans[i] << " ";
}
return 0;
}
5. 图的遍历进阶技巧
5.1 记忆化搜索应用
对于某些特定问题，可以结合记忆化技术优化遍历过程。例如在求解每个顶点能到达的最大编号时，可以记录中间结果：
cpp复制int memo[MAXN]; // 记忆化数组
int dfs_memo(int u) {
if(memo[u] != -1) return memo[u];
int max_v = u;
for(int v : adj[u]) {
max_v = max(max_v, dfs_memo(v));
}
return memo[u] = max_v;
}
5.2 多源BFS技巧
当需要从多个起点同时开始遍历时，可以初始化队列包含所有起点，并设置合适的初始距离：
cpp复制void multi_source_bfs(vector<int>& starts) {
queue<int> q;
for(int s : starts) {
q.push(s);
visited[s] = true;
dist[s] = 0;
}
while(!q.empty()) {
int u = q.front();
q.pop();
for(int v : adj[u]) {
if(!visited[v]) {
visited[v] = true;
dist[v] = dist[u] + 1;
q.push(v);
}
}
}
}
5.3 双向BFS优化
当目标是从起点找到特定终点的路径时，可以同时从起点和终点开始搜索，直到两边的搜索相遇：
cpp复制int bidirectional_bfs(int start, int target) {
if(start == target) return 0;
queue<int> q1, q2;
unordered_map<int, int> vis1, vis2;
q1.push(start); vis1[start] = 0;
q2.push(target); vis2[target] = 0;
while(!q1.empty() || !q2.empty()) {
if(!q1.empty()) {
int u = q1.front(); q1.pop();
for(int v : adj[u]) {
if(vis2.count(v)) {
return vis1[u] + 1 + vis2[v];
}
if(!vis1.count(v)) {
vis1[v] = vis1[u] + 1;
q1.push(v);
}
}
}
if(!q2.empty()) {
int u = q2.front(); q2.pop();
for(int v : adj[u]) {
if(vis1.count(v)) {
return vis2[u] + 1 + vis1[v];
}
if(!vis2.count(v)) {
vis2[v] = vis2[u] + 1;
q2.push(v);
}
}
}
}
return -1; // 不可达
}
6. 实际应用中的注意事项
6.1 栈溢出问题处理
在深度较大的图上运行DFS时，递归版本可能导致栈溢出。解决方法包括：
- 改用非递归实现
- 调整编译器栈大小（竞赛中通常不可行）
- 使用ulimit命令增加栈空间（Linux系统）
bash复制# 临时设置栈空间为256MB
ulimit -s 262144
6.2 访问标记的优化
传统的visited数组在顶点编号范围很大但不连续时（如使用字符串作为顶点ID）会浪费空间。替代方案：
- 使用
unordered_set存储已访问顶点 - 使用时间戳标记法（适用于多次遍历场景）
- 对于特定问题，可以利用问题的特殊性质优化
6.3 内存访问优化
现代CPU的缓存机制使得连续内存访问比随机访问快得多。在实现邻接表时：
- 使用单个大数组存储所有边，而不是为每个顶点动态分配
- 对于静态图，可以预先排序邻接表提高缓存命中率
- 使用紧凑的数据结构如
vector<vector<int>>而非链表
cpp复制// 内存友好的邻接表实现
vector<int> edges;
vector<int> head[MAXN];
void add_edge(int u, int v) {
edges.push_back(v);
head[u].push_back(edges.size() - 1);
}
6.4 并行遍历算法
对于超大规模图，可以考虑并行化遍历过程。OpenMP实现示例：
cpp复制#pragma omp parallel for
for(int u = 1; u <= N; ++u) {
if(!visited[u]) {
#pragma omp critical
{
if(!visited[u]) {
visited[u] = true;
// 开始遍历
dfs(u);
}
}
}
}