Tarjan强连通分量详解补充

statement

这篇博客引用了其他博客的资料，我自己补充了一点。好文必须转切补充！！

说到以Tarjan命名的算法，我们经常提到的有3个，其中就包括本文所介绍的求强连通分量的Tarjan算法。而提出此算法的普林斯顿大学的Robert E Tarjan教授也是1986年的图灵奖获得者（具体原因请看本博“历届图灵奖得主”一文）。

首先明确几个概念

补充：
1.割点：若删掉某点后，原连通图分裂为多个子图，则称该点为割点。

2.割点集合：在一个无向连通图中，如果有一个顶点集合，删除这个顶点集合，以及这个集合中所有顶点相关联的边以后，原图变成多个连通块，就称这个点集为割点集合。

3.点连通度：最小割点集合中的顶点数。

4.割边(桥)：删掉它之后，图必然会分裂为两个或两个以上的子图。

5.割边集合：如果有一个边集合，删除这个边集合以后，原图变成多个连通块，就称这个点集为割边集合。

6.边连通度：一个图的边连通度的定义为，最小割边集合中的边数。

7.缩点：把没有割边的连通子图缩为一个点，此时满足任意两点之间都有两条路径可达。 注：求块<>求缩点。缩点后变成一棵k个点k-1条割边连接成的树。而割点可以存在于多个块中。

8.双连通分量：分为点双连通和边双连通。它的标准定义为：点连通度大于1的图称为点双连通图，边连通度大于1的图称为边双连通图。通俗地讲，满足任意两点之间，能通过两条或两条以上没有任何重复边的路到达的图称为双连通图。无向图G的极大双连通子图称为双连通分量。

详解：
1、强连通图。在一个强连通图中，任意两个点都通过一定路径互相连通。比如图一是一个强连通图，而图二不是。因为没有一条路使得点4到达点1、2或3。

2、强连通分量。在一个非强连通图中极大的强连通子图就是该图的强连通分量。比如图三中子图{1,2,3,5}是一个强连通分量，子图{4}是一个强连通分量。

Tarjan算法的应用论述：

1.求强连通分量、割点、桥、缩点：
对于Tarjan算法中，我们得到了dfn和low两个数组，
low[u]:=min(low[u],dfn[v])——(u,v)为后向边，v不是u的子树； low[u]:=min(low[u],low[v])——(u,v)为树枝边，v为u的子树；

下边对其进行讨论：
若low[v]>=dfn[u],则u为割点，u和它的子孙形成一个块。
因为这说明u的子孙不能够通过其他边到达u的祖先，这样去掉u之后，图必然分裂为两个子图。
若low[v]>dfn[u],则(u,v)为割边。理由类似于上一种情况。

其实，tarjan算法的基础是DFS。我们准备两个数组Low和Dfn**。Low数组是一个标记数组，记录该点所在的强连通子图所在搜索子树的根节点的Dfn值（很绕嘴，往下看你就会明白），**Dfn数组记录搜索到该点的时间，也就是第几个搜索这个点的。根据以下几条规则，经过搜索遍历该图（无需回溯）和对栈的操作，我们就可以得到该有向图的强连通分量。

数组的初始化：当首次搜索到点p时，Dfn与Low数组的值都为到该点的时间。
堆栈：每搜索到一个点，将它压入栈顶。
当点p有与点p’相连时，如果此时（时间为dfn[p]时）p’不在栈中，p的low值为两点的low值中较小的一个。
当点p有与点p’相连时，如果此时（时间为dfn[p]时）p’在栈中，p的low值为p的low值和p’的dfn值中较小的一个。
每当搜索到一个点经过以上操作后（也就是子树已经全部遍历）的low值等于dfn值，则将它以及在它之上的元素弹出栈。这些出栈的元素组成一个强连通分量。

继续搜索（或许会更换搜索的起点，因为整个有向图可能分为两个不连通的部分），直到所有点被遍历。

由于每个顶点只访问过一次，每条边也只访问过一次，我们就可以在O（n+m）的时间内求出有向图的强连通分量。但是，这么做的原因是什么呢？

Tarjan算法的操作原理如下：

Tarjan算法基于定理：在任何深度优先搜索中，同一强连通分量内的所有顶点均在同一棵深度优先搜索树中。也就是说，强连通分量一定是有向图的某个深搜树子树。
可以证明，当一个点既是强连通子图Ⅰ中的点，又是强连通子图Ⅱ中的点，则它是强连通子图Ⅰ∪Ⅱ中的点。
这样，我们用low值记录该点所在强连通子图对应的搜索子树的根节点的Dfn值。注意，该子树中的元素在栈中一定是相邻的，且根节点在栈中一定位于所有子树元素的最下方。
强连通分量是由若干个环组成的。所以，当有环形成时（也就是搜索的下一个点已在栈中），我们将这一条路径的low值统一，即这条路径上的点属于同一个强连通分量。
如果遍历完整个搜索树后某个点的dfn值等于low值，则它是该搜索子树的根。这时，它以上（包括它自己）一直到栈顶的所有元素组成一个强连通分量。

Tarjan求有向图强连通分量、割点、割边的代码： 
Var 
    n,m,i,j,x,y,z:longint; 
    a,b:array[0..1000,0..1000]of longint;//图 
    dfn,low,s:array[0..1000]of longint;//dfn为时间戳，low为祖先，s为栈                   
    vis,ins:array[0..1000]of boolean;//vis为是否访问，ins为是否在栈中     
    num,p:longint; 
function min(x,y:longint):longint;  
begin 
    if x<y then exit(x) else exit(y); 
end; 
procedure tarjan(u:longint);  
var 
      i,v:longint;  
begin 
    inc(num);//给定一个时间戳   
    dfn[u]:=num;   
    low[u]:=num;   
    vis[u]:=true;   
    inc(p);//入栈 
    s[p]:=u; 
    ins[u]:=true; 
    for i:=1 to b[u,0] do//注意只有u与i相连才进行下面的操作    
    if not vis[b[u,i]] then//未被访问 
    begin 
        tarjan(b[u,i]); 
        low[u]:=min(low[u],low[b[u,i]]);//是树枝边，取两个low的min值 
       {如果是求割点或者割边，在这里判断dfn[u]和low[v]的大小并进行弹栈即可。}        
    end 
    else 
    if ins[b[u,i]] then//在栈中 
        low[u]:=min(low[u],dfn[b[u,i]]);//非树枝边，取low与dfn的min值      
    if dfn[u]=low[u] then//已经找到一个强连通分量，弹栈。    
    repeat     
         v:=s[p];    
         write(v,' ');     
         ins[v]:=false;     
         dec(p); 
         if u=v then writeln;    
    until u=v;  
end; 
begin 
     readln(n,m); 
     for i:=1 to m do//构图  
     begin 
         readln(x,y);    
         inc(b[x,0]); 
         b[x,b[x,0]]:=y;   
    end; 
    tarjan(1); 
End. 

2.求双连通分量以及构造双连通分量：
对于点双连通分支，实际上在求割点的过程中就能顺便把每个点双连通分支求出。
建立一个栈，存储当前双连通分支，在搜索图时，每找到一条树枝边或后向边(非横叉边)，就把这条边加入栈中。如果遇到某时满足DFS(u)<=Low(v)，说明u是一个割点，同时把边从栈顶一个个取出，直到遇到了边(u,v)，取出的这些边与其关联的点，组成一个点双连通分支。

割点可以属于多个点双连通分支，其余点和每条边只属于且属于一个点双连通分支。
对于边双连通分支，求法更为简单。只需在求出所有的桥以后，把桥边删除，原图变成了多个连通块，则每个连通块就是一个边双连通分支。桥不属于任何一个边双连通分支，其余的边和每个顶点都属于且只属于一个边双连通分支。

一个有桥的连通图，如何把它通过加边变成边双连通图？

方法为首先求出所有的桥，然后删除这些桥边，剩下的每个连通块都是一个双连通子图。把每个双连通子图收缩为一个顶点，再把桥边加回来，最后的这个图一定是一棵树，边连通度为1。

统计出树中度为1的节点的个数，即为叶节点的个数，记为leaf。
则至少在树上添加(leaf+1)/2条边，就能使树达到边二连通，所以至少添加的边数就是(leaf+1)/2。
具体方法为，首先把两个最近公共祖先最远的两个叶节点之间连接一条边，这样可以把这两个点到祖先的路径上所有点收缩到一起，因为一个形成的环一定是双连通的。然后再找两个最近公共祖先最远的两个叶节点，这样一对一对找完，恰好是(leaf+1)/2次，把所有点收缩到了一起。

3.求最近公共祖先（LCA）
在遍历到u时，先tarjan遍历完u的子树，则u和u的子树中的节点的最近公共祖先就是u,并且u和【u的兄弟节点及其子树】的最近公共祖先就是u的父亲。注意到由于我们是按照DFS顺序遍历的，我们可用一个color数组标记，正在访问的染色为1，未访问的标记为0，已经访问到即在【u的子树中的】及【u的已访问的兄弟节点及其子树中的】染色标记为2，这样我们可以通过并查集的不断合并更新，通过find实现以上目标。

Code

function find(x:longint):longint;   
begin 
    if f[x]<>x then f[x]:=find(f[x]);     
end; 
procedure tarjan(u:longint);   
begin 
     f[u]:=u; 
     for i:=1 to n do 
     if (g[u,i])and(color[i]=0) then//g[u,i]表示u连着i 
     begin 
            f[i]:=u;         
     end; 
     for i:=1 to n do 
     if ((ask[u,i])or(ask[i,u]))and(color[i]=2) then//ask[u,i]表示询问了u,i        
     begin 
         lca[u,i]:=find(i);
         lca[i,u]:=lca[u,i];       
      end; 
     color[u]:=2;  
 end;

一道例题（题号我忘了囧）

CODE

#include <cstdio>
#include <iostream>
#define N 50001
#define LL long long
#define fo(i,a,b) for (int i=a;i<=b;i++)

using namespace std;

int dfn[N],low[N],zhan[N];
bool v[N];
int t[2*N],next[2*N],last[2*N];
int n,m,l,top=0;
LL ans=0;

void add(int x,int y)
{
    t[++l]=y;
    next[l]=last[x];
    last[x]=l;
}

void tarjan(int x)
{
    zhan[++top]=x;
    dfn[x]=++l;
    low[x]=l;
    int k=last[x];
  //  bz[x]=true;
    v[x]=true;
    while (k!=0)
    {
        if (dfn[t[k]]==0)
        {
            tarjan(t[k]);
            if (low[t[k]]<low[x]) low[x]=low[t[k]];
        }
        else if (v[t[k]] && dfn[t[k]]<low[x]) low[x]=dfn[t[k]];
        k=next[k];
    }
    if (low[x]==dfn[x])
    {
        LL xdl=0;
        while (zhan[top+1]!=x)
        {
            v[zhan[top]]=false;
            top--;
            xdl++;
        }
        ans+=(xdl-1)*xdl/2;
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    int x,y;
    fo(i,1,m)
    {
        scanf("%d%d",&x,&y);
        add(x,y);
    }
    l=0;
    fo(i,1,n)
    if (not bz[i]) tarjan(i);
    printf("%d",ans);
}