tarjan强连通图分量

[有向图强连通分量]

　　有向图强连通分量的Tarjan算法

在有向图G中，如果两个顶点间至少存在一条路径，称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量(strongly connected components)。

　　下图中，子图{1,2,3,4}为一个强连通分量，因为顶点1,2,3,4两两可达。{5},{6}也分别是两个强连通分量。

　　


[Tarjan算法]

　　Tarjan算法是基于对图深度优先搜索的算法，每个强连通分量为搜索树中的一棵子树。搜索时，把当前搜索树中未处理的节点加入一个堆栈，回溯时可以判断栈顶到栈中的节点是否为一个强连通分量。

　　定义DFN(u)为节点u搜索的次序编号(时间戳)，Low(u)为u或u的子树能够追溯到的最早的栈中节点的次序号。
　 当DFN(u)=Low(u)时，以u为根的搜索子树上所有节点是一个强连通分量。
[演示]

　　从节点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已经出栈，(4,6)是横叉边，返回3，(3,4)为树枝边，所以LOW[3]=LOW[4]=1。





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





　　算法结束。求出了图中全部的三个强连通分量{1,3,4,2},{5},{6}。

　　可以发现，运行Tarjan算法的过程中，每个顶点都被访问了一次，且只进出了一次堆栈，每条边也只被访问了一次，所以该算法的时间复杂度为O(N+M)。

[拓展]

　　有时对求出的强连通分量需要做缩点操作，即将所有分量缩成一个点，常用的是使用出入读。当然有时也得用缩点构建图。

[模板]

/*==================================================*\
| Tarjan强连通分量
| INIT: vec[]为邻接表; stop, cnt, scnt,inStack置0; id[],pre[]置-1;
| CALL: for(i=0; i<n; ++i) if(-1==dfn[i]) tarjan(i);
|
| vec[] :邻接表
| id[]  :属于哪个分量,对应范围:0~cnt-1
| dfn[m]:记录m的是第几次访问，同时如果dfn[m]==-1则表明m未访问
| vec[] :为邻接表
| s[]   :栈
| stop  :栈顶指针
| scnt  :强连通分量的个数
| cnt_scnt[] :强连通分量元素个数
| cnt   :访问计数
| void tarjan(int v) :v为当前访问节点
\*==================================================*/
const int V=10010;
vector<int> vec[V];
int n;
int id[V],dfn[V],s[V],low[V],stop=0,cnt=0,scnt=0,cnt_scnt[V];
bool inStack[V];
void tarjan(int v)
{
int t;
low[v]=dfn[v]=cnt++;
s[stop++]=v;
inStack[v]=1;
vector<int>::iterator pv;
for(pv=vec[v].begin();pv!=vec[v].end();++pv)
{
if(-1==dfn[*pv])    //未访问过
{
tarjan(*pv);
low[v]=min(low[v],low[*pv]);
}
else if(inStack[*pv])    //在栈中
low[v]=min(low[v],low[*pv]);
}
if(dfn[v]==low[v])  //找到分量
{
do{
t=s[--stop];
id[t]=scnt;
inStack[t]=false;
cnt_scnt[scnt]++;
}while(t!=v);
++scnt;
}
}

[例子]

　　题目:高速公路

　　问题描述
　　　　某国有n个城市，为了使得城市间的交通更便利，该国国王打算在城市之间修一些高速公路，由于经费限制，国王打算第一阶段先在部分城市之间修一些单向的高速公路。
　　　　现在，大臣们帮国王拟了一个修高速公路的计划。看了计划后，国王发现，有些城市之间可以通过高速公路直接（不经过其他城市）或间接（经过一个或多个其他城市）到达，而有的却不能。如果城市A可以通过高速公路到达城市B，而且城市B也可以通过高速公路到达城市A，则这两个城市被称为便利城市对。
　　　　国王想知道，在大臣们给他的计划中，有多少个便利城市对。
　　输入格式
　　　　输入的第一行包含两个整数n, m，分别表示城市和单向高速公路的数量。
　　　　接下来m行，每行两个整数a, b，表示城市a有一条单向的高速公路连向城市b。
　　输出格式
　　　　输出一行，包含一个整数，表示便利城市对的数量。

#include<iostream>
#include<cstring>
#include<vector>
#include<iterator>
using namespace std;
const int V=10010;
vector<int> vec[V];
int n;
int id[V],dfn[V],s[V],low[V],stop=0,cnt=0,scnt=0,cnt_scnt[V];
bool inStack[V];
void tarjan(int v)
{
int t;
low[v]=dfn[v]=cnt++;
s[stop++]=v;
inStack[v]=1;
vector<int>::iterator pv;
for(pv=vec[v].begin();pv!=vec[v].end();++pv)
{
if(-1==dfn[*pv])
{
tarjan(*pv);
low[v]=min(low[v],low[*pv]);
}
else if(inStack[*pv])
low[v]=min(low[v],low[*pv]);
}
if(dfn[v]==low[v])  //找到分量
{
do{
t=s[--stop];
id[t]=scnt;
inStack[t]=false;
cnt_scnt[scnt]++;
}while(t!=v);
++scnt;
}
}
int main()
{
int m;
cin>>n>>m;
int a,b;
memset(inStack,false,sizeof(inStack));
memset(dfn,-1,sizeof(dfn));
memset(id,-1,sizeof(id));
memset(cnt_scnt,0,sizeof(cnt_scnt));
stop=cnt=scnt=0;
for(int i=0;i<m;i++)
{
cin>>a>>b;
vec[a-1].push_back(b-1);
}
for(int i=0;i<n;i++)
{
if(-1==dfn[i])
tarjan(i);
}
int ans=0;
for(int i=0;i<scnt;i++)
{
ans+=((cnt_scnt[i]-1)*cnt_scnt[i])/2;
}
cout<<ans;
}