笔记：Tarjan算法 求解有向图强连通分量的线性时间的算法

void Tarjan(int u)  //此代码仅供参考
{
    vis[u]=1;
    low[u]=dfn[u]=cnt++;
    stack[++tt]=u;
    for(int i=0;i<mp[u].size();i++)
    {
        int v=mp[u][i];
        if(vis[v]==0)Tarjan(v);
        if(vis[v]==1)low[u]=min(low[u],low[v]);
    }
    if(dfn[u]==low[u])
    {
        sig++;
        do
        {
            low[stack[tt]]=sig;
            color[stack[tt]]=sig;
            vis[stack[tt]]=-1;
        }
        while(stack[tt--]!=u);
    }
}

//注意，v指的是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])
　　　　else if (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)
}

void Tarjan ( int x )
 {
  dfn[ x ] = ++dfs_num ;
  low[ x ] = dfs_num ;
  vis [ x ] = true ; //是否在栈中
  stack [ ++top ] = x ;
  for ( int i=head[ x ] ; i!=0 ; i=e[i].next )
      {
          int temp = e[ i ].to ;
          if ( !dfn[ temp ] )
           {
             Tarjan ( temp ) ;
              low[ x ] = gmin ( low[ x ] , low[ temp ] ) ;
           }
            else if ( vis[ temp ])low[ x ] = gmin ( low[ x ] , dfn[ temp ] ) ;
      }
      if ( dfn[ x ]==low[ x ] )            //构成强连通分量
      {
            vis[ x ] = false ;
             color[ x ] = ++col_num ;    //染色
             while ( stack[ top ] != x )  //清空
             {
              color [stack[ top ]] = col_num ;
             vis [ stack[ top-- ] ] = false ;
             }
                 top -- ;
       }
}

#define M 5010       //题目中可能的最大点数
int STACK[M],top=0;  //Tarjan算法中的栈
bool InStack[M]; //检查是否在栈中
int DFN[M];    //深度优先搜索访问次序
 
int Low[M];  //能追溯到的最早的次序
int ComponentNumber=0;  //有向图强连通分量个数
int Index=0;  //索引号
vector<int> Edge[M];  //邻接表表示
vector<int> Component[M];  //获得强连通分量结果
int InComponent[M];  //记录每个点在第几号强连通分量里
int ComponentDegree[M]; //记录每个强连通分量的度
 
void Tarjan(int i)
{
    int j;
    DFN[i]=Low[i]=Index++;
    InStack[i]=true;STACK[++top]=i;
    for (int e=0;e<Edge[i].size();e++)
    {
        j=Edge[i][e];
        if (DFN[j]==-1)
        {
            Tarjan(j);
            Low[i]=min(Low[i],Low[j]);
        }
        else
            if (InStack[j]) Low[i]=min(Low[i],DFN[j]);
    }
    if (DFN[i]==Low[i])
    {
        ComponentNumber++;
        do{
            j=STACK[top--];
            InStack[j]=false;
            Component[ComponentNumber].
            push_back(j);
            InComponent[j]=ComponentNumber;
        }
        while (j!=i);
    }
}

#include<cstdio>
 #include<algorithm>
 #include<string.h>
 using namespace std;
 struct node
{
     int v,next;
 }edge[1001];
 int DFN[1001],LOW[1001];
 int stack[1001],heads[1001],visit[1001],cnt,tot,index;
void add(int x,int y)
{
     edge[++cnt].next=heads[x];
     edge[cnt].v = y;
     heads[x]=cnt;
    return ;
 }
 void tarjan(int x)  //代表第几个点在处理。递归的是点。
 {
     DFN[x]=LOW[x]=++tot; //新进点的初始化。
     stack[++index]=x; //进栈
     visit[x]=1;  //表示在栈里
    for(int i=heads[x];i!=-1;i=edge[i].next)
     {
         if(!DFN[edge[i].v]) //如果没访问过
{   
            tarjan(edge[i].v);  //往下进行延伸，开始递归
             LOW[x]=min(LOW[x],LOW[edge[i].v]);//递归出来，比较谁是谁的儿子／父亲，就是树的对应关系，涉及到强连通分量子树最小根的事情。
           }
        else if(visit[edge[i].v ])//如果访问过，并且还在栈里
{  
             LOW[x]=min(LOW[x],DFN[edge[i].v]);//比较谁是谁的儿子／父亲。就是链接对应关系
          }
     }
     if(LOW[x]==DFN[x]) //发现是整个强连通分量子树里的最小根。
    {
         do{
            printf("%d ",stack[index]);
             visit[stack[index]]=0;
             index--;
         }while(x!=stack[index+1]);//出栈，并且输出。
         printf("\n");
     }
     return ;
 }
 int main()
 {
     memset(heads,-1,sizeof(heads));
     int n,m;
     scanf("%d%d",&n,&m);
    int x,y;
     for(int i=1;i<=m;i++)
     {
         scanf("%d%d",&x,&y);
        add(x,y);
     }
    for(int i=1;i<=n;i++)
         if(!DFN[i])  tarjan(i);//当这个点没有访问过，就从此点开始。防止图没走完
    return 0;
 }