Tarjan-割点&桥&双连通

$Tarjan$求割点

　　感觉图论是个好神奇的东西啊，有各种奇奇怪怪的算法，而且非常巧妙。

　　周末之前说好回来之后进行一下学术交流，于是wzx就教了$Tarjan$，在这里我一定要说：

　　wzx  AK  IOI!

　　Tarjan发明了很多算法，而且还都叫一个名字，所以说只好用用途来区分它们。

　　闲聊时间结束。

 

---

　　首先,什么是割点呢？在一个无向图中，如果有一个顶点，删除这个顶点以及所有相关联的边以后，图的连通分量增多，就称这个点为割点。

　　首先找一个点作为根进行搜索，把图按照$dfs$的方法组织成一棵搜索树，树上的边一定都是图上的边，称为树边，而图上其余的边则为非树边（回边）。

　　如果一个点不能通过非树边而回到比他树上的父亲的$dfs$序更小的点，那么如果把它树上的父亲删掉，它就不能通过其他方法与图的其他部分联通，它的父亲就是一个割点。多么神奇啊！对于根节点，我们可以发现，如果它有不止一个的子树，那它就是割点了。看代码：

　　割点：https://www.luogu.org/problemnew/show/P3388

　　

void dfs(int x,int roo,int Dad)
{
    id[x]=low[x]=++cnt;
    int j,cnts=0;
    for (R i=firs[x];i;i=g[i].nex)
    {
        j=g[i].too;
        if(!id[j])
        {
            dfs(j,roo,x);
            low[x]=min(low[x],low[j]);
            if(x==roo) cnts++;
            if(low[j]>=id[x]&&x!=roo) f[x]=1;
        }
        else 
        {
            if(j!=Dad) low[x]=min(low[x],low[j]);
        }
    }
    if(x==roo&&cnts>=2) f[x]=1;
}

　　这里有一句话还是比较重要的：

　1 if(j!=Dad) low[x]=min(low[x],low[j]);

　　是防止重复走树边，其实也可以改成 $low[x]=min(low[x],id[j])$，这样更新出来的$low$可能不是真正的$low$,但是因为儿子到父亲的路径上不会再有别的点，所以这样也能保证正确性。

---

 

 　　割点的理论知识似乎就到此为止了，现在还是看几道题比较好。

　　[POI2008]BLO-Blockade：https://www.luogu.org/problemnew/show/P3469

　　题意概述：在一个无向图中删去一个点后，还有多少个有序的(x,y)的点对本可以联通但是现在不能联通了？输出删除每一个点之后的答案。

　　这道题还是挺妙的，不算是板子题，有一点点思维含量，这样的题最适合入门新算法啦。

　　如果一个点不是割点，那么损失的点对只有与它直接相连的点；如果一个点是割点，那么割掉它之后图就分成了一些小块，在每个小块内仍是$size*(size-1)$；这么一说感觉也没啥思维难度啊...

　　

# include <cstdio>
# include <iostream>
# define R register int

using namespace std;

const int maxn=100009;
const int maxm=500009;
int cnt=0,h=0,n,m,x,y,firs[maxn],f[maxn],id[maxn],low[maxn];
long long ans[maxn],siz[maxn];
struct edge
{
    int too,nex;
}g[maxm<<1];

void add(int x,int y)
{
    g[++h].too=y;
    g[h].nex=firs[x];
    firs[x]=h;
}

int read()
{
    int x=0;
    char c=getchar();
    while (!isdigit(c))
        c=getchar();
    while (isdigit(c))
    {
        x=(x<<3)+(x<<1)+(c^48);
        c=getchar();
    }
    return x;
}

void dfs(int x,int roo)
{
    id[x]=low[x]=++cnt;
    int j,s=0;
    siz[x]=1;
    for (R i=firs[x];i;i=g[i].nex)
    {
        j=g[i].too;
        if(!id[j])
        {
            dfs(j,roo);
            low[x]=min(low[x],low[j]);
            siz[x]+=siz[j];
            if(low[j]>=id[x]) 
            {
                ans[x]+=(long long)s*siz[j];
                s+=siz[j];
            }
        }
        else
            low[x]=min(low[x],id[j]);
    }
    ans[x]+=(long long)s*(n-s-1);    
}

int main()
{
    n=read();
    m=read();
    for (R i=1;i<=m;++i)
    {
        x=read();
        y=read();
        add(x,y);
        add(y,x);
    }
    for (R i=1;i<=n;++i)
        if(!id[i]) dfs(i,i);
    for (R i=1;i<=n;++i)
        printf("%lld\n",(ans[i]+n-1)<<1);
    return 0;
}

　 其实割点的题比较少见唉...

 

$Tarjan$求割边(桥)

　　什么是割边呢？如果删去一条边后整个图变得不连通了，那么这条边就叫做这个图的一个割边。显然割边是对于无向图的一种东西，有向图是无法定义图的连通性的。

　　割点和割边听起来总是有种神奇的联系，所以有两个猜想：

　　1.两个割点中间连一条边一定是桥；

　　2.桥的两个端点都是割点；

　　然而并不是...都是错的...

　　如果对图上的边对于在搜索树上出现的位置进行分类，可以分为：树枝边(搜索树上的树枝)，返祖边(指向搜索树上祖先的边),正向边(指向后代,但不是搜索树上的边),横叉边(指向搜索树与它不在同一子树上的边).然而无向图不存在横叉边.考虑反证法:如果$X$有指向其他子树的边,那必然也有从那边指过来的边,所以之前搜索时应该已经搜到过$X$了,这是不成立的.

　　那么一条边成为桥需要什么条件呢?首先对于搜索树上的一个节点$x$和它的子节点$y$，如果$low[y]>id[x]$,也就是说如果不走$(x,y)$这条边,$y$就无法与搜索树的其他部分相连通,那么$(x,y)$这条边就是一条割边.但是可以发现$low[y]<=id[y]$且$low[y]>id[x]$,而且$x$是$y$的直接祖先,所以可以认为是$low[y]=id[y]$,这就和缩点有一些相似之处了.这里有一些细节问题需要注意:怎样防止走反向边回到父亲去?一种最简单的方法是记录每个点在搜索书上的父亲.很可惜,这样做是错误的.如果一个点和它的父节点间有重边,那么这几条边肯定都不是割边,但是这样的做法却可能误判成割边.正确的做法是记录上一条走的边的编号且利用网络流反向边的标号技巧，注意不要走它即可。

　　来一道例题吧：

　　旅游航道：https://loj.ac/problem/10102

　　题意概述：求割边的数量。

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# define R register int

using namespace std;

const int maxn=30004;
int n,m,h,firs[maxn],low[maxn],id[maxn],cnt,x,y,ed;
struct edge
{
    int too,nex;
}g[maxn<<1];

void dfs (int x,int las)
{
    int j;
    low[x]=id[x]=++cnt;
    for (R i=firs[x];i;i=g[i].nex)
    {
        j=g[i].too;
        if(i==(las^1)) continue;
        if(!id[j]) dfs(j,i);
        low[x]=min(low[x],low[j]);
        if(low[j]>id[x]) ed++;
    }
}

void add (int x,int y)
{
    g[++h].nex=firs[x];
    firs[x]=h;
    g[h].too=y;
}

int main()
{
    scanf("%d%d",&n,&m);
    while(n||m)
    {
        h=1;
        cnt=ed=0;
        memset(firs,0,sizeof(firs));
        memset(id,0,sizeof(id));
        memset(low,0,sizeof(low));
        for (R i=1;i<=m;++i)
        {
            scanf("%d%d",&x,&y);
            add(x,y);
            add(y,x);
        }
        for (R i=1;i<=n;++i)
            if(!id[i]) dfs(i,-1);
        printf("%d\n",ed);
        scanf("%d%d",&n,&m);
    }
    return 0;
}

　　割边好像不是很难。但是，难的还在后面。

边双连通分量

　　边双连通分量是什么？

---shzr