连通分量

最新推荐文章于 2022-11-07 19:24:54 发布
最新推荐文章于 2022-11-07 19:24:54 发布
阅读量187 收藏
点赞数
分类专栏： 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C2022lihan/article/details/115576143
版权

无向图

1.求无向图的边双连通分量
int dfn[Maxn + 5], low[Maxn + 5], timestamp;
int id[Maxn + 5], dcc_cnt;
int st[Maxn + 5], Top;
bool is_bridge[Maxm * 2 + 5];
void Tarjan (int u, int fa) {
    dfn[u] = low[u] = ++timestamp;
    st[++Top] = u;
    
    for (int i = Head[u]; i; i = e[i].Next) {
        int v = e[i].to;
        if (dfn[v] == 0) {
            Tarjan (v, i);
            low[u] = Min (low[u], low[v]);
            if (low[v] > dfn[u]) {
                is_bridge[i] = is_bridge[i ^ 1] = 1;
            }
        }
        else if (fa != (i ^ 1)) {
            low[u] = Min (low[u], dfn[v]);
        }
    }
    
    if (dfn[u] == low[u]) {
        dcc_cnt++;
        int v;
        do {
            v = st[Top--];
            id[v] = dcc_cnt;
        }while (u != v);
    }
}
2.求无向图的点双连通分量
int dfn[Maxn + 5], low[Maxn + 5], timestamp;
int Top, dcc_cnt;
pair <int, int> st[Maxm + 5];
vector <pair <int, int> > block[Maxm + 5];
void Tarjan (int u, int fa) {
	dfn[u] = low[u] = ++timestamp;
	
	for (int i = Head[u]; i; i = e[i].Next) {
		int v = e[i].to;
		if (dfn[v] == 0) {
			st[++Top] = make_pair (u, v);
			Tarjan (v, u);
			low[u] = Min (low[u], low[v]);
			if (low[v] >= dfn[u]) {
				dcc_cnt++;
				pair <int, int> tem;
				do {
					tem = st[Top--];
					block[dcc_cnt].push_back (make_pair (Min (tem.first, tem.second), Max (tem.first, tem.second)));
				}while (tem != make_pair (u, v));
			}
		}
		else if (v != fa) {
			if (dfn[v] <= dfn[u])//返祖边 
				st[++Top] = make_pair (u, v);
			low[u] = Min (low[u], dfn[v]);
		}
	}
}
3.求要加哪些边才能使原图成为边双连通
#include <map>
#include <set>
#include <cmath>
#include <stack>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

#define LL long long
#define ULL unsigned long long

template <typename T> int read (T &x) {x = 0; T f = 1;char tem = getchar ();while (tem < '0' || tem > '9') {if (tem == '-') f = -1;tem = getchar ();}while (tem >= '0' && tem <= '9') {x = (x << 1) + (x << 3) + tem - '0';tem = getchar ();}x *= f; return 1;}
template <typename T> void write (T x) {if (x < 0) {x = -x;putchar ('-');}if (x > 9) write (x / 10);putchar (x % 10 + '0');}
template <typename T> T Max (T x, T y) { return x > y ? x : y; }
template <typename T> T Min (T x, T y) { return x < y ? x : y; }
template <typename T> T Abs (T x) { return x > 0 ? x : -x; }

const int Maxn = 2500;
const int Maxm = 2 * 1e4;

int n, m;

int len = 1, Head[Maxn + 5], len_dcc = 1, Head_dcc[Maxn + 5];
struct edge {
    int to, Next;
}e[Maxm * 2 + 5], e_dcc[Maxm * 2 + 5];
void add (int x, int y) {
    e[++len].to = y;
    e[len].Next = Head[x];
    Head[x] = len;
}
void add_dcc (int x, int y) {
	e_dcc[++len_dcc].to = y;
	e_dcc[len_dcc].Next = Head_dcc[x];
	Head_dcc[x] = len_dcc;
}

int dfn[Maxn + 5], low[Maxn + 5], timstamp;
int st[Maxn + 5], Top;
int id[Maxn + 5], _min[Maxn + 5], dcc_cnt;
bool is_bridge[Maxm * 2 + 5];
void Tarjan (int u, int fa) {
    dfn[u] = low[u] = ++timstamp;
    st[++Top] = u;
    
    for (int i = Head[u]; i; i = e[i].Next) {
        int v = e[i].to;
        if (dfn[v] == 0) {
            Tarjan (v, i);
            low[u] = Min (low[u], low[v]);
            if (low[v] > dfn[u])
                is_bridge[i] = is_bridge[i ^ 1] = 1;
        }
        else if ((i ^ 1) != fa)
            low[u] = Min (low[u], dfn[v]);
    }
    
    if (dfn[u] == low[u]) {
        dcc_cnt++;
        int v;
        do {
            v = st[Top--];
            id[v] = dcc_cnt;
            _min[dcc_cnt] = Min (_min[dcc_cnt], v);
        }while (u != v);
    }
}

int d[Maxn + 5];
vector <pair <int, int> > v;
void dfs (int u, int fa) {
    dfn[u] = ++timstamp;
    if (d[u] == 1) {
        v.push_back (make_pair (dfn[u], _min[u]));
    }
    for (int i = Head_dcc[u]; i; i = e_dcc[i].Next) {
        int v = e_dcc[i].to;
        if (v == fa) continue;
        dfs (v, u);
    }
}

int g[Maxn + 5][Maxn + 5];

signed main () {
    memset (_min, 0x3f, sizeof _min);
    read (n); read (m);
    for (int i = 1; i <= m; i++) {
        int x, y; read (x); read (y);
        add (x, y); add (y, x);
    }
    for (int i = 1; i <= n; i++) {
        if (dfn[i] == 0)
            Tarjan (i, -1);
    }
    for (int i = 2; i <= len; i++)
        if (is_bridge[i] == 1)
            d[id[e[i].to]]++;
    for (int u = 1; u <= n; u++) {
    	for (int i = Head[u]; i; i = e[i].Next) {
    		int v = e[i].to;
    		if (id[u] == id[v]) continue;
    		if (is_bridge[i] == 1) {
    		    if (g[id[u]][id[v]] || g[id[v]][id[u]]) continue;
    		    g[id[u]][id[v]] = g[id[v]][id[u]] = 1;
    		    add_dcc (id[u], id[v]); add_dcc (id[v], id[u]);
    		}
		}
	}
    
    int root;
    for (int i = 1; i <= dcc_cnt; i++) {
        if (d[i] > 1) {
            timstamp = 0;
            dfs (i, -1);
            root = i;
            break;
        }
    }
    
    sort (v.begin (), v.end ());
    int len = (int)v.size ();
    printf ("%d\n", (len + 1) >> 1);
    for (int i = 0, j = (len + 1 >> 1); i <= len / 2, j < len; i++, j++) {
        printf ("%d %d\n", v[i].second, v[j].second);
    }
    if (len & 1) printf ("%d %d", v[len / 2].second, root);
	return 0;
}
4.求要加多少点才能使原图成为边双连通
#include <map>
#include <set>
#include <cmath>
#include <stack>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

#define LL long long
#define ULL unsigned long long

template <typename T> int read (T &x) {x = 0; T f = 1;char tem = getchar ();while (tem < '0' || tem > '9') {if (tem == '-') f = -1;tem = getchar ();}while (tem >= '0' && tem <= '9') {x = (x << 1) + (x << 3) + tem - '0';tem = getchar ();}x *= f; return 1;}
template <typename T> void write (T x) {if (x < 0) {x = -x;putchar ('-');}if (x > 9) write (x / 10);putchar (x % 10 + '0');}
template <typename T> T Max (T x, T y) { return x > y ? x : y; }
template <typename T> T Min (T x, T y) { return x < y ? x : y; }
template <typename T> T Abs (T x) { return x > 0 ? x : -x; }

const int Maxn = 2500;
const int Maxm = 2 * 1e4;

int n, m;

int len = 1, Head[Maxn + 5], len_dcc = 1, Head_dcc[Maxn + 5];
struct edge {
    int to, Next;
}e[Maxm * 2 + 5], e_dcc[Maxm * 2 + 5];
void add (int x, int y) {
    e[++len].to = y;
    e[len].Next = Head[x];
    Head[x] = len;
}
void add_dcc (int x, int y) {
	e_dcc[++len_dcc].to = y;
	e_dcc[len_dcc].Next = Head_dcc[x];
	Head_dcc[x] = len_dcc;
}

int dfn[Maxn + 5], low[Maxn + 5], timstamp;
int st[Maxn + 5], Top;
int id[Maxn + 5], _min[Maxn + 5], dcc_cnt;
bool is_bridge[Maxm * 2 + 5];
void Tarjan (int u, int fa) {
    dfn[u] = low[u] = ++timstamp;
    st[++Top] = u;
    
    for (int i = Head[u]; i; i = e[i].Next) {
        int v = e[i].to;
        if (dfn[v] == 0) {
            Tarjan (v, i);
            low[u] = Min (low[u], low[v]);
            if (low[v] > dfn[u])
                is_bridge[i] = is_bridge[i ^ 1] = 1;
        }
        else if ((i ^ 1) != fa)
            low[u] = Min (low[u], dfn[v]);
    }
    
    if (dfn[u] == low[u]) {
        dcc_cnt++;
        int v;
        do {
            v = st[Top--];
            id[v] = dcc_cnt;
            _min[dcc_cnt] = Min (_min[dcc_cnt], v);
        }while (u != v);
    }
}

int d[Maxn + 5];
vector <pair <int, int> > v;
void dfs (int u, int fa) {
    dfn[u] = ++timstamp;
    if (d[u] == 1) {
        v.push_back (make_pair (dfn[u], _min[u]));
    }
    for (int i = Head_dcc[u]; i; i = e_dcc[i].Next) {
        int v = e_dcc[i].to;
        if (v == fa) continue;
        dfs (v, u);
    }
}

int g[Maxn + 5][Maxn + 5];

signed main () {
    memset (_min, 0x3f, sizeof _min);
    read (n); read (m);
    for (int i = 1; i <= m; i++) {
        int x, y; read (x); read (y);
        add (x, y); add (y, x);
    }
    for (int i = 1; i <= n; i++) {
        if (dfn[i] == 0)
            Tarjan (i, -1);
    }
    for (int i = 2; i <= len; i++)
        if (is_bridge[i] == 1)
            d[id[e[i].to]]++;
    for (int u = 1; u <= n; u++) {
    	for (int i = Head[u]; i; i = e[i].Next) {
    		int v = e[i].to;
    		if (id[u] == id[v]) continue;
    		if (is_bridge[i] == 1) {
    		    if (g[id[u]][id[v]] || g[id[v]][id[u]]) continue;
    		    g[id[u]][id[v]] = g[id[v]][id[u]] = 1;
    		    add_dcc (id[u], id[v]); add_dcc (id[v], id[u]);
    		}
		}
	}
    
    int root;
    for (int i = 1; i <= dcc_cnt; i++) {
        if (d[i] > 1) {
            timstamp = 0;
            dfs (i, -1);
            root = i;
            break;
        }
    }
    
    sort (v.begin (), v.end ());
    int len = (int)v.size ();
    printf ("%d\n", (len + 1) >> 1);
    for (int i = 0, j = (len + 1 >> 1); i <= len / 2, j < len; i++, j++) {
        printf ("%d %d\n", v[i].second, v[j].second);
    }
    if (len & 1) printf ("%d %d", v[len / 2].second, root);
	return 0;
}
5.求要加多少边才能使原图成为点双连通(还不会）

2.有向图

1.求有向图的强连通分量
vector <int> g[Maxn + 5];
int dfn[Maxn + 5], low[Maxn + 5], timestamp;
int scc_cnt, id[Maxn + 5];
int Top, st[Maxn + 5];
bool in_st[Maxn + 5];
void Tarjan (int u) {
    dfn[u] = low[u] = ++timestamp;
    st[++Top] = u; in_st[u] = 1;
    
    for (int i = Head[u]; i; i = e[i].Next) {
        int v = e[i].to;
        if (dfn[v] == 0) {
            Tarjan (v);
            low[u] = Min (low[u], low[v]);
        }
        else if (in_st[v] == 1)
            low[u] = Min (low[u], dfn[v]);
    }
    
    if (dfn[u] == low[u]) {
        scc_cnt++;
        int v;
        do {
            v = st[Top--];
            id[v] = scc_cnt;
            g[scc_cnt].push_back (v);
            in_st[v] = 0;
        }while (v != u);
    }
}
4.求要加多少边才能使原图成为强连通
#include <cmath>
#include <stack>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define ULL unsigned long long
using namespace std;

template <typename T> int read (T &x) {x = 0; T f = 1;char tem = getchar ();while (tem < '0' || tem > '9') {if (tem == '-') f = -1;tem = getchar ();}while (tem >= '0' && tem <= '9') {x = (x << 1) + (x << 3) + tem - '0';tem = getchar ();}x *= f; return 1;}
template <typename T> void write (T x) {if (x < 0) {x = -x;putchar ('-');}if (x > 9) write (x / 10);putchar (x % 10 + '0');}
template <typename T> T Max (T x, T y) { return x > y ? x : y; }
template <typename T> T Min (T x, T y) { return x < y ? x : y; }
template <typename T> T Abs (T x) { return x > 0 ? x : -x; }

const int Maxn = 100;
const int Maxm = 1e4;

int n;
int dfn[Maxn + 5], low[Maxn + 5], timestamp;
int st[Maxn + 5], Top;
bool in_st[Maxn + 5];
int scc_cnt, Size[Maxn + 5], id[Maxn + 5];
int din[Maxn + 5], dout[Maxn + 5];

int len, head[Maxn + 5];
struct edge {
    int to, next;
}e[Maxm + 5];

void add (int x, int y) {
    e[++len].to = y;
    e[len].next = head[x];
    head[x] = len;
}

void Tarjan (int u) {
    dfn[u] = low[u] = ++timestamp;
    st[++Top] = u; in_st[u] = 1;
    
    for (int i = head[u]; i; i = e[i].next) {
        int v = e[i].to;
        
        if (dfn[v] == 0) {
            Tarjan (v);
            low[u] = Min (low[u], low[v]);
        }
        else if (in_st[v] == 1) {
            low[u] = Min (low[u], dfn[v]);
        }
    }
    
    if (low[u] == dfn[u]) {
        scc_cnt++;
        int v;
        do {
            v = st[Top--];
            in_st[v] = 0;
            id[v] = scc_cnt;
            Size[scc_cnt]++;
        }while (u != v);
    }
}

int main () {
    read (n);
    for (int i = 1; i <= n; i++) {
        int x; read (x);
        while (x != 0) {
            add (i, x);
        	read (x);
        }
    }
    
    for (int i = 1; i <= n; i++)
        if (dfn[i] == 0)
            Tarjan (i);
    
    // printf ("%d\n", scc_cnt);
    
    int Start_cnt = 0, End_cnt = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = head[i]; j; j = e[j].next) {
            int k = e[j].to;
            int u = id[i], v = id[k];
            if (u == v) continue;
            dout[u]++;
            din[v]++;
        }
    }
    
    for (int i = 1; i <= scc_cnt; i++) {
        if (din[i] == 0) {
            Start_cnt++;
        }
        if (dout[i] == 0) {
            End_cnt++;
        }
    }
    
    // printf ("start = %d, end = %d\n", Start_cnt, End_cnt);
    
    if (scc_cnt == 1) {
        printf ("0");
    }
    else {
        printf ("%d", Max (Start_cnt, End_cnt));
    }
	return 0;
}
IDSY QAQ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
求连通分量
01-03
求无向图的连通分量，用的是c++的，喜欢的欢迎下载。
《C语言-数据结构篇章》-求连通图的分量》
weixin_45540964的博客
11-22 1250
无向图的的连通分量较为简单，只需要在深度优先遍历的时候，作一个记录就行。 深度搜索算法，就是利用递归的性质来做的。 void dfs(graphy *gra)//递归遍历 { int k=0; for(int i=1;i<=gra->node_number;i++) { if(visted[i-1]==0)//用来判断是否已经访问过了 ...
c++ 图DFS遍历, 及获取连通量(可用于判断两点间的可达性)
qq_31747473的博客
03-15 2868
数据结构-图 文章目录前言一、连通分量是什么？二、图的相关操作1. 存储的实现（邻接表）2.读入数据2.图的遍历（递归实现DFS）3. 连通分量的求解4. 连通分量判断两点是否可达 前言 图是一种挺复杂的数据结构，在此介绍一下图的遍历以及连通分量的求法： 一、连通分量是什么？ 我们在次不做定义的介绍，用通俗的语言： 连通分量可以理解为：图可以分为 互相没有联系的几个部分： 如下图： 第一张图片里面节点全相通（从任意一个节点都有路径到其他节点），所以称其连通分量为1 第二张图里面显然可以分为两个部
邻接表 计算连通分量C语言 数据结构
最新发布
weixin_44639345的博客
11-07 324
邻接表存储的图计算连通分量 ## 按照王道书的函数名称做滴
连通分量问题分析
TowlGol的博客
03-04 302
今天拿起来了小白书，开始仔细的过一过。 连通分量问题： 编写一个程序，输入QQ的好友关系，判断从指定任务出发是否能通过盆友链抵达目标任务。 （题目实在懒得写，拍了张照片） 关于这个问题，其实不难，是一个简单的无向图**（不一定连通哦）**，查找两个点之间是否连通，书本上给了一种解法，然后我把它打出来，发现觉得些许有些麻烦。 测试用例： 10 9 0 1 0 2 3 4 5 7 5 6 6 7 6...
识别连通分量
08-25
在图像处理领域，"识别连通分量"是一项基础且重要的任务。连通分量（Connected Component）是指在二值图像中，同一像素值的一组相邻像素的集合，它们通过水平、垂直或对角线方向上的连续像素相连。这项技术广泛应用...
leetcode323. 无向图中连通分量的数目
12-15
无向图中连通分量的数目”是关于寻找无向图中的连通分量数量的问题。连通分量是指图中任意两个节点之间都存在路径的子图，且这个子图是最大化的，即不能再添加其他节点而不破坏其连通性。 给定问题的输入包括两个...
实验_C++_数据结构_图连通分量_
10-03
本实验的主题是“C++数据结构_图连通分量”，这涉及到图论和算法设计。在这个实验中，我们将关注如何使用邻接表来存储无向图，并实现求解连通分量个数的算法。 首先，我们来理解什么是图。在计算机科学中，图是一种...
Tarjan 的强连通分量算法的Python实现
06-08
）图作为输入，并以拓扑顺序返回其强连通分量作为输出 循环依赖 在各种情况下，依赖关系可能是循环的，并且必须同时执行一组相互依赖的操作。同时执行成本高昂的情况并不少见。使用 Tarjan 算法，可以确定执行相互...
【老生谈算法】matlab实现求图的连通分量算法.doc
07-03
"matlab实现求图的连通分量算法" 该算法实现了使用MATLAB语言对图的连通分量的求解。连通分量是指图中的一组节点和边，它们之间存在连接关系，而与其他节点和边之间不存在连接关系。在本算法中，我们首先生成一个...
SDUT 1488-连通分量个数
0.2℃ 的博客
08-17 481
数据结构实验：连通分量个数Problem Description 在无向图中，如果从顶点vi到顶点vj有路径，则称vi和vj连通。如果图中任意两个顶点之间都连通，则称该图为连通图， 否则，称该图为非连通图，则其中的极大连通子图称为连通分量，这里所谓的极大是指子图中包含的顶点个数极大。 例如：一个无向图有5个顶点，1-3-5是连通的，2是连通的，4是连通的，则这个无向图有3个连通分量。Inp
强连通图的算法
热门推荐
justlovetao的专栏
08-09 2万+
有向图强连通分量的Tarjan算法 [有向图强连通分量] 在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量(stron
求有向图的强连通分量(c语言版)
weixin_37885641的博客
01-07 3272
求有向图的强连通分量(c语言版)
无向图的连通分量c语言源代码,求无向图的连通分量
weixin_39943992的博客
05-23 827
#include #include #include #include //无向图的邻接表存储表示 #define MAX_NAME 3 //#include #include #include #include //无向图的邻接表存储表示 #define MAX_NAME 3 // 顶点字符串的最大长度+1 #define MAX_VERTEX_NUM 20#define TRUE 1#de...
求连通分量（并查集）
沉默的大多数
03-21 1611
问题描述 求连通分量 输入格式 第一行，两个整数m，n，用空格分开，表示格子的行数、列数。 接下来一行，一个整数k，表示下面还有k行数据 接下来k行，第行两个整数a，b，表示ab连通。 样例输入 5 4 16 2 3 1 5 5 9 4 8 7 8 9 10 10 11 11 12 10 14 12 16 14 18 17 18 15 19 19 20 9 13 13 17 样例输...
连通分量 | Connected Components | C/C++实现
qq_40998706的博客
01-29 1490
问题描述 请编写一个程序，输入SNS的朋友关系，判断从指定人物出发能否通过双向朋友链抵达人物。 输入： 第1行输入代表SNS用户数的整数n以及代表朋友关系数的m，用空格隔开。SNS各用户的ID分别为0到n-1。 接下来的m行输入朋友关系，每个朋友关系占1行。1个朋友关系包含s、t这两个整数，表示s和t为朋友。s、t输入时用空格隔开。 紧接下来的1行输入问题数q。再接下来的q行输入问题。 各问题均为...
连通分量定义
TYWZzjm的博客
07-18 1万+
百度百科定义：无向图G的极大连通子图称为G的连通分量( Connected Component)。任何连通图的连通分量只有一个，即是其自身，非连通的无向图有多个连通分量。 我の理解：连通分量其实就是一个图里面并查集集合数量的多少，相当于一个图中有多少个连通图。 就相当于是一个森林里有多少棵树。 比如上面这个图里就有两个连通分量。 ...
有向图强连通分量算法-Kosaraju
"这篇内容主要讨论了有向图的强连通分量及其计算方法，具体介绍了Kosaraju算法的思想和实现步骤。" 在有向图中，强连通分量是指图中的一组节点，其中任意两个节点之间都存在双向路径。也就是说，对于分量内的任何...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值