强连通分量(Tarjan)模板

贴模板，备忘。

模板1:

 #include<iostream>
 #include<cstring>
 #include<cmath>
 #include<cstdlib>
 #include<cstdio>
 #include<algorithm>
 #include<string.h>
 using namespace std;
 struct node {
     int v,next;
 }edge[];
 int DFN[],LOW[];
 int stack[],heads[],visit[],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]=;//表示在栈里
      for(int i=heads[x];i!=-;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]]=;
              index--;
          }while(x!=stack[index+]);//出栈，并且输出。
          printf("\n");
      }
      return ;
 }
 int main()
 {
      memset(heads,-,sizeof(heads));
      int n,m;
      scanf("%d%d",&n,&m);
      int x,y;
      for(int i=;i<=m;i++)
      {
          scanf("%d%d",&x,&y);
         add(x,y);
      }
      for(int i=;i<=n;i++)
          if(!DFN[i])  tarjan(i);//当这个点没有访问过，就从此点开始。防止图没走完
      return ;
 }

模板2:

 #include<iostream>
 #include<algorithm>
 #include<cstring>
 #include<queue>
 #include<stack>
 #define maxn 1005
 using namespace std;
 struct Edge
 {
     int next;
     int to;
 }edge[maxn];
 int head[maxn];
 int cnt;
 int step;
 int dfn[maxn];//表示深搜的步数；
 int low[maxn];//表示能追溯到最早的栈中节点的次序；
 int sccno[maxn];//缩点数组，表示每个点对应的缩点值；
 int scc_cnt;//强连通分量的个数；
 void init()
 {
     cnt=;
     step=;
     memset(head,-,sizeof(head));
 }
 void add(int u,int v)
 {
     edge[cnt].next=head[u];
     edge[cnt].to=v;
     head[u]=cnt++;
 }
 vector<int>scc[maxn];//得出来的缩点，保存具体缩了那些点；
 stack<int>s;
 void dfs(int u)
 {
     dfn[u]=low[u]=++step;
     s.push(u);
     for(int i=head[u];i!=-;i=edge[i].next)
     {
         int v=edge[i].to;
         if(!dfn[v])
         {
             dfs(v);
             low[u]=min(low[u],low[v]);
         }
         else if(!sccno[v])
         {
             low[u]=min(low[u],dfn[v]);
         }
     }
     if(low[u]==dfn[u])
     {
         scc_cnt++;
         scc[scc_cnt].clear();
         while()
         {
             int x=s.top();
             s.pop();
             if(sccno[x]!=scc_cnt)
                 scc[scc_cnt].push_back(x);
             sccno[x]=scc_cnt;
             if(x==u)
                 break;
         }
     }
 }
 void tarjan(int n)
 {
     memset(sccno,,sizeof(sccno));
     memset(dfn,,sizeof(dfn));
     step=scc_cnt=;
     for(int i=;i<=n;i++)
         if(!dfn[i])dfs(i);
 }
 int main()
 {
     int n,m;
     int x,y;
     cin>>n>>m;
     init();
     while(m--)
     {
         cin>>x>>y;
         add(x,y);
     }
     tarjan(n);
     cout<<scc_cnt<<endl;
     return ;
 }

滚了。