CF427C Checkposts(tarjan求强连通)

### Tarjan算法实现强连通分量的详细步骤 Tarjan算法是一种基于深度优先搜索（DFS）的方法，用于寻找有向图中的强连通分量。以下是其实现的核心逻辑： #### 1. 定义关键变量 - **dfn[u]**：表示节点 `u` 的访问时间戳，在 DFS 遍历时记录每个节点第一次被访问的时间。 - **low[u]**：表示节点 `u` 能够回溯到的最早祖先节点的访问时间戳。 这些变量帮助我们判断当前子图是否构成一个强连通分量[^1]。 #### 2. 构建辅助数据结构 - 使用栈来存储当前路径上的节点，当发现某个节点满足条件时，可以弹出栈中属于同一强连通分量的所有节点。 #### 3. 深度优先搜索过程 在 DFS 过程中，对于每一个未访问过的节点 `u`： - 初始化 `dfn[u]` 和 `low[u]` 均为当前时间戳。 - 将节点 `u` 入栈并标记为已访问。 - 对于 `u` 的所有邻接点 `v`： - 如果 `v` 尚未被访问，则递归调用 DFS 并更新 `low[u] = min(low[u], low[v])`。 - 如果 `v` 已经在栈中，则说明存在一条指向祖先的反向边，此时应更新 `low[u] = min(low[u], dfn[v])`。 #### 4. 判断强连通分量 如果 `dfn[u] == low[u]`，则表明以 `u` 为根的子树构成了一个新的强连通分量。此时可以从栈中依次弹出节点直到弹出 `u`，并将它们作为一个独立的强连通分量保存下来[^2]。 --- ### Java代码示例 以下是一个完整的 Java 实现示例： ```java import java.util.*; public class TarjanSCC { private static int index; private static Stack<Integer> stack; public static List<List<Integer>> tarjan(List<List<Integer>> graph, int n) { int[] dfn = new int[n]; Arrays.fill(dfn, -1); int[] low = new int[n]; boolean[] onStack = new boolean[n]; stack = new Stack<>(); List<List<Integer>> sccs = new ArrayList<>(); for (int i = 0; i < n; i++) { if (dfn[i] == -1) { dfs(i, graph, dfn, low, onStack, sccs); } } return sccs; } private static void dfs(int u, List<List<Integer>> graph, int[] dfn, int[] low, boolean[] onStack, List<List<Integer>> sccs) { dfn[u] = low[u] = ++index; stack.push(u); onStack[u] = true; for (int v : graph.get(u)) { if (dfn[v] == -1) { dfs(v, graph, dfn, low, onStack, sccs); low[u] = Math.min(low[u], low[v]); } else if (onStack[v]) { low[u] = Math.min(low[u], dfn[v]); } } if (low[u] == dfn[u]) { List<Integer> scc = new ArrayList<>(); while (true) { int node = stack.pop(); onStack[node] = false; scc.add(node); if (node == u) break; } sccs.add(scc); } } public static void main(String[] args) { int n = 7; List<List<Integer>> graph = new ArrayList<>(n); for (int i = 0; i < n; i++) { graph.add(new ArrayList<>()); } graph.get(0).add(1); graph.get(1).add(2); graph.get(2).add(0); graph.get(2).add(3); graph.get(3).add(4); graph.get(4).add(5); graph.get(5).add(3); graph.get(5).add(6); List<List<Integer>> result = tarjan(graph, n); System.out.println("Strongly Connected Components:"); for (List<Integer> component : result) { System.out.println(component); } } } ``` --- ### Python代码示例 Python 版本的实现如下所示： ```python def tarjan_scc(graph): index_counter = [0] stack = [] on_stack = {} indices = {} lows = {} sccs = [] def strongconnect(vertex): indices[vertex] = index_counter[0] lows[vertex] = index_counter[0] index_counter[0] += 1 stack.append(vertex) on_stack[vertex] = True for neighbor in graph[vertex]: if neighbor not in indices: strongconnect(neighbor) lows[vertex] = min(lows[vertex], lows[neighbor]) elif on_stack[neighbor]: lows[vertex] = min(lows[vertex], indices[neighbor]) if lows[vertex] == indices[vertex]: scc = set() while True: w = stack.pop() on_stack[w] = False scc.add(w) if w == vertex: break sccs.append(scc) for vertex in graph.keys(): if vertex not in indices: strongconnect(vertex) return sccs if __name__ == "__main__": graph = {0: [1], 1: [2], 2: [0, 3], 3: [4], 4: [5], 5: [3, 6], 6: []} components = tarjan_scc(graph) print("Strongly Connected Components:") for comp in components: print(comp) ``` --- ### 性能优势 Tarjan算法具有线性时间复杂度 \( O(V + E) \)，其中 \( V \) 是顶点数量，\( E \) 是边的数量。这种高效性能使其成为解决大规模图问题的理想工具[^4]。 ---