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*2];//注意无向边相当于正反两条有向边,不然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=0;
    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>=2) 
        cut[fa[u]]=true;//入度>=2且为根的结点,因为一棵树的根一删不管有几棵子树肯定都不连通了
}

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

另一种写法,在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=0;
void input()
{
    scanf("%d%d",&n,&m);
    int a,b;
    for(int i=1;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=0;j<G[i].size();++j)
    {
        int k=G[i][j];
        if(dfn[k]==-1)
        {
            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=0;
    Tarjan(1,0);
    for(int i=2;i<=n;++i)
    {
        int v=father[i];
        if(v==1)
            rootson++;/*统计根节点子树的个数,根节点的子树个数>=2,就是割点*/
        else
        {
            if(low[i]>=dfn[v])/*割点的条件*/
            is_cut[v]=true;
        }
    }
    if(rootson>1)
        is_cut[1]=true;
    for(int i=1;i<=n;++i)
        if(is_cut[i])
            printf("%d
",i);
    for(int i=1;i<=n;++i)
    {
        int v=father[i];
        if(v>0&&low[i]>dfn[v])/*桥的条件*/
            printf("%d,%d
",v,i);
    }
    
}
int main()
{
    input();
    memset(dfn,-1,sizeof(dfn));
    memset(father,0,sizeof(father));
    memset(low,-1,sizeof(low));
    memset(is_cut,false,sizeof(is_cut));
    count();
    return 0;
}
原文地址:https://www.cnblogs.com/lovewhy/p/8442142.html