无向图 点连通tarjan算法 求割点 + 求BCC以及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 <cstdio>
#include <cstring>
#include <queue>
#include <stack>
#include <algorithm>
#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<Edge> S;//存储当前bcc中的边
vector<int> 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 addcutnum(int le,int ri) //如果要统计 割点的个数，要这样统计
{
    int ans=0;
    for(int i=le;i<=ri;i++)
    if(iscut[i]) ans++;
    return ans;
}
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里面的点
        int num=addcutnum(1,N);
    }
    return 0;
}