强连通分量算法：Kosaraju算法

强连通分量算法：Kosaraju算法详解

强连通分量（Strongly Connected Component，SCC）是有向图 中的一个极大子图，满足子图内任意两个顶点 u 和 v 都可以互相到达（u→v 且 v→u）。

Kosaraju算法是求解强连通分量的经典算法，核心思想是两次DFS + 图的转置，通过"拓扑序逆序遍历转置图"的方式，精准划分每个强连通分量。

资料：https://pan.quark.cn/s/43d906ddfa1b、https://pan.quark.cn/s/90ad8fba8347、https://pan.quark.cn/s/d9d72152d3cf

一、核心概念

强连通分量（SCC）：有向图的极大强连通子图，单个孤立顶点也是一个SCC。
图的转置 ：将原图中所有边的方向反转得到的新图，记为 G^T（转置不改变原图的强连通分量结构）。
逆拓扑序：对原图做DFS后序遍历得到的序列，反转后即为逆拓扑序（Kosaraju的关键遍历顺序）。

二、算法核心原理

强连通分量的顶点在转置图中依然强连通；
按原图的逆后序（逆拓扑序） 遍历转置图时，每次DFS能完整遍历一个强连通分量（不会跨分量遍历）。

三、算法步骤

Kosaraju算法分为 3个核心步骤 ，时间复杂度为 O(n+e)（n 为顶点数，e 为边数）：

第一次DFS（原图） ：
- 对原图进行DFS，按后序遍历顺序将顶点压入栈中；
- 后序顺序的特点：一个强连通分量的"出口顶点"会先入栈，整个分量的顶点会集中在栈的某一段。
构建转置图 G^T ：
- 将原图的所有边反转方向，得到转置图（邻接表反转）。
第二次DFS（转置图） ：
- 按栈的逆序（弹出顺序） 遍历转置图；
- 每次从栈顶取出未访问的顶点，在转置图中做DFS，遍历到的所有顶点即为一个强连通分量。

四、代码实现（Python）

python 复制代码

def kosaraju(n, edges):
    """
    Kosaraju算法求有向图的强连通分量
    :param n: 顶点数（0~n-1）
    :param edges: 边列表，格式为[(u, v), ...]，表示u→v的有向边
    :return: 强连通分量列表，每个元素是一个SCC的顶点集合
    """
    # ========== 步骤1：构建原图邻接表 ==========
    adj = [[] for _ in range(n)]
    for u, v in edges:
        adj[u].append(v)
    
    # ========== 步骤2：第一次DFS（原图），获取后序栈 ==========
    visited = [False] * n
    post_stack = []  # 存储后序遍历结果
    
    def dfs1(u):
        stack = [(u, False)]
        while stack:
            node, processed = stack.pop()
            if processed:
                post_stack.append(node)
                continue
            if visited[node]:
                continue
            visited[node] = True
            stack.append((node, True))  # 标记为待处理（后序入栈）
            # 逆序入栈，保证遍历顺序与递归版一致
            for v in reversed(adj[node]):
                if not visited[v]:
                    stack.append((v, False))
    
    # 遍历所有未访问顶点，处理非连通图
    for i in range(n):
        if not visited[i]:
            dfs1(i)
    
    # ========== 步骤3：构建转置图邻接表 ==========
    adj_t = [[] for _ in range(n)]
    for u, v in edges:
        adj_t[v].append(u)  # 边反转：v→u
    
    # ========== 步骤4：第二次DFS（转置图），划分SCC ==========
    visited = [False] * n
    scc_list = []  # 存储所有强连通分量
    
    def dfs2(u, component):
        stack = [u]
        visited[u] = True
        component.append(u)
        while stack:
            node = stack.pop()
            for v in adj_t[node]:
                if not visited[v]:
                    visited[v] = True
                    component.append(v)
                    stack.append(v)
    
    # 按后序栈的逆序（弹出顺序）遍历
    while post_stack:
        u = post_stack.pop()
        if not visited[u]:
            component = []
            dfs2(u, component)
            scc_list.append(component)
    
    return scc_list

# 测试示例
if __name__ == "__main__":
    # 顶点数：5
    n = 5
    # 边列表：有向图，包含2个强连通分量 [0,1,2] 和 [3,4]
    edges = [
        (0, 1), (1, 2), (2, 0),
        (1, 3), (3, 4), (4, 3)
    ]
    sccs = kosaraju(n, edges)
    print("强连通分量列表：", sccs)
    # 输出：强连通分量列表： [[0, 2, 1], [3, 4]]（顺序可能略有不同）

五、算法分析

时间复杂度 ：O(n+e)
- 两次DFS的时间均为 O(n+e)；
- 构建转置图的时间为 O(e)；
- 总时间与图的规模线性相关，适合大规模图。
空间复杂度 ：O(n+e)
- 存储原图、转置图的邻接表：O(e)；
- 访问标记数组、后序栈：O(n)。

六、关键细节与原理拆解

为什么要转置图？
原图中，强连通分量 C 到另一个分量 C' 可能有边 C→C'，但转置图中边会变成 C'→C；
按逆后序遍历转置图时，会先处理"无入边"的分量，避免跨分量遍历。
为什么是后序栈的逆序？
原图DFS的后序栈中，分量 C 的顶点会全部出现在分量 C' 顶点的下方 （若 C→C'）；
逆序弹出时会先处理 C，再处理 C'，转置图中 C'→C 的边不会干扰 C 的遍历。
非递归DFS的必要性
递归DFS在顶点数较多时会触发栈溢出，代码中使用手动栈模拟递归，更稳定。

七、Kosaraju vs Tarjan算法（强连通分量两大经典算法）

特性	Kosaraju算法	Tarjan算法
核心思想	两次DFS + 图转置	一次DFS + 栈 + 时间戳
时间复杂度	O(n+e)	O(n+e)
空间复杂度	O(n+e)（需存储转置图）	O(n)（无需转置图）
实现难度	低（逻辑直观，代码易写）	中（需理解时间戳和low值）
适用场景	分布式计算、图结构清晰的场景	内存受限、需一次遍历的场景
输出顺序	逆拓扑序输出分量	按发现顺序输出分量

八、强连通分量的典型应用

图的缩点（DAG化） ：将每个强连通分量缩成一个顶点，原图会转化为有向无环图（DAG），可用于拓扑排序、最长路径求解。
编译器优化：检测代码中的循环依赖（如模块之间的强依赖）。
社交网络分析：识别强连通的用户群体（如互相关注的圈子）。
电路设计：检测电路中的反馈环。

九、常见注意事项

顶点编号映射 ：若顶点编号非连续整数（如字符串、大ID），需先映射为 0~n-1 的连续编号。
非连通图处理：第一次DFS必须遍历所有顶点，避免遗漏孤立的强连通分量。
边的方向：构建转置图时，必须严格反转每条边的方向，否则会导致分量划分错误。

Kosaraju算法的优势在于逻辑简单、易于理解和实现，是学习强连通分量的入门算法。掌握其"两次DFS + 转置图"的核心思想，能为理解更高效的Tarjan算法打下基础。