P3388 【模板】割点（割顶）&& 桥

题目背景

割点

题目描述

给出一个n个点，m条边的无向图，求图的割点。

输入输出格式

输入格式：

第一行输入n,m

下面m行每行输入x,y表示x到y有一条边

输出格式：

第一行输出割点个数

第二行按照节点编号从小到大输出节点，用空格隔开

输入输出样例

输入样例#1： 复制

6 7
1 2
1 3
1 4
2 5
3 5
4 5
5 6

输出样例#1： 复制

1
5

说明

n,m均为100000

tarjan 图不一定联通！！！

———————————————————————————————————————————————————————————————————————————————

一.基本概念

1.桥：是存在于无向图中的这样的一条边，如果去掉这一条边，那么整张无向图会分为两部分，这样的一条边称为桥无向连通图中，如果删除某边后，图变成不连通，则称该边为桥。

2.割点：无向连通图中，如果删除某点后，图变成不连通，则称该点为割点。

二：tarjan算法在求桥和割点中的应用

1.割点：1）当前节点为树根的时候，条件是“要有多余一棵子树”（如果这有一颗子树，去掉这个点也没有影响，如果有两颗子树，去掉这点，两颗子树就不连通了。）

2）当前节点U不是树根的时候，条件是“low[v]>=dfn[u]”，也就是在u之后遍历的点，能够向上翻，最多到u，如果能翻到u的上方，那就有环了，去掉u之后，图仍然连通。

保证v向上最多翻到u才可以

2.桥：若是一条无向边（u，v）是桥，

1）当且仅当无向边（u，v）是树枝边的时候，需要满足dfn(u)<low(v)，也就是v向上翻不到u及其以上的点，那么u--v之间一定能够有1条或者多条边不能删去，因为他们之间有一部分无环，是桥。

如果v能上翻到u那么u--v就是一个环，删除其中一条路径后，能然是连通的。

3.注意点：

1）求桥的时候：因为边是无方向的，所以父亲孩子节点的关系需要自己规定一下，

在tarjan的过程中if（v不是u的父节点） low[u]=min(low[u],dfn[v]);

因为如果v是u的父亲，那么这条无向边就被误认为是环了。

2）找桥的时候：注意看看有没有重边，有重边的边一定不是桥，也要避免误判。

4.也可以先进行tarjan（），求出每一个点的dfn和low，并记录dfs过程中的每个点的父节点，遍历所有点的low，dfn来寻找桥和割点

———————————————————————————————————————————————————————————————————————————————

#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#define N 100001
using namespace std;

int n,m,cnt,ans,tim;
int head[N],dfn[N],low[N],fa[N];
//dfn[u]表示节点u被访问的时间，
//low[u]表示u及u的子树中所有结点能到达的结点中dfn最小的结点的时间
//fa[u]表示u的祖先结点
bool cut[N];
struct Edge
{
    int v;
    int next;
}edge[N*];//注意无向边相当于正反两条有向边，不然RE

void Add(int u,int v)
{
    cnt++;
    edge[cnt].next=head[u],
    edge[cnt].v=v,
    head[u]=cnt;
}

void Tarjan(int u)
{
    int rd=;
    dfn[u]=low[u]=++tim;
    for(int i=head[u];i;i=edge[i].next)
    {
        int v=edge[i].v;
        if(!dfn[v])
        {
            ++rd;    //记录有几个儿子
            fa[v]=u;//合并
            Tarjan(v);
            low[u]=min(low[u],low[v]);
            if(low[v]>=dfn[u]&&u!=fa[u])
                cut[u]=true;
            //非根且子树能达到的dfn最小的结点的时间>=自己的时间时
            //说明他的子树中最早能访问到的结点都比他后访问，只要不为根就一定是割点
        }
        else
            low[u]=min(low[u],dfn[v]);//把u及其子树可以达到的dfn最小结点更新
    }
    if(u==fa[u]&&rd>=)
        cut[fa[u]]=true;//入度>=2且为根的结点，因为一棵树的根一删不管有几棵子树肯定都不连通了
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=;i<=m;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        Add(x,y);Add(y,x);
    }
    for(int i=;i<=n;i++)
        fa[i]=i;    //因为题目中说图不一定联通，所以初始化每个结点的父亲结点都为其本身，如果联通的话可以省去
    for(int i=;i<=n;i++)
        if(!dfn[i])
            Tarjan(i);
    for(int i=;i<=n;i++)
        if(cut[i])
            ans++;
    printf("%d\n",ans);
    for(int i=;i<=n;i++)
        if(cut[i])
            printf("%d ",i);
    return ;
}

另一种写法，在dfs外边处理（附带求桥）：

#include<iostream>
using namespace std;
#include<cstdio>
#include<cstring>
#include<vector>
#define N 201
vector<int>G[N];
int n,m,low[N],dfn[N];
bool is_cut[N];
int father[N];
int tim=;
void input()
{
    scanf("%d%d",&n,&m);
    int a,b;
    for(int i=;i<=m;++i)
    {
        scanf("%d%d",&a,&b);
        G[a].push_back(b);/*邻接表储存无向边*/
        G[b].push_back(a);
    }
}
void Tarjan(int i,int Father)
{
    father[i]=Father;/*记录每一个点的父亲*/
    dfn[i]=low[i]=tim++;
    for(int j=;j<G[i].size();++j)
    {
        int k=G[i][j];
        if(dfn[k]==-)
        {
            Tarjan(k,i);
            low[i]=min(low[i],low[k]);
        }
        else if(Father!=k)/*假如k是i的父亲的话，那么这就是无向边中的重边，有重边那么一定不是桥*/
            low[i]=min(low[i],dfn[k]);//dfn[k]可能！=low[k]，所以不能用low[k]代替dfn[k],否则会上翻过头了。
    }
}
void count()
{
    int rootson=;
    Tarjan(,);
    for(int i=;i<=n;++i)
    {
        int v=father[i];
        if(v==)
            rootson++;/*统计根节点子树的个数，根节点的子树个数>=2,就是割点*/
        else
        {
            if(low[i]>=dfn[v])/*割点的条件*/
            is_cut[v]=true;
        }
    }
    if(rootson>)
        is_cut[]=true;
    for(int i=;i<=n;++i)
        if(is_cut[i])
            printf("%d\n",i);
    for(int i=;i<=n;++i)
    {
        int v=father[i];
        if(v>&&low[i]>dfn[v])/*桥的条件*/
            printf("%d,%d\n",v,i);
    }

}
int main()
{
    input();
    memset(dfn,-,sizeof(dfn));
    memset(father,,sizeof(father));
    memset(low,-,sizeof(low));
    memset(is_cut,false,sizeof(is_cut));
    count();
    return ;
}