图算法之强连通分量（Strongly Connected Components, SCC）详细解读

Katie。

已于 2024-10-14 11:08:13 修改

阅读量1.6k

点赞数 20

分类专栏：算法分析文章标签：算法

于 2024-10-14 11:02:10 首次发布

本文链接：https://blog.csdn.net/m0_61840987/article/details/142912858

版权

算法分析专栏收录该内容

87 篇文章

订阅专栏

强连通分量（Strongly Connected Components，SCC）是图论中有向图的重要概念。对于一个有向图，强连通分量是这样一个最大子图，其中任意两个顶点之间都有双向可达路径。也就是说，对于强连通分量内的任意两个顶点 u 和 v，从 u 可以到达 v，同时从 v 也可以到达 u。

在很多应用中，识别图的强连通分量是图算法中的一个关键步骤。它可以用于优化编译器的控制流分析、社交网络中的社区检测、Web 爬虫的页面分组等。

强连通分量的定义

在一个有向图中：

强连通图：如果图中的任意两个顶点 u 和 v 都满足从 u 可以到达 v，且从 v 也可以到达 u，则称这个有向图是强连通的。
强连通分量（SCC）：是有向图中的一个最大强连通子图。也就是说，一个强连通分量是图的一个极大子集，且子集内任意两个顶点都是强连通的。

例如，在一个网站的网页结构中，强连通分量可以表示某个子集中的所有网页都可以通过某些超链接相互访问。

应用场景

强连通分量在以下领域中有广泛应用：

编译器设计：控制流图中的循环优化。
网络分析：分析社交网络中的社群，或者在 Web 爬虫中分组相互关联的网页。
电路设计：用于分析有向图中的强连通性，例如环路检测。
数据库系统：在引用完整性约束中，用于检测循环依赖。

求解强连通分量的常用算法

1. Kosaraju 算法

Kosaraju 算法是基于深度优先搜索（DFS）的两次遍历算法，用于高效地查找有向图中的强连通分量。该算法的时间复杂度为 O(V+E)，其中 V 是顶点数，E 是边数。

算法步骤

第一次 DFS 遍历：对原图执行深度优先搜索，并记录每个顶点的完成时间。DFS 过程中，每个顶点在搜索结束后被“标记”为已访问。
图的转置（反向图）：对图中所有边的方向进行反转，得到图的转置。转置图中顶点和边的关系与原图相反。
第二次 DFS 遍历：按照第一次 DFS 结束时的逆序（即完成时间从后到前）对转置图进行深度优先搜索，每次搜索都找到一个新的强连通分量。

Kosaraju 算法的 Java 实现

import java.util.*;

public class KosarajuSCC {
    private int V; // 顶点数量
    private LinkedList<Integer>[] adj; // 原图的邻接表

    // 构造函数
    public KosarajuSCC(int V) {
        this.V = V;
        adj = new LinkedList[V];
        for (int i = 0; i < V; i++) {
            adj[i] = new LinkedList<>();
        }
    }

    // 添加边
    public void addEdge(int u, int v) {
        adj[u].add(v);
    }

    // 深度优先搜索
    private void DFS(int v, boolean[] visited, Stack<Integer> stack) {
        visited[v] = true;
        for (int neighbor : adj[v]) {
            if (!visited[neighbor]) {
                DFS(neighbor, visited, stack);
            }
        }
        stack.push(v);
    }

    // 反转图
    private KosarajuSCC getTranspose() {
        KosarajuSCC g = new KosarajuSCC(V);
        for (int v = 0; v < V; v++) {
            for (int neighbor : adj[v]) {
                g.addEdge(neighbor, v);
            }
        }
        return g;
    }

    // 在转置图上执行 DFS
    private void DFSUtil(int v, boolean[] visited) {
        visited[v] = true;
        System.out.print(v + " ");
        for (int neighbor : adj[v]) {
            if (!visited[neighbor]) {
                DFSUtil(neighbor, visited);
            }
        }
    }

    // Kosaraju 算法
    public void printSCCs() {
        Stack<Integer> stack = new Stack<>();

        // 第一次 DFS，填充栈
        boolean[] visited = new boolean[V];
        for (int i = 0; i < V; i++) {
            if (!visited[i]) {
                DFS(i, visited, stack);
            }
        }

        // 获取转置图
        KosarajuSCC transpose = getTranspose();

        // 第二次 DFS，按栈顺序
        Arrays.fill(visited, false);
        while (!stack.isEmpty()) {
            int v = stack.pop();
            if (!visited[v]) {
                transpose.DFSUtil(v, visited);
                System.out.println();
            }
        }
    }

    public static void main(String[] args) {
        KosarajuSCC g = new KosarajuSCC(5);
        g.addEdge(1, 0);
        g.addEdge(0, 2);
        g.addEdge(2, 1);
        g.addEdge(0, 3);
        g.addEdge(3, 4);

        System.out.println("强连通分量：");
        g.printSCCs();
    }
}

复杂度分析

时间复杂度：O(V+E)，每个顶点和每条边都只访问一次。
空间复杂度：O(V+E)，用于存储图和转置图的邻接表。

2. Tarjan 算法

Tarjan 算法也是基于深度优先搜索的，它在一次 DFS 遍历中即可找到所有的强连通分量。Tarjan 算法的时间复杂度为 O(V+E)。

算法思想

Tarjan 算法利用 DFS 树以及低链接值（Low-Link Value）来确定图中是否存在环。低链接值是 DFS 树中某个节点能够通过后代或回边到达的最小节点。

算法步骤

对图进行深度优先搜索，标记每个节点的访问时间。
通过 DFS 树的回溯过程计算低链接值。
当一个节点的低链接值等于其访问时间时，表示它是一个强连通分量的根，继续沿 DFS 树回溯，将该节点及其后代归为一个强连通分量。

Tarjan 算法的 Java 实现

import java.util.*;

public class TarjanSCC {
    private int V; // 顶点数量
    private LinkedList<Integer>[] adj; // 邻接表
    private int time = 0; // 记录DFS时间
    private Stack<Integer> stack; // 记录SCC
    private int[] disc, low; // 记录发现时间和低链接值
    private boolean[] inStack; // 判断节点是否在栈中

    // 构造函数
    public TarjanSCC(int V) {
        this.V = V;
        adj = new LinkedList[V];
        for (int i = 0; i < V; i++) {
            adj[i] = new LinkedList<>();
        }
        disc = new int[V];
        low = new int[V];
        stack = new Stack<>();
        inStack = new boolean[V];
        Arrays.fill(disc, -1); // 初始化为未访问
        Arrays.fill(low, -1);
    }

    // 添加边
    public void addEdge(int u, int v) {
        adj[u].add(v);
    }

    // Tarjan 算法的递归 DFS
    private void SCCUtil(int u) {
        disc[u] = low[u] = ++time;
        stack.push(u);
        inStack[u] = true;

        for (int v : adj[u]) {
            if (disc[v] == -1) {
                SCCUtil(v);
                low[u] = Math.min(low[u], low[v]);
            } else if (inStack[v]) {
                low[u] = Math.min(low[u], disc[v]);
            }
        }

        // 如果节点 u 是 SCC 的根节点
        if (low[u] == disc[u]) {
            while (stack.peek() != u) {
                int v = stack.pop();
                System.out.print(v + " ");
                inStack[v] = false;
            }
            System.out.print(stack.pop() + "\n");
            inStack[u] = false;
        }
    }

    // Tarjan 算法的主函数
    public void SCC() {
        for (int i = 0; i < V; i++) {
            if (disc[i] == -1) {
                SCCUtil(i);
            }
        }
    }

    public static void main(String[] args) {
        TarjanSCC g = new TarjanSCC(5);
        g.addEdge(1, 0);
        g.addEdge(0, 2);
        g.addEdge(2, 1);
        g.addEdge(0, 3);
        g.addEdge(3, 4);

        System.out.println("强连通分量：");
        g.SCC();
    }
}