无向图 点连通tarjan算法 求割点 + 求BCC以及BCC里面的点 + 求去掉每个点后图中BCC数目 【总结】

看了好久，终于把点——双联通看懂了。

题目：给定一个有N个点M条边组成的无向图

1，求出图中BCC数目以及每个BCC里面的点。

2，求出所有割点。

3，求出去掉每个点后图中还剩多少个BCC。（即使图存在独立点+成环，下面模板也可以解决。但是若图中全是独立点，需要单独判断）

思路：

tarjan算法：

用low[]表示从该点或它的子孙出发 通过回边可以到达的最低深度优先数 

更新low[u]有三点：均在tarjan中实现

1，u本身的深度优先数dfn[u]

2，u的子女中最低深度优先数（对没有查询过的 要每次更新）

3，u通过回边可以到达的最低优先数

用dfn[u]表示该点的深度优先数。那么则有：

当割点u为根节点时，它的子节点数目必须有两个以上，而它的子节点数目就是BCC数目；

当割点u为非根节点时，若有d个子女w，使得low[w] >= dfn[u],那么去掉u则分成d+1个BCC。

 模板：注意点双联通可能会存在割点属于不同的BCC的情况。代码后给出例子。

#include 
#include 
#include 
#include 
#include 
#define MAXN 100+10
#define MAXM 10000+10
using namespace std;
struct Edge
{
	int from, to, next;
}edge[MAXM];
int head[MAXN], edgenum;//存储指针
int add_bcc[MAXN];//去掉该点增加的bcc数目
int dfn[MAXN];//该点的深度优先数
int low[MAXN];//从该点或它的子孙出发 通过回边可以到达的最低深度优先数
bool iscut[MAXN];//该点是否为割点
int bccno[MAXN], bcc_cnt;//该点属于哪个BCC bcc_cnt是BCC计数器
int dfs_clock;//时间戳
stack S;//存储当前bcc中的边
vector bcc[MAXN];//存储BCC里面的点
int num;//图可能存在 独立点  需要先计算出图中的块数
void init()
{
	edgenum = 0;
	memset(head, -1, sizeof(head));
}
void addEdge(int u, int v)
{
	Edge E1 = {u, v, head[u]};
	edge[edgenum] = E1;
	head[u] = edgenum++;
	Edge E2 = {v, u, head[v]};//无向图需要反向建边
	edge[edgenum] = E2;
	head[v] = edgenum++;
}
void getMap(int m)
{
	int a, b;
	while(m--)
	{
		scanf("%d%d", &a, &b);
		addEdge(a, b);
	}
}
void tarjan(int u, int fa)//u在DFS树中的父节点是fa
{
	low[u] = dfn[u] = ++dfs_clock;
	int child = 0;//记录子节点数目
	for(int i = head[u]; i != -1; i = edge[i].next)
	{
		Edge E = edge[i];
		int v = E.to;
		if(!dfn[v])
		{
			S.push(E);
			child++;
			tarjan(v, u);
			low[u] = min(low[u], low[v]);
			if(low[v] >= dfn[u])//割点 先不考虑根节点 最后再考虑
			{
				iscut[u] = true;
				add_bcc[u]++;//增加一个BCC
				bcc_cnt++;//BCC数目加一
				bcc[bcc_cnt].clear();//清空 开始记录点
				for(;;)
				{
					Edge x = S.top(); S.pop();
					if(bccno[x.from] != bcc_cnt)
					{
						bcc[bcc_cnt].push_back(x.from);//属于对应BCC 存储
						bccno[x.from] = bcc_cnt;
					}
					if(bccno[x.to] != bcc_cnt)
					{
						bcc[bcc_cnt].push_back(x.to);//属于对应BCC 存储
						bccno[x.to] = bcc_cnt;
					}
					if(x.from == u && x.to == v) break;
				}
			}
		}
		else if(dfn[v] < dfn[u] && v != fa)
		{
			S.push(E);
			low[u] = min(low[u], dfn[v]);//反向边更新
		}
	}
	//对根节点进行再次判断
	if(fa < 0 && child < 2) iscut[u] = false, add_bcc[u] = 0;//根节点不是割点
	if(fa < 0 && child > 1) iscut[u] = true, add_bcc[u] = child - 1;//根节点是割点 更新add_bcc的值
}
void find_cut(int l, int r)//左右区间 根据数据可以进行变化
{
	memset(add_bcc, 0, sizeof(add_bcc));
	memset(iscut, 0, sizeof(iscut));
	memset(low, 0, sizeof(low));
	memset(bccno, 0, sizeof(bccno));
	memset(dfn, 0, sizeof(dfn));
	dfs_clock = bcc_cnt = num = 0;
	for(int i = l; i <= r; i++)//从左到右
	if(!dfn[i]) tarjan(i, -1), num++;// 计算 图分成多少块
}
void putall(int l, int r)
{
    for(int i = l; i <= r; i++)
    {
        if(iscut[i])//割点
            printf("node %d is cut and ", i);
        printf("node %d leaves %d subsets\n", i, add_bcc[i] + num);
    }
}
void BCC()
{
	printf("have %d BCC(s)\n", bcc_cnt);//单复数就不区分了
	for(int i = 1; i <= bcc_cnt; i++)//输出每个BCC里面的点
	{
		printf("BCC %d have node(s): ", i);
		for(int j = 0; j < bcc[i].size(); j++)
		printf("%d ", bcc[i][j]);
		printf("\n");
	}
}
int main()
{
	int N, M;
	while(scanf("%d%d", &N, &M), N||M)//这里不考虑 M为0的情况
	{
		init();
		getMap(M);
		find_cut(1, N);//找割点 和 BCC
		putall(1, N);//输出割点 和 去掉每一个点 图中剩余的BCC
		BCC();//输出每个BCC里面的点
	}
	return 0;
}

输入数据

6 7

1 2

2 3

3 4

2 4

2 5

2 6

5 6

自己实践下，会发现割点2属于两个BCC。

所以在处理点双联通的问题时，还要注意对bccno[]数组的处理：

for(int i = 1; i <= bcc_cnt; i++)
{
	for(int j = 0; j < bcc[i].size(); j++) bccno[bcc[i][j]] = i;//用当前BCC时 要处理下 
}