强连通分量+双连通分量【模板】

最新推荐文章于 2022-03-18 13:16:27 发布
最新推荐文章于 2022-03-18 13:16:27 发布
阅读量297 收藏
点赞数 1
分类专栏： 双连通分量 强连通分量
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36368339/article/details/79356103
版权

求桥+割点+连通块+map重边：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <map>
#include <vector>
using namespace std;
typedef long long LL;

const int MAXN = 1e4 + 10;
const int MAXM = 2e5 + 10;
int head[MAXM], low[MAXM], dfn[MAXM];
int add_block[MAXM], stack[MAXM];
bool cut[MAXM], instack[MAXM];
int cnt, index_, top, bridge;
map<int, int> ma;

struct Edge {
    int to;
    int next;
    bool cut_;
}edge[MAXM];

void addedge(int u, int v) {
    edge[cnt].to = v;
    edge[cnt].next = head[u];
    edge[cnt].cut_ = false;
    head[u] = cnt++;
}

void tarjan(int u, int fa) { //tarjan找割点,桥 
    int v;
    low[u] = dfn[u] = ++index_;
    stack[top++] = u;
    instack[u] = true;
    int son = 0;
    for(int i = head[u]; ~i; i = edge[i].next) {
        v = edge[i].to;
        if(v == fa) continue;
        if(!dfn[v]) {
            son++;
            tarjan(v, u);
            low[u] = min(low[u], low[v]);
            if(low[v] > dfn[u] && ma[u * MAXN + v] == 1) {  //求桥(判重边) 
                bridge++;            //桥的数量 
                edge[i].cut_ = true; //该边是桥 
                edge[i^1].cut_ = true;
            }
            if(u != fa && low[v] >= dfn[u]) { 
                cut[u] = true;  //该点是割点 
                add_block[u]++; //割该点之后，连通块的数量 
            }
        }
        else {
            low[u] = min(dfn[v], low[u]);
        }
    }
    if(u == fa && son > 1) cut[u] = true; //该点是割点 
    if(u == fa) add_block[u] = son - 1;   //割该点之后，连通块的数量 
    instack[u] = false;
    top--;
}

void init() { //初始化 
    memset(head, -1, sizeof(head));
    memset(dfn, 0, sizeof(dfn));
    memset(instack, 0, sizeof(instack));
    memset(cut, 0, sizeof(cut));
    cnt = index_ = top = bridge = 0;
    ma.clear();
}

void solve(int n) {
    for(int i = 1; i <= n; ++i) {
        if(!dfn[i]) {
            tarjan(i, i);
        }
    }
    //加输出
}

int main() {
    int n, m, T;
    scanf("%d", &T);
    while(T--) {
        init(); 
        scanf("%d %d", &n, &m);
        while(m--) {
            int a, b;
            scanf("%d %d", &a, &b);
            ma[a * MAXN + b]++; //处理重边 
            ma[b * MAXN + a]++;
            addedge(a, b);
            addedge(b, a);
        }
        solve(n);
    }
    return 0; 
}

双联通缩点+染色+建新图+结构体排序去重边：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;

const int MAXN = 200000 + 5;
int low[MAXN], dfn[MAXN], Head[MAXN];
int vis[MAXN], dist[MAXN], stack[MAXN], col[MAXN];
int index_, p, cnt, top, scc;
vector<int> G[MAXN];

struct node_ {
    int to;
    int next;
    bool flag;
    bool cut;
}Edge[MAXN * 10];

struct Node {
    int a;
    int b;
}s[MAXN * 10];

void addEdge(int u, int v, bool Flag) {
    Edge[cnt].to = v;
    Edge[cnt].next = Head[u];
    Edge[cnt].flag = Flag;
    Edge[cnt].cut = false;
    Head[u] = cnt++;
}

//Tarjan缩点+染色(去重边) 
inline void tarjan(int u, int fa, bool tt) {
    int v;
    low[u] = dfn[u] = ++index_;
    stack[top++] = u;
    vis[u] = 1;
    for(int i = Head[u]; ~i; i = Edge[i].next) {
        v = Edge[i].to;
        if(v == fa && tt) continue;
        if(!dfn[v]) {
            tarjan(v, u, Edge[i].flag);
            low[u] = min(low[v], low[u]);
            if(low[v] > dfn[u]) {
                p++;
                Edge[i].cut = true;
                Edge[i ^ 1].cut = true;
            }
        }
        else if(vis[v] && low[u] > dfn[v]) {
            low[u] = dfn[v];
        }
    }
    if(low[u] == dfn[u]) {
        scc++;
        do {
            v = stack[--top];
            vis[v] = 0;
            col[v] = scc;
        } while(v != u);
    }
}

bool cmp(Node x, Node y) { //结构体排序去重 
    if(x.a != y.a) return x.a < y.a;
    return x.b < y.b;
}

void init() { 
    memset(dfn, 0, sizeof(dfn));
    memset(Head, -1, sizeof(Head));
    memset(s, 0, sizeof(s));
    memset(vis, 0, sizeof(vis));
    memset(col, 0, sizeof(col));
    scc = top = p = index_ = cnt = 0;
    for(int i = 0; i < MAXN; ++i) {
        G[i].clear();
    }
}

void solve(int n) {
    for(int i = 1; i <= n; ++i) {
        if(!dfn[i]) {
            tarjan(i, -1, true);
        }
    }
    for(int i = 1; i <= n; ++i) { //建新图 
        for(int j = Head[i]; ~j; j = Edge[j].next) {
            if(Edge[j].cut) {
                G[col[Edge[j].to]].push_back(col[i]);
            }
        }
    }

}

int main() {
    int n, m, T;
    while(scanf("%d %d", &n, &m) && (n + m)) {
        init();
        int A, B;
        for(int i = 0; i < m; ++i) {
            scanf("%d %d", &A, &B);
            if(A == B) continue;
            s[i].a = min(A, B);
            s[i].b = max(A, B);
        }
        sort(s, s + m, cmp); //去重边 
        for(int i = 0; i < m; ++i) {
            if(!i || (s[i].a != s[i - 1].a || s[i].b != s[i - 1].b)) {
                if(s[i].a == s[i + 1].a && s[i].b == s[i + 1].b) {
                    addEdge(s[i].a, s[i].b, false);
                    addEdge(s[i].b, s[i].a, false);
                }
                else {
                    addEdge(s[i].a, s[i].b, true);
                    addEdge(s[i].b, s[i].a, true);
                }
            }
        }
        solve(n);
    }
    return 0; 
}

缩点+染色+保留点集+建缩点图：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;
typedef long long LL;

const int MAXN = 50010;
int stack[MAXN], col[MAXN], vis[MAXN];
int dfn[MAXN], low[MAXN], in[MAXN], out[MAXN];
int index, top, scc;
vector<int> V[MAXN], G[MAXN];

void init() {
    memset(dfn, 0, sizeof(dfn));
    memset(vis, 0, sizeof(vis));
    memset(out, 0, sizeof(out));
    memset(in, 0, sizeof(in));
    index = scc = top = 0;
    for(int i = 0; i < MAXN; i++) {
        V[i].clear();
        G[i].clear();
    }
}

inline void tarjan(int u) {
    int v;
    low[u] = dfn[u] = ++index;
    stack[top++] = u;
    vis[u] = 1;
    for(int i = 0; i < V[u].size(); ++i) {
        v = V[u][i];
        if(!dfn[v]) {
            tarjan(v);
            low[u] = min(low[v], low[u]);
        }
        else if(vis[v] && low[u] > dfn[v]) {
            low[u] = dfn[v];
        }
    }
    if(low[u] == dfn[u]) {
        scc++;
        do {
            v = stack[--top];
            vis[v] = 0;
            col[v] = scc; //染色，有利于后续建图
            G[scc].push_back(v); //保留每个scc的点集
        } while(v != u);
    }
}

void solve(int n) {
    for(int i = 1; i <= n; ++i) {
        if(!dfn[i]) {
            tarjan(i);
        }
    }
    memset(vis, 0, sizeof(vis));
    for(int i = 1; i <= n; ++i) {
        for(int j = 0; j < V[i].size(); ++j) {
            int v = V[i][j];
            if(col[v] == col[i]) continue;
            out[col[i]]++;
        }
    }
    int ans = 0, flag = 0;
    for(int i = 1; i <= scc; ++i) {
        if(!out[i]) {
            ans += G[i].size();
            flag++;
        }
    }
    if(flag > 1) printf("0\n"); //不受所有牛欢迎
    else printf("%d\n", ans);
}

int main() {
    int n, m, A, B;
    while(scanf("%d %d", &n, &m) != EOF) {
        init();
        while(m--) {
            scanf("%d %d", &A, &B);
            V[A].push_back(B);
        }
        solve(n);
    }
    return 0;
}

搭桥模板：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;
typedef long long LL;

const int MAXN = 50010;
int stack[MAXN], col[MAXN], vis[MAXN];
int dfn[MAXN], low[MAXN], in[MAXN], out[MAXN];
int index, top, scc;
vector<int> V[MAXN];

void init() {
    memset(dfn, 0, sizeof(dfn));
    memset(vis, 0, sizeof(vis));
    memset(out, 0, sizeof(out));
    memset(in, 0, sizeof(in));
    index = scc = top = 0;
    for(int i = 0; i < MAXN; i++) {
        V[i].clear();
    }
}

inline void tarjan(int u) {
    int v;
    low[u] = dfn[u] = ++index;
    stack[top++] = u;
    vis[u] = 1;
    for(int i = 0; i < V[u].size(); ++i) {
        v = V[u][i];
        if(!dfn[v]) {
            tarjan(v);
            low[u] = min(low[v], low[u]);
        }
        else if(vis[v] && low[u] > dfn[v]) {
            low[u] = dfn[v];
        }
    }
    if(low[u] == dfn[u]) {
        scc++;
        do {
            v = stack[--top];
            vis[v] = 0;
            col[v] = scc;
        } while(v != u);
    }
}

void solve(int n) {
    for(int i = 1; i <= n; ++i) {
        if(!dfn[i]) {
            tarjan(i);
        }
    }
                             //搭桥 
    if(scc == 1) {
        printf("0\n");
        return ;
    }
    memset(vis, 0, sizeof(vis));
    for(int i = 1; i <= n; ++i) {
        for(int j = 0; j < V[i].size(); ++j) {
            int v = V[i][j];
            if(col[v] == col[i]) continue;
            in[col[v]]++;
            out[col[i]]++;
        }
    }
    int ans1 = 0, ans2 = 0;
    for(int i = 1; i <= scc; ++i) {
        if(!out[i]) ans1++;
        if(!in[i]) ans2++;
    }
    printf("%d\n", max(ans1, ans2));
}

int main() {
    int n, m, A, B;
    while(scanf("%d %d", &n, &m) != EOF) {
        init();
        while(m--) {
            scanf("%d %d", &A, &B);
            V[A].push_back(B);
        }
        solve(n);
    }
    return 0;
}
UCAS王小二
关注
专栏目录
C/C++ 实现强连通分量(strongly connected components)算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-30 246
实现强连通分量算法的优点是能够高效地找到有向图中的强连通分量，并将其划分出来，以便进行后续的分析和处理。强连通分量在许多应用中都有重要的作用，例如图的可达性、环的检测、拓扑排序等问题。实现强连通分量算法的优点是能够高效地找到有向图中的强连通分量，并将其划分出来，以便进行后续的分析和处理。实现强连通分量算法的优点是能够高效地找到有向图中的强连通分量，并将其划分出来，以便进行后续的分析和处理。实现强连通分量算法的优点是能够高效地找到有向图中的强连通分量，并将其划分出来，以便进行后续的分析和处理。
寒假2019培训：双连通分量（点双+边双）
星暗宇的博客
02-17 7651
定义： 若一个无向连通图不存在割点，则称它为“点双连通图”。若一个无向连通图不存在割边，则称它为“边双连通图”。 无向图的极大点双连通子图称为“点双连通分量”，简记为“v-DCC”。无向连通图的极大边双连通子图被称为“边双连通分量”，简记为“e-DCC”。二者统称为“双连通分量”，简记为“DCC”。 边双联通分量 求法： 核心概念： 没有割边 割边只会把图分成两部分，对图中的点没有影响。 用...
图中强连通分量的寻找
03-19
图论中一个图序列强连通分量的检测程序，属于datastructure，帮助搜索算法
双连通分量 模板
YueLing's Blog
11-05 802
1. bcc的全称是biconnected component，双连通分量，点双连通关注的是不包含割点的连通分量，边双连通关注的是不包含桥的连通分量。 2. 点双连通例题：UVALive 5135。边双连通例题：poj 3352。 3. 边双连通分量巧妙利用isB数组，空间换时间，也大大降低了模板的复杂度，解决了标记边难的问题。
【双连通分量模板】
tystrwor的博客
09-21 424
一、点双联通分量 1.调用init（）初始化。然后调用find_vbcc()；求解。 2.N，n是点数，M，m是边数。 3.belong表示该点属于哪一个联通分量（割顶无意义），bcc表示该联通分量的点，isc表示该点是否为割顶，bcc_cnt点双联通分支数量。 const int N=10010; const int M=200020; struct edge { int f
双连通分量模板
小狼
10-13 46
【代码】双连通分量模板。
双连通分量模板（点/边）
Dave_lzw的博客
03-09 704
在一个连通图中，任意两个点都能通过至少两条不经过同一个点的路径而互相到达，就说明它是点双连通的。 点双连通分量： 任意两点之间的两条路径之间没有公共的边 void Tarjan( int x , int fa ){ int son = 0; DFN[x] = LOW[x] = ++index1; for( int i = head[x] ; ~i ; i = G[i].nex
HDU-1269（Tarjan模板-求强连通分量）
01-03
 求一个有向图n个点 m 条边，是否是强连通分量，如果是输出Yes, 不是输出No. 数据范围  n < 10000, m < 100000 思路：  Tarjan模板题 补习： AC code: /* Tarjan求有向图的强连通分量， */ #include #...
Tarjan求强连通分量【模板】.cpp
04-14
纯代码
强连通分量较难例题【受欢迎的牛 + 最大半联通子图】
531 の 流 水 线
03-18 924
这几道题都是 Tarjan 和其他算法的综合，难度较大，含金量较高，特别是第二题。 我的博客：关于 Tarjan 算法的入门博客。 传送门 - 板子题 B3609 题解 开始—— 例题一 受欢迎的牛 传送门 - P2314 受欢迎的牛 G 思路 概述： Tarjan + 缩点 DAG + 出入度 1. Tarjan 在一个强连通分量中，很明显，所有奶牛都是互相喜欢的，所以我们分别求出每一个强连通分量，并记录下他们的 size 。 2. 缩点 DAG 我们把强连通分量看成一个超级点，并在相互之间建边。 （图
双连通分量（边、点）模板
tomjobs的博客
09-08 279
点双连通分量 const int SIZE = 2e5 + 7; int head[SIZE], ver[SIZE * 2], Next[SIZE * 2]; int dfn[SIZE], low[SIZE], stack[SIZE]; int cut[SIZE], color[SIZE], vis[SIZE], CNT[SIZE]; void tarjan(int x) { dfn[x] = low[x] = ++num; stack[++top] = x; int flag =
点双连通分量[模板]
jziwjxjd的博客
08-24 510
#include <bits/stdc++.h> using namespace std; const int maxn=2e5+10; int n,m,cut[maxn]; struct edge{ int to,nxt; }d[maxn]; int head[maxn],cnt=1; void add(int u,int v){ d[++cnt]=(edge){v,head[u]},head[u]=cnt; } int low[maxn],dfn[maxn],stac[maxn],top
点-双连通分量模板
不吸血的Vampire
07-05 873
by：白书 #define M 10000 int pre[M],dfs_clock,iscut[M],low[M],bcc_cnt,bccno[M]; vectorG[M],bcc[M]; struct Edge { int u,v; Edge(int from,int to) { u=from; v=to; } }; stack S; int dfs(int u,int fa
浅谈双连通分量、强连通分量（模板）
AI蜗牛之家
04-13 973
初谈这个话题相信每一位都会感到一丝疑惑，主要原因是这个词中“分量”一词，当然，如果仅是为了了解和使用这两个术语，就不必在意这个无关大体的词语。         好了，该谈谈正题了，所谓双连通与强连通，最大的差别，也是最本质的差别就是前者适用于无向图中，而后者适用于有向图。至于两者的概念是一样的，就是图中有a点、b点，从a点可到达b点，同时从b点可到达a点。（若是有向图必须延方向到达。）
双连通分量+tarjan缩点模板
萌新的博客
09-23 149
taijan视频讲解 代码 #include <cstring> #include <iostream> #include <algorithm> using namespace std; const int N = 5010, M = 20010; int n, m; int h[N], e[M], ne[M], idx; int dfn[N], low[N], timestamp; int stk[N], top; int id[N], dcc_cnt; boo
无向图的点-双联通分量（模板）
Change the world by program.
01-31 187
求一个无向图的点双联通分量，大白书315页 性质：不同的点-双联通分量之间最多只有一个公共点，且它一定是割顶，反过来说任何割顶都至少是两个不同的点-双连通分量的公共点 模板 int n, m; int dfs_clock, bcc_cnt;//bcc_cnt记录点-双连通分量的个数，初始化是0但是是从1开始的 int pre[maxn], low[maxn], bccno[maxn];//b
poj3177Redundant Paths【构造双连通分量：并查集缩点 模板】
MissZhou要努力
11-20 1219
这个题就是问加几条边可以构成双连通分量，一开始图样图森破的以为只是求桥的个数就好，然而并非如此…… 构造双连通分量的加边数=（原图的叶节点数+1）/2    因为双连通分量需要成环嘛，原图已经是连着的了，所以只需要在另一侧再加一条边就成环啦~怎么判断哪里是叶结点呢？先用并查集缩点，把所有当前的双连通分量都缩到一起，然后就构成了只有桥的图，枚举每个桥，记录每个点的次数，每次加一。只有1的点就是原图
点双连通分量
ACTerminate的博客
09-13 4490
点双连通分量定义与性质： 1.     对于点双联通分量，删除任意一点连通性不变，其中不含桥，环与环必定含有公共边，且公共点至少两个，简单圈中的点一定属于同一个点BCC。   原理，通过两个标记数组来判别割点，并在dfs过程中用栈来记录每个双联通分量(或是强连通分量)中的点，最后按这些记录缩点建图后是森林。   两个标记数组分别是 dfn[] low[] dfn[]数组记录的是，在df
图论——强连通分量：Tarjan算法——练习1
weixin_33788244的博客
11-07 180
上一次我们详细介绍了强连通分量的Tarjan算法，今天呢，我们来做一些习题来巩固Tarjan算法，毕竟它十分重要。 Tarjan算法详解 上面是上一次的详解，在做题时可供参考。 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 练习一般采用洛谷...
Kosaraju算法详解：挖掘有向图的强连通分量
强连通分量是图论中的一个重要概念，它在有向图中定义为一组顶点，其中任意两个顶点在两个方向上都存在有向路径。在实际应用中，如网络分析、编译器设计和数据流分析等领域，理解和计算强连通分量至关重要。理解强...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值