怎么计算连通分量个数python

转载

码海探险家 2024-07-15 13:02:58

文章标签 怎么计算连通分量个数python 强连通分量缩点进栈 文章分类 Python 后端开发

一些 update
1. 前言
2. 定义
3. 求法
4. 应用
5. 总结

一些 update

update on 2021/8/12：增加了对于 Kosaraju 算法优势的分析。

1. 前言

强连通分量，是图论的一个东西。

这个东西可以将有向图变为一张 DAG，而在 DAG 上就可以使用各种技巧了。

2. 定义

分量的定义：在一张给定的有向图中，如果点 \(a,b\) 能够互相到达，就称点 \(a,b\)

显然的，分量具有传递性，即若 \(a,b\) 在一个分量，\(b,c\) 在一个分量，那么 \(a,c\)

强连通分量：对于一张图 \(G\)，设其点集为 \(V\)，如果能够从中选出一些点构成点集 \(V'\)，满足 \(V'\) 内的所有点都在一个分量内，且 \(V'\) 内的所有点都不与 \(V'\) 之外的点在一个分量内，那么点 \(V'\) 称作图 \(G\)

根据定义可以知道，强连通分量里面的所有点都是能够互相到达的。

3. 求法

强连通分量有很多求法，而笔者使用的求法是 Kosaraju 算法，该算法采用两次 dfs 确定强连通分量，也就是俗称的两遍 dfs 求强连通分量。

该算法的步骤如下：

首先先对整张图做一遍 dfs（任意点开始均可），对于每一个点，当遍历完其所有出边之后将这个点压入一个栈 \(sta\)。
然后将 \(sta\)
从 \(sta\)

注意第三步是有顺序的，也就是反转 \(sta\)

那么这个算法为什么是正确的呢？

假设反转前的 \(sta=\{a,b,c,...,z\}\)。

那么反转之后 \(z\) 是第一个，假设在反向图中 \(z\) 能到达 \(a,b,c\)。

那么显然的，此时在正向图中能够保证 \(a,b,c\) 能够到达 \(z\)。

但是为什么 \(z\) 能够到达 \(a,b,c\)

因为在反转前的 \(sta\) 中，\(a,b,c\) 在 \(z\)

这就意味着 \(a,b,c\) 必须在 \(z\) 之前进栈，而在 \(z\) 之前进栈，要么是 \(a,b,c\) 与 \(z\)

因此，只能是 \(z\) 能够到达 \(a,b,c\)，这样才能够说明 \(a,b,c\) 在 \(z\)

证毕。

关于这一部分的代码可以看应用的缩点代码，这里面包含了强连通分量的代码。

除了 Kosaraju 算法之外，最常用的求强连通分量的算法就是 Tarjan 算法了。

那么 Kosaraju 算法有什么优点呢？

思路比 Tarjan 算法简洁易懂。
代码不容易出错。
有一个很神奇的特性，这个特性将会在应用板块中讲解。

而且特别的，由于求强连通分量的 Tarjan 算法和求割点与桥的 Tarjan 算法在实现细节上是有一定不同的，有些时候容易将两者搞混，因此笔者只讲述 Kosaraju 算法。

4. 应用

强连通分量有 2 个应用，一个是缩点，一个是 2 - SAT，此处只讲缩点。

例题：P3387 【模板】缩点

强连通分量的一个好处是能够将一张有向图变为一张 DAG。

怎么变呢？

因为一个强连通分量里面的所有点互相可达，因此我们可以将这些点的信息合并成一个点，那么在这么做之后这张图就会变成一张 DAG。

为什么是 DAG？

假设图中还有环，那么这些点就属于一个强连通分量，但是我们已经将所有的强连通分量缩成一个点了，矛盾。

缩点有什么用吗？

DAG 最好用的地方就是拓扑排序！利用拓扑排序 + DP，可以解决很多图上问题。

代码：

/*
========= Plozia =========
    Author:Plozia
    Problem:P3387 【模板】缩点
    Date:2021/4/15
========= Plozia =========
*/

#include <bits/stdc++.h>
using std::queue;

typedef long long LL;
const int MAXN = 1e4 + 10, MAXM = 1e5 + 10;
int n, m, val[MAXN], cnt_EEdge = 1, a[MAXN], HHead[MAXN], cnt_Edge = 1, sta[MAXN], Top, col, Color[MAXN], Head[MAXN];
int cnt[MAXN], ans, f[MAXN];
struct node { int to, val, Next; } EEdge[MAXM << 1], Edge[MAXM << 1];
bool vis[MAXN];

int read()
{
    int sum = 0, fh = 1; char ch = getchar();
    for (; ch < '0' || ch > '9'; ch = getchar()) fh -= (ch == '-') << 1;
    for (; ch >= '0' && ch <= '9'; ch = getchar()) sum = (sum << 3) + (sum << 1) + (ch ^ 48);
    return sum * fh;
}
void add_EEdge(int x, int y, int z) { ++cnt_EEdge; EEdge[cnt_EEdge] = (node){y, z, HHead[x]}; HHead[x] = cnt_EEdge; }
void add_Edge(int x, int y, int z) { ++cnt_Edge; Edge[cnt_Edge] = (node){y, z, Head[x]}; Head[x] = cnt_Edge; }
//千万注意不能搞错原图和新图的存储！！！
int Min(int fir, int sec) { return (fir < sec) ? fir : sec; }
int Max(int fir, int sec) { return (fir > sec) ? fir : sec; }

void dfs1(int now)
{
    vis[now] = 1;
    for (int i = HHead[now]; i; i = EEdge[i].Next)
    {
        int u = EEdge[i].to;
        if (EEdge[i].val == 0) continue;
        if (vis[u]) continue; dfs1(u);
    }
    sta[++Top] = now;//进栈
}

void dfs2(int now, int col)
{
    vis[now] = 1; Color[now] = col;//染色，记录是哪一个强连通分量
    for (int i = HHead[now]; i; i = EEdge[i].Next)
    {
        int u = EEdge[i].to;
        if (vis[u] || EEdge[i].val == 1) continue;
        dfs2(u, col);
    }
}

void Topsort()//拓扑排序 + DP
{
    queue <int> q;
    for (int i = 1; i <= col; ++i)
        if (cnt[i] == 0) q.push(i), ans = Max(ans, f[i] = a[i]);
    while (!q.empty())
    {
        int x = q.front(); q.pop();
        for (int i = Head[x]; i; i = Edge[i].Next)
        {
            int u = Edge[i].to; --cnt[u];
            f[u] = Max(f[u], f[x] + a[u]);
            ans = Max(ans, f[u]);
            if (cnt[u] == 0) q.push(u);
        }
    }
}

int main()
{
    n = read(), m = read();
    for (int i = 1; i <= n; ++i) val[i] = read();
    for (int i = 1; i <= m; ++i)
    {
        int u = read(), v = read();
        add_EEdge(u, v, 1); add_EEdge(v, u, 0);
    }
    for (int i = 1; i <= n; ++i)
        if (!vis[i]) dfs1(i);//一次 dfs
    memset(vis, 0, sizeof(vis));
    std::reverse(sta + 1, sta + Top + 1);//注意反转！
    for (int i = 1; i <= n; ++i)
        if (!vis[sta[i]]) { ++col; dfs2(sta[i], col); }//二次 dfs
    for (int i = 1; i <= cnt_EEdge; i += 2)
    {
        int u = EEdge[i ^ 1].to, v = EEdge[i].to;
        if (Color[u] != Color[v]) { add_Edge(Color[u], Color[v], 1); cnt[Color[v]]++; }
        //建立新图
    }
    for (int i = 1; i <= n; ++i) a[Color[i]] += val[i];//处理新图的点权
    Topsort(); printf("%d\n", ans);
    return 0;
}

接下来，在确定理解上述代码之后，讲解 Kosaraju 算法的特性：