Tarjan算法

转自：点击打开链接

双连通分量

定义： 
对于一个连通图，如果任意两点至少存在两条点不重复路径，则称这个图为点双连通的（简称双连通）；如果任意两点至少存在两条边不重复路径，则称该图为边双连通的。点双连通图的定义等价于任意两条边都同在一个简单环中，而边双连通图的定义等价于任意一条边至少在一个简单环中。对一个无向图，点双连通的极大子图称为点双连通分量（简称双连通分量），边双连通的极大子图称为边双连通分量。这篇博客就是总结一下求解无向图点双连通分量与边双连通分量的方法。

无向图的双连通分量

        点-双连通图：一个连通的无向图内部没有割点，那么该图是点-双连通图。

        注意：孤立点，以及两点一边这两种图都是点-双连通的。因为它们都是内部无割点。

        边-双连通图：一个连通的无向图内部没有桥，那么该图就是边-双连通的。

        注意：孤立点是边-双连通的，但是两点一边不是边-双连通的。

        由上面定义可以知道：点-双连通图不一定是边-双连通的。

        对于一张无向图，点-双连通的极大子图称为双连通分量。不难发现,每条边恰好属于一个双连通分量(所以两点一边是一个点-双连通分量)。但不同双连通分量可能会有公共点，可以证明不同双连通分量最多只有一个公共点，且它一定是割顶。另一方面任意割顶都是至少两个不同的点-双连通分量的公共点。

        边-双连通的极大子图称为边-双连通分量。除了桥不属于任何边-双连通分量外，其他每条边恰好属于一个边-双连通分量，而且把所有桥删除之后,每个连通分量对应原图中的一个边-双连通分量。

        总之:

        判断一个图是不是点-双连通的只要看图中是否有割点。

        判断一个图是不是边-双连通的只要看图中是否有桥。

        (以上定义参考刘汝佳<<训练指南>>P314)

         求一个无向图的所有点双连通分量可以用下面的代码，但是求一个无向图的所有边双连通分量如何求呢？

        方法1：将无向图的所有桥边标记出来，然后执行dfs，且dfs过程中不走桥边。所以每次dfs经过的点都是同一个边-双连通分量的。

        方法2：对无向图执行dfs求割点，然后对于任意点i和j，如果low[i]==low[j]，那么它们属于同一个边-双连通分量(点-双连通分量内的两个点的low[]值不一定相同，自己画图验证下)。

算法： 
求解点双连通分量与边双连通分量其实和求解割点与桥密切相关。不同双连通分量最多只有一个公共点，即某一个割顶，任意一个割顶都是至少两个点双连通的公共点。不同边双连通分量没有公共点，而桥不在任何一个边双连通分量中，点双连通分量一定是一个边双连通分量。 
下面首先介绍点双连通分量的Tarjan算法： 
在之前的博客中，我们已经知道如何求解割顶了，很容易可以发现，当我们找到割顶的时候，就已经完成了一次对某个极大点双连通子图的访问，那么我们如果在进行DFS的过程中将遍历过的点保存起来，是不是就可以得到点双连通分量了？为了实现算法，我们可以在求解割顶的过程中用一个栈保存遍历过的边（注意不是点！因为不同的双连通分量存在公共点即割顶），之后每当找到一个点双连通分量，即子结点v与父节点u满足关系low[v]>=dfn[u]，我们就将栈里的东西拿出来直到遇到当前边。 
这里注意放入栈中的不是点，而是边，这是因为点双连通分量是存在重复点的，如果我们放入栈中的是点，那么对于某些点双连通分量，就会少掉一些点（这些点都是割顶）。 
代码：

struct Edge{
    int u,v;
    Edge(int u=0,int v=0):u(u),v(v){}
}e[maxm];
int n,m,stamp,dfn[maxn],low[maxn],iscut[maxn],bccno[maxn];
int scnt,stack[maxm],bcc_cnt;
vector<int> vec[maxn],bcc[maxn];

void tarjan(int index,int fa)
{
    int child=0,tmp;
    dfn[index]=low[index]=++stamp;
    for(int i=0;i<vec[index].size();i++)
    {
        tmp=e[vec[index][i]].v;
        if(!dfn[tmp])
        {
            stack[++scnt]=vec[index][i],child++;
            tarjan(tmp,index);
            low[index]=min(low[index],low[tmp]);
            if(low[tmp]>=dfn[index])
            {
                iscut[index]=1;
                bcc[++bcc_cnt].clear();
                while(1)
                {
                    int num=stack[scnt--];
                    if(bccno[e[num].u]!=bcc_cnt)
                    {
                        bcc[bcc_cnt].push_back(e[num].u);
                        bccno[e[num].u]=bcc_cnt;
                    }
                    if(bccno[e[num].v]!=bcc_cnt)
                    {
                        bcc[bcc_cnt].push_back(e[num].v);
                        bccno[e[num].v]=bcc_cnt;
                    }
                    if(e[num].u==index && e[num].v==tmp)
                        break;
                }
            }
        }
        else if(dfn[tmp]<dfn[index] && tmp!=fa)
        {
            stack[++scnt]=vec[index][i];
            low[index]=min(low[index], dfn[tmp]);
        }
    }
    if(fa<0 && child==1)
        iscut[index]=0;
}

void find_bcc()
{
    // 割顶的bccno值无意义 
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(iscut,0,sizeof(iscut));
    memset(bccno,0,sizeof(bccno));
    memset(bcc,0,sizeof(bcc));
    stamp=scnt=bcc_cnt=0;
    for(int i=1;i<=n;i++)
        if(!dfn[i])
            tarjan(i,-1);
}
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

这里需要十分注意的是，算法结束之后，每个结点会有一个编号，代表它属于哪一个点双连通分量，但是，割顶的编号是完全没有意义的！这个算法灵活使用了两个时间戳和栈，完成了点双连通分量的发现。 
例题：UVALIVE 5135

之后介绍边双连通分量的求解算法： 
边双连通分量的求解非常简单，因为边双连通分量之间没有公共边，而且桥不在任意一个边双连通分量中，所以算法十分简单，即先一次DFS找到所有桥，再一次DFS（排除了桥）找到边双连通分量。 
PS：当然可以用一次DFS实现。 
代码：

struct Edge{
    int u,v;
    Edge(int u=0,int v=0):u(u),v(v){}
}e[maxm];
int n,m,stamp,dfn[maxn],low[maxn],bccno[maxn],bcc_cnt;
vector<int> vec[maxn],bcc[maxn];
bool g[maxn][maxn],isbridge[maxm];

void tarjan(int index,int fa)
{
    int tmp;
    dfn[index]=low[index]=++stamp;
    for(int i=0;i<vec[index].size();i++)
    {
        tmp=e[vec[index][i]].v;
        if(!dfn[tmp])
        {
            tarjan(tmp,index);
            low[index]=min(low[index],low[tmp]);
            if(low[tmp]>dfn[index])
                isbridge[vec[index][i]]=isbridge[vec[index][i]^1]=1;
        }
        else if(dfn[tmp]<dfn[index] && tmp!=fa)
        {
            low[index]=min(low[index], dfn[tmp]);
        }
    }
}

void dfs(int index)
{
    dfn[index]=1;
    bccno[index]=bcc_cnt;
    for(int i=0;i<vec[index].size();i++)
    {
        int tmp=vec[index][i];
        if(isbridge[tmp])
            continue;
        if(!dfn[e[tmp].v])
        {
            dfs(e[tmp].v);
        }
    }
}

void find_ebcc(){
    bcc_cnt=stamp=0;
    memset(dfn,0,sizeof(dfn));
    memset(low,0,sizeof(low));
    memset(isbridge,0,sizeof(isbridge));
    memset(bccno,0,sizeof(bccno));
    memset(bcc,0,sizeof(bcc));
    for(int i=1;i<=n;i++)
        if(!dfn[i])
            tarjan(i, -1);
    memset(dfn,0,sizeof(dfn));
    for(int i=1;i<=n;i++)
    {
        if(!dfn[i])
        {
            bcc_cnt++;
            dfs(i);
        }
    }               
}
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

例题：POJ 3352

割点桥

Robert Endre Tarjan是一个美国计算机学家，他传奇的一生中发明了无数算法，统称为Tarjan算法。其中最著名的有三个，分别用来求解 
1) 无向图的双连通分量 
2) 有向图的强连通分量 
3) 最近公共祖先问题 
接下来几篇博客将分别讲述三个算法，首先是无向图的双连通分量，我们先从无向图的割点和桥讲起。

下面介绍中无向图中割点和桥的概念： 
割点：一个结点称为割点（或者割顶）当且仅当去掉该节点极其相关的边之后的子图不连通。 
桥：一条边称为桥（或者割边）当且仅当去掉该边之后的子图不连通。 
割点： 
首先我们考虑一个连通图（非连通图可以分别考虑连通块），我们从任意一个起点开始进行深度优先搜索，可以得到一棵树，并且这棵树中所有结点的子树之间不存在边，即没有跨越两棵子树的边（考虑一下，如果存在，那么与深度优先搜索树的定义互相矛盾）。于是有如下定理： 
在无向连通图G中， 
1、根结点u为割顶当且仅当它有两个或者多个子结点； 
2、非根结点u为割顶当且仅当u存在结点v，使得v极其所有后代都没有反向边可以连回u的祖先（u不算） 
在Tarjan算法里面，有两个时间戳非常重要，一个是dfn，意为深度优先数，即代表访问顺序；一个是low，意为通过反向边能到达的最小dfn。于是，上述定理中第二个条件（非根结点）可以简单地写成low[v]>=dfn[u]。 
代码如下：

int n,m,stamp,low[1005],dfn[1005],iscut[1005];
vector<int> vec[1005];
void tarjan(int index,int fa){
    int child=0;
    low[index]=dfn[index]=++stamp;
    for(int i=0;i<vec[index].size();i++)
    {
        int tmp=vec[index][i];
        if(!dfn[tmp])
        {
            child++;
            tarjan(tmp,index);
            low[index]=min(low[index],low[tmp]);
            if(low[tmp]>=dfn[index])
                iscut[index]=1;
        }
        else if(dfn[tmp]<dfn[index] && tmp!=fa)
        {
            low[index]=min(low[index],dfn[tmp]);
        }
    }
    if(fa<0 && child==1)
        iscut[index]=0;
}
     
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

桥： 
桥的求法其实也是类似的，它的求法可以看成是割顶的一种特殊情况，当结点u的子结点v的后代通过反向边只能连回v，那么删除这条边(u, v)就可以使得图G非连通了。用Tarjan算法里面的时间戳表示这个条件，就是low[v]>dfn[u]。 
代码如下：

int n,stamp,dfn[1005],low[1005];
int cnt,ansx[10005],ansy[10005];
vector<int> vec[1005];
int rank[1005];
void addAns(int x,int y)
{
    if(x>y)
        swap(x,y);
    ansx[cnt]=x, ansy[cnt]=y;
    cnt++;
}
void tarjan(int index,int fa)
{
    int tmp;
    dfn[index]=low[index]=++stamp;
    for(int i=0;i<vec[index].size();i++)
    {
        tmp=vec[index][i];
        if(!dfn[tmp])
        {
            tarjan(tmp,index);
            low[index]=min(low[index],low[tmp]);
            if(low[tmp]>dfn[index])
                addAns(index,tmp);
        }
        else if(dfn[tmp]<dfn[index] && tmp!=fa)
        {
            low[index]=min(low[index],dfn[tmp]);
        }
    }
}
     
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31