Tarjan算法-CSDN博客

Tarjan算法整理

（[转自：http://blog.sina.com.cn/s/blog_60707c0f0100xdh5.html][http://blog.sina.com.cn/s/blog_71aa4dbb01010qsc.html] [http://blog.sina.com.cn/s/blog_71aa4dbb01010pq0.html]）

基本概念：

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

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

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

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

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

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

7.缩点：把没有割边的连通子图缩为一个点，此时满足任意两点之间都有两条路径可达。

注：求块<>求缩点。缩点后变成一棵k个点k-1条割边连接成的树。而割点可以存在于多个块中。

8.双连通分量：分为点双连通和边双连通。

它的标准定义为：点连通度大于1的图称为点双连通图，边连通度大于1的图称为边双连通图。

通俗地讲，满足任意两点之间，能通过两条或两条以上没有任何重复边的路到达的图称为双连通图。

无向图G的极大双连通子图称为双连通分量。

<1>求强连通分量

在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量。下图中，子图{1,2,3,4}为一个强连通分量，因为顶点1,2,3,4两两可达。{5},{6}也分别是两个强连通分量：

根据定义，用双向遍历取交集的方法求强连通分量，时间复杂度为O(N^2+M)。更好的方法是Kosaraju算法或Tarjan算法，两者的时间复杂度都是O(N+M)。本文介绍的是Tarjan算法。Tarjan算法是基于对图深度优先搜索的算法，每个强连通分量为搜索树中的一棵子树。搜索时，把当前搜索树中未处理的节点加入一个堆栈，回溯时可以判断栈顶到栈中的节点是否为一个强连通分量。定义DFN(u)为节点u搜索的次序编号(时间戳)，Low(u)为u或u的子树能够追溯到的最早的栈中节点的次序号。由定义可以得出，Low(u)=Min { DFN(u), Low(v),(u,v)为树枝边，u为v的父节点 DFN(v),(u,v)为指向栈中节点的后向边(非横叉边)} 当DFN(u)=Low(u)时，以u为根的搜索子树上所有节点是一个强连通分量。

（附伪代码）

tarjan(u)
{
  DFN[u]=Low[u]=++Index // 为节点u设定次序编号和Low初值
  Stack.push(u)// 将节点u压入栈中
  for each (u, v) in E // 枚举每一条边
    if(v is not visted)// 如果节点v未被访问过
      tarjan(v)// 继续向下找
      Low[u]= min(Low[u], Low[v])
    elseif(v in S)// 如果节点u还在栈内
      Low[u]= min(Low[u], DFN[v])

    if(DFN[u]== Low[u])// 如果节点u是强连通分量的根
      repeat
        v = S.pop// 将v退栈，为该强连通分量中一个顶点
        print v
      until (u== v)
}

算法流程图示：

从节点1开始DFS，把遍历到的节点加入栈中。搜索到节点u=6时，DFN[6]=LOW[6]，找到了一个强连通分量。退栈到u=v为止，{6}为一个强连通分量。

返回节点5，发现DFN[5]=LOW[5]，退栈后{5}为一个强连通分量。

返回节点3，继续搜索到节点4，把4加入堆栈。发现节点4像节点1的后向边，节点1还在栈中，所以LOW[4]=1。节点6已经出栈，不再访问6，返回3，(3,4)为树枝边，所以LOW[3]=LOW[4]=1。

继续回到节点1，最后访问节点2。访问边(2,4)，4还在栈中，所以LOW[2]=4。返回1后，发现DFN[1]=LOW[1]，把栈中节点全部取出，组成一个连通分量{1,3,4,2}。

至此，算法结束。经过该算法，求出了图中全部的三个强连通分量{1,3,4,2},{5},{6}。可以发现，运行Tarjan算法的过程中，每个顶点都被访问了一次，且只进出了一次堆栈，每条边也只被访问了一次，所以该算法的时间复杂度为O(N+M)。

对于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的子树；

<2>Tarjan求割点

若low[v]>=dfn[u],则u为割点，节点v的子孙和节点u形成一个块。因为这说明v的子孙不能够通过其他边到达u的祖先，这样去掉u之后，图必然分裂为两个子图。这样我们处理点u时，首先递归u的子节点v，然后从v回溯至u后，如果发现上述不等式成立，则找到了一个割点u，并且u和v的子树构成一个块。

void tarjan(int x)
{
 v[x]=1,dfn[x]=low[x]=++num;
 for(int i=head[x];i;i=next[i])
  if(!v[ver[i]])
  {
   tarjan(ver[i]);
   low[x]=min(low[x],low[ver[i]]);
   if(dfn[x]<=low[ver[i]]) v[x]++;
  }
  else low[x]=min(low[x],dfn[ver[i]]);
 if((x==1&&v[x]>2)||(x>1&&v[x]>1)) v[x]=2; else v[x]=1;//v[x]=2表示该点为割点，注意其中第一个点要特判
}

<3>Tarjan求割边（桥）
若low[v]>dfn[u],则(u,v)为割边。但是实际处理时我们并不这样判断，因为有的图上可能有重边，这样不好处理。我们记录每条边的标号（一条无向边拆成的两条有向边标号相同），记录每个点的父亲到它的边的标号，如果边(u,v)是v的父亲边，就不能用dfn[u]更新low[v]。这样如果遍历完v的所有子节点后，发现low[v]=dfn[v]，说明u的父亲边(u,v)为割边。

<span style="color: rgb(85, 85, 85);">void tarjan(int x)
{
 vis[x]=1;
 dfn[x]=low[x]=++num;
 for(int i=head[x];i;i=next[i])
  if(!vis[ver[i]])
  {
   p[ver[i]]=edge[i];//记录父亲边
   tarjan(ver[i]);
   low[x]=min(low[x],low[ver[i]]);
  }
  else if(p[x]!=edge[i])//</span><span style="color:#ff0000;">不是父亲边才更新</span><span style="color:#555555;">
   low[x]=min(low[x],dfn[ver[i]]);
 if(p[x]&&low[x]==dfn[x]) f[p[x]]=1;//是割边
}</span>

<4>求点双连通分量

求点双连通分量可以在求割点的同时用栈维护。在搜索图时，每找到一条树枝边或后向边(非横叉边)，就把这条边加入栈中。如果遇到某时满足DFS(u)<=Low(v)，说明u是一个割点，同时把边从栈顶一个个取出，直到遇到了边(u,v)，取出的这些边与其关联的点，组成一个点双连通分支。割点可以属于多个点双连通分支，其余点和每条边只属于且属于一个点双连通分支。

stack<int> s;
int num = 1;
int time = 0;
int id[1000] = {0};
void tarjan(int x, int fa)
{
    dfn[x] = low[x] = time++;
    for(int e = first[x]; e != -1; e = next[e])
     {
        if(x != fa && dfn[x] < dfn[v[e]])
         {
            s.push(e);
            if(dfn[x] == 0)
             {
                tarjan(v[e], x);
                if(low[v[e]] < low[x]) low[x] = low[v[e]];
                if(low[v[e]] >= dfn[x])//x是割点
                 {
                    int edge;
                    do{ 
                        s.pop();
                        edge = s.top();
                        id[u[edge]] = id[v[edge]] = num++;
                    }while(u[edge] != x || v[edge] != v[e]);
                }
            }
            else 
			 if(dfn[v[e]] < low[x]) low[x] = dfn[v[e]];//只剩下反向边了
        }
    } 
}

<5>求边双连通分量

求边连通分量时，只需要先求出桥，然后把桥全部去掉，原图变成了多个连通块，则每个连通块就是一个边双连通分量。桥不属于任何一个边双连通分量，其余的边和每个顶点都属于且只属于一个边双连通分量

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

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

统计出树中度为1的节点的个数，即为叶节点的个数，记为leaf。则至少在树上添加(leaf+1)/2条边，就能使树达到边二连通，所以至少添加的边数就是(leaf+1)/2。

首先把两个最近公共祖先最远的两个叶节点之间连接一条边，这样可以把这两个点到祖先的路径上所有点收缩到一起，因为一个形成的环一定是双连通的。然后再找两个最近公共祖先最远的两个叶节点，这样一对一对找完，恰好是(leaf+1)/2次，把所有点收缩到了一起。

void tarjan(int u,int fa)
{
    int e;
    dfn[u]=low[u]=++time;
    s[top++]=u;
    for(e=first[u];e!=-1;e=next[e])
     if(v[e]!=fa)
      {
        if(!dfn[v[e]])
         {
            tarjan(v[e],u);
            if(low[v[e]]<low[u])
              low[u]=low[v[e]];
             else 
			  if(low[v[e]]>dfn[u])
               {
                    for(s[top]=-1;s[top]!=v[e];) id[s[--top]]=num;
                    num++;
                }
        }
        else 
		 if(dfn[v[e]]<low[u])  low[u]=dfn[v[e]];
      }
}

<6>求最近公共祖先

在遍历到u时，先tarjan遍历完u的子树，则u和u的子树中的节点的最近公共祖先就是u,并且u和【u的兄弟节点及其子树】的最近公共祖先就是u的父亲。注意到由于我们是按照DFS顺序遍历的，我们可用一个color数组标记，正在访问的染色为1，未访问的标记为0，已经访问到即在【u的子树中的】及【u的已访问的兄弟节点及其子树中的】染色标记为2，并查集维护
[注：用链表存储边和问题，可以使得该算法的时间复杂度降低为O(n+m+q)]

int find(int x)
{
	if(f[x]==x) return f[x];
	f[x]=find(f[x]);
	return f[x]; 
}
void tarjan(int x)
{
	f[x]=x; color[x]=1;
	for(int i=1;i<=n;++i)
	 if(g[x][i]&&!color[i])
	  tarjan(i),f[i]=x;
	for(int i=1;i<=n;++i)
	 if((ask[x][i]||ask[i][x])&&color[i]==2) lca[x][i]=find(i),lca[i][x]=lca[x][i];
	color[x]=2;
}