强、双连通学习笔记

目录

• 有向图强连通分量
  • Tarjan算法
    • 定义
    • 做法
      • low,dfn的相等情况证明
      • DFS处理问题
      • 代码
  • 练习
    • 1
    • 2
    • 3
• 双连通分量
  • 边-双连通分量
    • 桥
    • 边双
      • 定义
      • 做法
      • 缩点
      • dfn,low相等情况证明
      • DFS处理
      • 代码
    • 练习
  • 点双连通分量
    • 割点
    • 点双连通分量
      • 点双缩点
      • 点双的点
      • 点双的边
      • 代码
    • 初始化问题
  • 求割点与桥
    • 割点
    • 桥
• 小结

updata：修正错误

有向图强连通分量

有向图强连通分量就是在一个强连通分量里面，每个点都能到达分量里面其他所有点。（很明显的是每个点只能属于一个分量）

那么，如何求？

Tarjan算法

例题

定义

我们定义一个low数组与一个dfs数组与一个ts（时间戳，不需要过多理解，下文看了就知道功能了）

做法

先说DFS树，Tarjan算法实际上是利用了DFS树和时间戳进行的寻找联通分量的算法。

一个图的DFS树是什么，对一个图进行DFS，每个点只能遍历一遍，走过的边和点构成了一棵树，例如下面这个例子。

时间戳是什么，你可以理解为访问这个点的时间，我们有个\(tim\)变量，每次访问一个点，就把\(tim++\)，因此不难发现，一个点访问的早，时间戳也早。

好，那么我们进入到DFS的世界中去：

（其中，边权为\(1\)的边表示不是DFS树中的边，有一条边有两个箭头的，原本是想两条有向边的，但是画图网站直接给我合并了。。。）

这里我们对于每个点开两个变量，一个\(dfn\)，储存时间戳，\(low\)刚开始储存时间戳，在中间可能更新，具体作用后面讲。

好，在DFS中，我们总是会遇到以下两种情况：

1. 这个点访问过了，实际上就是已经有了时间戳。
2. 这个点没有被访问过，表现上就是这个点没有时间戳。

第二种情况直接访问即可，因此我们要针对的是第一种情况。

对于\(4->2\)这条边，表现上是\(DFS\)树中儿子连向父亲，我们称其为\(A\)类边，那么代表这个儿子和父亲实际上是一个强连通分量。

对于\(2->4\)这条边，表现上是\(DFS\)树中父亲连向已经访问过的儿子，我们称其为\(B\)类边，那么这个儿子有没有可能跟这个这个父亲同一个分量呢？因为一个分量中的点能互相到达，所以默认是这个儿子来访问爸爸，而不是爸爸访问儿子，所以这个边我们先暂时不理会他。

对于\(3->5\)这条边，实际表现是一个子树连向另外一个子树，我们称其为\(C\)类边，这种情况比较复杂，所以我们将在下文的分析后，开始这三条边的分析。

（为了方便下文讨论，我们称第二种情况的边是\(D\)类边）

对于一个联通分量，两个点必定能互相访问（但是需要注意的是，\(x->y\)的路径和\(y->x\)的路径可能有相同的边，比如：\(1->2,2->3,3->4,3->1,4->2\)），加入这个分量中有一个点最先被访问，我们设他是\(fa\)吧，好，这个时候\(low\)派上了用场，如果一个点\(dfn==low\)，那么其是\(fa\)点，反之不是。

先假如图中只有一个联通分量，那么有以下几个引理：

1. 每个点都会被访问到。

   证明：如果\(x\)没有被访问到，假设\(fa\)到\(x\)的路径是：\(fa->a_1->a_2->...->a_k->x\)，那么\(a_k\)是会访问\(x\)的，什么？\(a_k\)也没有被访问，看\(a_{k-1}\)，一直看下去，\(fa\)总被访问了吧。

2. 一个分量的DFS树不一定只是一条链。

   你问我这个怎么证明？构造法啊。

   

   看，如果先更新了\(3\)，那么\(DFS\)树就变成了\(1\)有两个儿子\(2,3\)。

3. 如果\(x\)有一条边指向已经被访问过的点\(y\)，我们采用\(low[x]=min(low[y],low[x])\)的更新方式，且如果\(x\)访问到未访问点\(y\)，在\(y\)完成\(DFS\)之后，也执行上述语句，那么除了\(fa\)点外，每个点都不可能\(low==dfn\)。

   证明：假如一个点，如果一个点，或者其DFS子树中有一个点可以到达\(fa\)，那么这个点绝对不可能是\(low==dfn\)，那么对于一个点\(x\)，其一定存在一条到\(fa\)的路径，但是为什么其子树没有呢？还记得\(2\)中的例子吗，说明其路径中有点\(y\)已经被访问过了，如果假设\(y\)的\(low\)不等于\(y\)的\(dfn\)，因为\(y\)比\(x\)先访问，所以\(x\)也满足要求，而刚开始\(DFS\)时，第一个访问到已访问点的点，一定满足\(low\)不等于\(dfn\)。

   但实际上，\(low[x]=min(low[x],dfn[y])\)也不会错（但是需要注意，\(D\)类边的更新方式永远都是\(low[x]=min(low[y],low[x])\)），因为已访问点\(y\)比\(x\)先访问，所以也可以满足条件。

但是在实际使用中，是不可能只有一个联通分量的，因此，我们可以把一个强连通分量看成一个点，那么整个图就会变成DAG图，这个方法叫做缩点。

如这个例子，把左边变成了右边。

我们在\(DFS\)中，我们搜到一个分量中的一个点，上文讲了，称这个点为\(fa\)，那么所有这个分量的点都在其子树中，还记得上面的三条边吗。

\(A\)类边其实就是更新\(low\)的途径。

\(B\)类边毫无作用，因为如果这个儿子跟我是同一个分量，设这条边为\(x->z\)，则\(z\)在\(x\)的DFS树上的一个儿子\(y\)的子树中，那么可以直接通过\(y\)完成更新，完全没有必要考虑这种情况，但是考虑了也不会错，因此在打代码的过程中可以直接考虑，减少代码量（不难发现，在\(min(low[x],dfn[y])\)和\(min(low[x],low[y])\)两种更新模式都不会错）。

\(C\)类边，上文说了比较复杂，如：\(x->y\)，有可能\(x,y\)不是同一个分量的，那么\(y\)已经被先访问了，时间戳也比\(x\)小，那不就更新了吗？但是\(y\)所在的分量的\(fa\)节点是否已经结束\(DFS\)了呢，如果没有，说明\(y\)所在分量的\(fa\)是\(x\)在DFS树中的父亲，换而言之，\(x\)可以到达其父亲节点，那么\(x\)确实不可能是\(fa\)节点，而且是和\(y\)是同一个分量的矛盾，所以其\(fa\)一定已经停止\(DFS\)了（一个分量的\(fa\)停止了思考，表示这个分量的点都被找过了）。因此我们可以设置\(be\)数组，表示这个点所属的分量的\(fa\)节点是否已经停止了思考，然后只用\(be\)为\(0\)的点更新自身即可。

\(D\)类边，只需要担心\(x\)在其\(DFS\)子树中如果有不是跟\(x\)同个联通块的怎么处理。

需要证明一个东西，一个联通块的除\(fa\)以外的点的父亲节点都是这个联通块的点，根据引理1，每个点都会被访问，如果这个点被非联通块的点\(x\)访问了，那么\(fa\)可以到\(x\)，\(x\)可以到这个点，那么这个联通块的每个点都可以通过\(fa\)到\(x\)，\(x\)可以通过这个点到每个点，那么\(x\)也是这个联通块的点，矛盾，证毕。

所以如果\(x\)通过\(D\)类边访问到了\(y\)，\(y\)肯定是\(fa\)节点，假设\(y\)的\(low==dfn\)，那么\(x\)也肯定是正确的啦，而\(x\)的子树中一定存在一个\(fa\)点，其子树中不存在\(fa\)点，但是这个\(fa\)点一定满足要求吗？但是对于这个点而言\(ABC\)类边都是正确的，所以这个\(fa\)点也是正确的，证毕。

至于如何处理\(be\)吗，考虑到一个一个分量在\(DFS\)中的连续性，我们可以用栈储存，访问时，加入栈，当\(fa\)点回溯时，把\(fa\)点以及\(fa\)点以上的点全部弹出，根据数学归纳法，一定存在一个\(fa\)，其子树的不存在\(fa\)，这样肯定可以，而且访问\(fa\)之前和访问\(fa\)之后的栈是一样的，因此可以不断的把底层的分量删除，最终删完整个图。（其实细心的人不难发现，这不是缩点后的DAG的拓扑排序吗，这也是为什么说联通块编号是反着的拓扑序的原因）

low,dfn的相等情况证明

那么为什么\(x\)的\(low\)不一定等于分量中\(fa\)的\(dfn\)呢？

这还不简单，构造法啊。

如果\(2\)先访问了\(4\)，那么\(4\)的\(low\)并不会等于\(1\)，当然，这并不代表我们的做法是错的，只是单纯的因为\(1\)到\(4\)再回到\(1\)必须经过\(4\)而已，当然点双需要注意这个东西（后文会讲）。

扩展芝士：

当然，现在我们尝试证明存在\(fa->x->fa\)的一条路径使得路径上没有一个点重复走过，是\(low[x]=dfn[x]\)的充分不必要条件。（在\(min(low[x],low[y])\)的更新条件下）

充分性：

这样子的话，设路径为\(fa->a_1->a_2->...->a_q->x->b_1->...->b_p->fa\)，然后\(x\)访问到了\(b_i\)，发现\(b_i\)访问过了，就把\(x\)换成\(b_i\)，最终会换成一个\(b_j\)，使得访问\(b_j\)时，其子树中的一个点走过\(fa\)。

不必要性：

也就是证明\(low[x]=dfn[x]\)时，存在\(fa->x->fa\)的一条路径使得路径上没有一个点重复走过不成立，证明逆否命题是错的。

不存在\(fa->x->fa\)的一条路径使得路径上没有一个点重复走过时，则\(low[x]≠dfn[x]\)。

事实上：

这张图中，如果\(2\)优先访问了\(3\)，什么事都没有。

证毕

当然，至于\(min(low[x],dfn[y])\)的更新方式吗。懒得想

DFS处理问题

需要注意的一件事情是，一次\(DFS\)不一定可以搞出所有的点，所以需要判断每个点有没有\(DFS\)过，当然，也可以设置一个超级根节点，把这个点跟所有点连起来。

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
using  namespace std;
int  belong[61000],dfn[61000],cnt,low[61000],n,m,id;
struct  node
{
    int  y,next;
}a[210000];int  len,last[61000];
void  ins(int  x,int  y)
{
    len++;
    a[len].y=y;a[len].next=last[x];last[x]=len;
}//边目录
int  sta[61000],p;//栈
bool  v[61000];//所在的分量的fa找完没？其实就是上文的be数组
void  dfs(int  x)
{
    dfn[x]=low[x]=++id;sta[++p]=x;
    for(int  k=last[x];k;k=a[k].next)
    {
        int  y=a[k].y;
        if(dfn[y]==0)
        {
            dfs(y);//便历
            low[x]=min(low[x],low[y]);
        }
        else  if(v[y]==false)low[x]=min(low[x],dfn[y]);//low[x]=min(low[x],low[y]);也不会错
    }
    if(low[x]==dfn[x])
    {
        int  now=0;cnt++;
        do
        {
            now=sta[p--];
            v[now]=true;//找完了
            belong[now]=cnt;//所在的分量
        }while(now!=x  &&  p>0);
    }
}
int  main()
{
    scanf("%d%d",&n,&m);
    for(int  i=1;i<=m;i++)
    {
        int  x,y;scanf("%d%d",&x,&y);
        ins(x,y);
    }
    for(int  i=1;i<=n;i++)
    {
        if(dfn[i]==0)dfs(i);//遍历
    }
    printf("%d\n",cnt);
    return  0;
}

练习

1

1

这道题目难度有点大，我们做一遍Tarjan算法，然后把每个强连通分量当成一个点，计算每个点的入度与出度，我们需要知道，为什么这些点（我们已经把所有强连通分量缩点了）不在一个强连通分量里面？

比如：

我们可以姑且的认为，一个长得像\(1->2->3->4->...\)的点叫伪点（非专业术语）

而一个伪点一般有一个点入度为0，一个点出度为0，当然，即使有特殊情况使得某个为0也是没问题的，代表他和其他伪点已经有联系了。

那么，我们只需要把一个伪点没入度的连向没出度的（当然，只有一个分量的话要特判，直接输出0），也就是max(rdcnt,cdcnt)。

虽然很难理解，但是画以下图就知道了。

#include<cstdio>
#include<cstring>
#include<cstdlib>
using  namespace  std;
int  flog[21000],fa[21000],biao[21000],id,n,m,cnt,t;
struct  node
{
    int  x,y,next;
}a[51000];int  last[21000],len,list[21000],top;
bool  v[21000];
void  ins(int  x,int  y)
{
    len++;
    a[len].x=x;a[len].y=y;a[len].next=last[x];last[x]=len;
}
inline  int  mymin(int  x,int  y){return  x<y?x:y;}
inline  int  mymax(int  x,int  y){return  x>y?x:y;}
void  dfs(int  x)
{
    fa[x]=biao[x]=++id;
    list[++top]=x;v[x]=true;
    for(int  k=last[x];k;k=a[k].next)
    {
        int  y=a[k].y;
        if(biao[y]==0)
        {
            dfs(y);
            fa[x]=mymin(fa[x],fa[y]);
        }
        else
        {
            if(v[y]==true)fa[x]=mymin(fa[x],fa[y]);
        }
    }
    if(biao[x]==fa[x])
    {
        int  i=0;cnt++;
        while(i!=x)
        {
            i=list[top--];
            flog[i]=cnt;
            v[i]=false;
        }
    }
}
int  rd[21000],cd[21000];
int  main()
{
    //freopen("b.in","r",stdin);
    //freopen("1.out","w",stdout);
    scanf("%d",&t);
    while(t--)
    {
        memset(fa,0,sizeof(fa));
        memset(biao,0,sizeof(biao));cnt=0;len=0;id=0;
        memset(last,0,sizeof(last));top=0;
        memset(rd,0,sizeof(rd));memset(cd,0,sizeof(cd));
        scanf("%d%d",&n,&m);
        int  ans1=0,ans2=0;
        for(int  i=1;i<=m;i++)
        {
            int  x,y;scanf("%d%d",&x,&y);
            ins(x,y);
        }
        for(int  i=1;i<=n;i++)
        {
            if(biao[i]==0)dfs(i);
        }
        if(cnt==1)
        {
            printf("0\n");
            continue;
        }
        for(int  i=1;i<=m;i++)
        {
            int  tx=flog[a[i].x]/*缩点*/,ty=flog[a[i].y];
            if(tx!=ty)
            {
                rd[ty]++;cd[tx]++;
            }
        }
        for(int  i=1;i<=cnt;i++)
        {
            if(rd[i]==0)ans1++;
            if(cd[i]==0)ans2++;
        }
        printf("%d\n",mymax(ans1,ans2));
    }
    return  0;
}

2

2

我们先跑一遍二分匹配，然后把原本的边反向建（母牛连向公牛），并且连一条边，公牛连向他匹配的母牛，那么再跑一边强连通，我们就会发现每个分量里面都是公牛->母牛->公牛->母牛...

也就是说每个母牛至少有两个选择，公牛也是，然后我们在找公牛能****（手动打码）的每个母牛，如果母牛跟公牛在同一分量中，那么这个母牛原本的公牛也可以在找另外一头母牛，是不是很厉害？

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<bitset>
using  namespace  std;
const  int  cc=4010;
struct  node
{
	int  y,next;
}a[200010];int  len,last[cc];
struct  trlen
{
	int  x,y,next;
}map[200010];int  tlen,tlast[cc];
int  cnt,id,p;
int  sta[cc],low[cc],dfn[cc],belong[cc];
int  chw[cc],match[cc],n;
bool  v[cc];
void  ins(int  x,int  y)
{
	len++;
	a[len].y=y;a[len].next=last[x];last[x]=len;
}
void  ins1(int  x,int  y)
{
	tlen++;
	map[tlen].x=x;map[tlen].y=y;map[tlen].next=tlast[x];tlast[x]=tlen;
}
bool  find(int  x)
{
	for(int  k=tlast[x];k;k=map[k].next)
	{
		int  y=map[k].y;
		if(chw[y]!=id)
		{
			chw[y]=id;
			if(match[y]==0  ||  find(match[y])==true)
			{
				match[y]=x;
				return  true;
			}
		}
	}
	return  false;
}
void  dfs(int  x)
{
	low[x]=dfn[x]=++id;v[x]=true;sta[++p]=x;
	for(int  k=last[x];k;k=a[k].next)
	{
		int  y=a[k].y;
		if(low[y]==0)
		{
			dfs(y);
			low[x]=min(low[x],low[y]);
		}
		else  if(v[y]==true)low[x]=min(low[x],dfn[y]);
	}
	if(low[x]==dfn[x])
	{
		int  now=0;cnt++;
		do
		{
			now=sta[p--];
			v[now]=false;
			belong[now]=cnt;
		}while(now!=x);
	}
}
int  main()
{
	scanf("%d",&n);
	for(int  i=1;i<=n;i++)
	{
		int  kkk=0;scanf("%d",&kkk);
		for(int  j=1;j<=kkk;j++)
		{
			int  x;scanf("%d",&x);
			ins1(i,x+n);
		}
	}
	for(int  i=1;i<=n;i++)
	{
		id++;
		find(i);
	}//二分匹配
	for(int  i=1;i<=n;i++)ins(match[i+n],i+n);
	for(int  i=1;i<=tlen;i++)ins(map[i].y,map[i].x);
	for(int  i=1;i<=n;i++)
	{
		if(low[i]==0)dfs(i);
	}
	for(int  i=1;i<=n;i++)
	{
		int  jj=belong[i],ansl[cc];
		ansl[0]=0;
		for(int  j=tlast[i];j;j=map[j].next)
		{
			if(belong[map[j].y]==jj)ansl[++ansl[0]]=map[j].y-n;
		}
		sort(ansl+1,ansl+1+ansl[0]);
		for(int  j=1;j<ansl[0];j++)printf("%d ",ansl[j]);
		printf("%d\n",ansl[ansl[0]]);
	}
	//输出
	return  0;
}

3

3

这道题比较简单，如果一个强连通分量有边连向其他分量，这个分量都没用了。

#include<cstdio>
#include<cstring>
using  namespace  std;
inline  int  mymin(int  x,int  y){return  x<y?x:y;}
int  n,m;
int  low[21000],dfn[21000],belong[21000],cnt,out[21000],stp;
int  sta[21000],tp=0;bool  v[21000];
struct  node
{
	int  x,y,next;
}a[21000];int  last[21000],len;
int  ansl[21000];
void  ins(int  x,int  y)
{
	len++;
	a[len].x=x;a[len].y=y;a[len].next=last[x];last[x]=len;
}
void  dfs(int  x)
{
	low[x]=dfn[x]=++stp;v[x]=true;sta[++tp]=x;
	for(int  k=last[x];k;k=a[k].next)
	{
		int  y=a[k].y;
		if(low[y]==0)
		{
			dfs(y);
			low[x]=mymin(low[x],low[y]);
		}
		else  if(v[y]==true)low[x]=mymin(low[x],dfn[y]);
	}
	if(low[x]==dfn[x])
	{
		int  now=0;cnt++;
		while(now!=x)
		{
			now=sta[tp--];
			belong[now]=cnt;
			v[now]=false;
		}
	}
}
int  main()
{
	memset(v,true,sizeof(v));
	while(scanf("%d",&n)!=EOF)
	{
		if(n==0)break;
		scanf("%d",&m);
		memset(low,0,sizeof(low));stp=0;
		memset(last,0,sizeof(last));len=0;
		memset(out,0,sizeof(out));
		for(int  i=1;i<=m;i++)
		{
			int  x,y;scanf("%d%d",&x,&y);
			ins(x,y);
		}
		for(int  i=1;i<=n;i++)
		{
			if(low[i]==0)dfs(i);
		}
		for(int  i=1;i<=m;i++)
		{
			if(belong[a[i].x]!=belong[a[i].y])out[belong[a[i].x]]++;
		}
		for(int  i=1;i<=n;i++)
		{
			if(out[belong[i]]==0)ansl[++ansl[0]]=i;
		}
		for(int  i=1;i<ansl[0];i++)printf("%d ",ansl[i]);
		printf("%d\n",ansl[ansl[0]]);ansl[0]=0;
	}
	return  0;
}

双连通分量

双联通分量就是无向图的强连通分量

UPDATA：由于后面又更新了博客，所以有些内容看起来比较神奇，可能就是前一次的内容和后一次的更新内容卡一块了。

边-双连通分量

桥

如果原本两个点是连通的，截断一条边就使得两个点不联通了，这条边叫桥。

边双

定义

边双连通分量就是分量中不含桥的联通块。

一个点只会属于一个边双，如果属于两个边双，可以把这两个边双合并（因为如果这两个边双间有桥，删掉后，有\(x\)，不会不连通，所以矛盾，不存在桥）。

做法

没错，Tarjan永远的神！！！！

跟强连通一样的更新套路，但是需要注意的一件事情是，不可能存在\(C\)类边（比较重要的性质），因为如果\(x->y\)，那么理论上来讲，因为这是双向边，所以\(y\)在\(DFS\)的时候就可以访问\(x\)。而且需要注意。需要保存父亲边（需要注意的是，这里保存的是父亲边，因为可能存在重边），不能走过父亲边（但是如果题目中要求重边视为一条，则保存父亲），所以不需要保存\(be\)数组。

至于判断条件，有两种方法。

1. 对于\(low[x]==dfn[x]\)时，其到父亲的边是桥（但是如果\(x\)是\(DFS\)树的根则没有父亲），且\(x\)是\(fa\)点。

   这种跟强连通是比较像的，仔细想想可以发现，栈的证明是一样的。应该

2. 对于\(x\)在\(DFS\)树中的一个儿子\(y\)，若\(low[y]>dfn[x]\)，则\(x-y\)的边是桥，\(y\)是\(fa\)节点，需要注意的是，这种写法，栈的弹出设定不应该是：\(sta[top]!=x\)，而应该是\(now!=y\)，因为\(y,x\)在栈中不一定连续，可能存在\(x\)的另外一个儿子和\(x\)是一个边双的。

缩点

缩点都是差不多的，但是无向图的缩点最后会变成树，而不是DAG，后面的点双也是。

dfn,low相等情况证明

需要注意的是，由于边双中，\(fa->x->fa\)的路径中存在点重复无所谓，所以\(min\)中可以\(dfn,low\)都可以，而其\(low[x]\)和\(dfn[fa]\)的等于情况和强连通基本相同（好像就是相同的），所以不做过多分析。（反正不存在\(C\)类边，随便分析）

DFS处理

由于是无向图，如果图联通，只需要跑一次\(DFS\)，点双边双都一样，不需要像强连通一样用循环判断每个点时候\(DFS\)了。当然如果图不连通还是要的

代码

代码：

void  dfs(int  x,int  fa)
{
	low[x]=dfn[x]=++stp;
	sta[++tp]=x;
	for(int  k=last[x];k;k=a[k].next)
	{
		int  y=a[k].y;
		if(y!=fa)
		{
			if(low[y]==0)
			{
				dfs(y,x);
				low[x]=min(low[x],low[y]);
			}
			else  low[x]=min(low[x],dfn[y]);
		}
	}
	if(low[x]==dfn[x])
	{
		int  now=0;cnt++;
		while(now!=x)
		{
			now=sta[tp--];
			belong[now]=cnt;
		}
	}
}

练习

这次没例题，直接放练习

练习

像上次那样，我们记录每个分量的度（无向边），为0，ans+=2，为1，ans++

然后答案为ans/2+ans%2

#include<cstdio>
#include<cstring>
using  namespace  std;
inline  int  mymin(int  x,int  y){return  x<y?x:y;}
int  low[6000],dfn[6000],belong[6000],cnt,stp;
int  sta[6000],tp;
struct  node
{
	int  x,y,next;
}a[21000];int  last[6000],len;
int  ax[11000],ay[11000],n,m,io[11000],ans;
void  ins(int  x,int  y)
{
	len++;
	a[len].x=x;a[len].y=y;a[len].next=last[x];last[x]=len;
}
void  dfs(int  x,int  fa)
{
	low[x]=dfn[x]=++stp;
	sta[++tp]=x;
	for(int  k=last[x];k;k=a[k].next)
	{
		int  y=a[k].y;
		if(y!=fa)
		{
			if(low[y]==0)
			{
				dfs(y,x);
				low[x]=mymin(low[x],low[y]);
			}
			else  low[x]=mymin(low[x],dfn[y]);
		}
	}
	if(low[x]==dfn[x])
	{
		int  now=0;cnt++;
		while(now!=x)
		{
			now=sta[tp--];
			belong[now]=cnt;
		}
	}
}
int  main()
{
	scanf("%d%d",&n,&m);
	for(int  i=1;i<=m;i++)
	{
		scanf("%d%d",&ax[i],&ay[i]);
		ins(ax[i],ay[i]);ins(ay[i],ax[i]);
	}
	for(int  i=1;i<=n;i++)
	{
		if(low[i]==0)dfs(i,0);
	}
	if(cnt==1){printf("0\n");return  0;}//特判
	for(int  i=1;i<=m;i++)
	{
		if(belong[ax[i]]!=belong[ay[i]])io[belong[ax[i]]]++,io[belong[ay[i]]]++;
	}
	for(int  i=1;i<=cnt;i++)
	{
		if(io[i]==0)ans+=2;
		else  if(io[i]==1)ans++;
	}
	printf("%d\n",ans/2+ans%2);
	return  0;
}

点双连通分量

割点

就是把点割掉后，会导致原本联通块变成多个联通块，那么这个点就是割点。

点双连通分量

点双就是不含割点的连通分量（特别的，两个点一条边也是一个点双）。

点双最麻烦的就是一个点可能属于多个分量，如果一个点属于多个连通分量，此时这个点一定是割点，而割点也必然属于多个联通块，如下图。

我们发现，中间有一个点属于两个连通分量。

性质：

1. 点双每两个点存在一个简单环，每三个点\(x,y,z\)，一定存在\(x->y->z\)的一条简单路径。（应该吧，这个在下文小结给出的扩展资料有证明）
2. 我们探究一下边双和点双的关系，不难一个桥左右两个点一定是割点，而一条边左右两个点是割点，但这条边不一定是桥，好，这样的话，一个边双中可能含有很多个割点，只要不含桥即可，因此一个边双可以被拆分成多个点双，而且，点双中一定不存在桥。
3. 设\(x\)属于点双\(A\)，属于边双\(B\)，那么\(A∩B=B\)，证明：如果存在\(y\)不属于\(B\)而属于\(A\)，那么\(x,y\)之间存在简单环（点双的），环上不存在割边，那么\(y,x\)应该属于同一个边双，因此矛盾，证毕。

点双其实可以看作边的联通关系，因为每条边最多属于一个分量（这个证法就是删去证联通）。

点双依旧不存在\(C\)类边，且点的在\(DFS\)树中的连续性也是可以证明的，证法依旧类似。

但是突然发现一个十分重要的事情：如果不存在一条\(fa->x->fa\)的路径使得路径上点不重复（不包括起终点）的话，那么\(x,fa\)不可能是一个分量中的（实际上说明这个\(fa\)不是\(x\)所在连通分量的\(fa\)）。我们当时证明了，如果我们采用了\(min(low[x],low[y])\)的更新方式，那么\(low[x]=dfn[fa]\)，这个是很明显的错误，因此我们只能

那么就只能采用\(min(low[x],dfn[y])\)的更新方法了，但是这个为什么对呢？扩展资料中证明了，两个点之间不存在简单环，则一定存在割点，那么这种方法更新的话，\(x\)最多就等于\(x,fa\)中间那个割点的\(dfn\)，因此不用担心此情况，好，那么存在简单环就一定对吗？

好，就证明一个引理：

\(x-a_1-a_2-a_3.-..-a_q-y\)，其中\(x\)准备\(DFS\)，\(x\)在DFS树中在\(y\)的子树中，\(a_i(1≤i≤q)\)没有被访问过，那么在\(x\)\(DFS\)完之后，\(low[x]≤dfn[y]\)。假设\(a_i\)是下一个\(DFS\)的对象，那么只要\(a_i-...-y\)成立即可，运用数学归纳法，发现两个点一定成立，则数学归纳法生效。

好，现在证明点双中的除\(fa\)外每个点的\(low\)都小于\(dfn[x]\)（需要注意的是，本文的证明的\(fa\)都不是指父亲节点，而是指联通块\(fa\)节点，父亲节点我会特地的打中文）。

假设存在简单环：\(fa-a_1-a_2-...-a_q-fa\)，第一个被访问的点是\(a_i\)，那么\(a_i\)一定等于的\(low\)一定等于\(dfn[fa]\)，好，\(a_i\)到达\(a_j\)，那么，\(a_j\)的\(low\)也等于\(dfn[fa]\)，但是环上\(a_i-a_j\)中间的点呢？他们的\(low\)说不定不等于\(dfn[fa]\)，于是我们继续利用数学归纳法，已知\(a_i-a_j\)中最先被访问的点是\(a_k\)，那么\(a_k\)的\(low\)小于等于\(dfn[a_i]\)，小于\(dfn[a_k]\)，然后把区间切成了：\(a_i-a_k,a_k-a_i\)，最终一定会被切成两个点，中间没有任何点，证毕。

好，然后直接用\(min(low[x],dfn[y])\)更新方法即可，当然，\(D\)类边一直不变都是用\(low[y]\)更新的。

但需要注意的是，点双不需要保留父亲边，允许走父亲，反正每个点肯定和其父亲是同一个点双（因为两个点也是点双，至少有个保底）。

什么，判定一个点是不是\(fa\)节点？如果\(x\)通过\(D\)类边到\(y\)，然后\(low[y]==dfn[x]\)那么\(x\)是\(fa\)节点，和\(y\)一个点双。

点双缩点

由于每个割点，属于多个联通块，不能直接缩，因此，我们选择保留割点，删去所有的非割点，如果割点\(x\)属于联通块\(y\)，那么\(x\)与\(y+n\)连一条边即可。

点双的点

也许就有人要问了，MAD，一个点可以属于多个点双，还要栈干什么，反正每个点的\(belong\)可以有多个？但是在点双缩点的恰恰就需要找出一个点双中的点（但是不用保存到后面继续使用，而是直接用链式前向星缩点建树），这个时候了，我们发现一个点在结束完\(DFS\)后，就不会作为\(fa\)节点了，所以需要特殊考虑的就是当前\(DFS\)的节点\(x\)。

难道是如果\(x\)是\(fa\)节点的话，且和\(y\)一个分量，就把栈中\(x\)及\(x\)以上的全部弹出，然后再把\(x\)加回队列中？

不，类似边双的问题\(x,y\)不一定连续，所以应该把\(y\)和\(y\)以上的点全部弹出，并算上\(x\)即可。

点双的边

当然，有的时候需要搞出一个点双中所有的边，但是边只属于一个点双，就比较方便，直接在\(DFS\)中往栈塞\(D\)类边，但是\(A、B\)类边呢？因为双向边，所以\(A=B\)，所以只需要保存比较容易处理的\(A\)类边即可，然后在弹出的时候判断栈顶是不是\(x->\)y的\(D\)类边即可。

不对！！！！因为允许到父亲，所以实际上\(D⊂A\)，所以，几种处理方法：

1. 用\(v\)表示这个边是否用过。
2. 不保存\(D\)类边，但是这样栈弹出的否决条件就比较难处理，因此改进的方法可以是优先到父亲，或者说是到父亲的边不入栈。

当然还有其他方法，不再赘述。

代码

int  dfn[61000],cnt,low[61000],id;
int  sta[61000],p;
void  dfs(int  x)
{
    dfn[x]=low[x]=++id;sta[++p]=x;
    for(int  k=last[x];k;k=a[k].next)
    {
        int  y=a[k].y;
        if(!dfn[y])
        {
            dfs(y);
            low[x]=min(low[x],low[y]);
            if(low[y]==dfn[x])//我和你构成一个点双
            {
                int  now=0;cnt++;
                while(now!=y  &&  p>0)now=sta[p--];
                //可以在最后处理一下x
            }
        }
        else  low[x]=min(low[x],dfn[y]);
    }
}

初始化问题

其他自己想，三个分量都差不多，这里只说栈。

其他两个分量一个点只属于一个分量，所以最后栈中一个点不剩，

但是边双最后会剩一个点，\(DFS\)树的根，所以在初始化的时候别忘了\(top=0;\)

求割点与桥

割点

例题

我们研究DFS序就会发现，只要一个不是根结点的其中一个儿子的low小于等于（如果可以走父亲，可以直接换成等于）他的dfn，那么这个点就是割点，根节点就是他所在的点双个数大于等于\(2\)，当然具体表现就是\(D\)类边的个数，因为根节点的\(dfn\)最小，不可能小于，只能等于。

#include<cstdio>
#include<cstring>
#include<algorithm>
using  namespace std;
int  dfn[61000],low[61000],n,m,id;
struct  node
{
    int  y,next;
}a[210000];int  len,last[61000];
void  ins(int  x,int  y)
{
    len++;
    a[len].y=y;a[len].next=last[x];last[x]=len;
}

int  ans[130000];
void  dfs(int  x,bool  type)//判断是不是根节点而已
{
	bool  bk=false;int  cnt=0;
    dfn[x]=low[x]=++id;
    for(int  k=last[x];k;k=a[k].next)
    {
        int  y=a[k].y;
        if(!dfn[y])
        {
            cnt++;
            dfs(y,0);
            low[x]=min(low[x],low[y]);
            if(low[y]==dfn[x]/*桥就是>*/)bk=true;
        }
        else  low[x]=min(low[x],dfn[y]);
    }
	if(type)//根节点特判 
	{
		if(cnt>=2)ans[++ans[0]]=x;
	}
	else  if(bk==true)ans[++ans[0]]=x;
}
int  main()
{
    scanf("%d%d",&n,&m);
    for(int  i=1;i<=m;i++)
    {
        int  x,y;scanf("%d%d",&x,&y);
        ins(x,y);ins(y,x);
    }
    for(int  i=1;i<=n;i++)
    {
        if(dfn[i]==0)dfs(i,1);
    }
    sort(ans+1,ans+ans[0]+1);
    printf("%d\n",ans[0]);
    for(int  i=1;i<ans[0];i++)printf("%d ",ans[i]);
    if(ans[0])printf("%d\n",ans[ans[0]]);
    return  0;
}

桥

桥就不打了吧，直接在边双的时候随便乱搞都可以啦。

看个人喜好吧。

小结

又水了一篇博客

补充资料：我博客中的另外一篇博客关于“双联通分量的存在条件的证明（对于算法进阶的补充）”，应该可以加深你对点双的理解。

对于练习中有些题目的证明，强烈建议去网上搜证明，我的这个太不严谨了。（其实就是懒得更新练习了）