有向图的强连通分量

 一个图，经过深度优先遍历，成为一颗深度优先搜索树。将树的边分为四类。为什么要分为四类呢？我也不明白，就是tarjan老爷子为了解释算法吧。总之分为上述图片给的四类边之后，就可以找出来哪几类边容易构成环。对于有向图而言，强连通分两就是找里面的环。

如上所述，返祖边与树边一定构成环，横插边可能与树边构成环。横插去的那个点不一定能回到自身，所以也就不一定构成环。如上图所示。

tarjan算法最重要的就是这两个数组，时间戳数组与追溯值数组。时间戳表示结点第一次被访问的顺序，也就是可以看成深度优先遍历的结点编号。追溯值看作极大连通分量子图的代表点，就是从该点出发可以走到的最早被访问到的点。其实这两种说法都不是很准确。姑且如此认为，主要是为了与后面的代码一致。

直接上例题。

代码如下：

#include<iostream>
#include<cstring>

using namespace std;

const int N=10010,M=50010;
int h[N],e[M],ne[M],idx;
int dfn[N],low[N],timestrap;
int stk[N],top;
bool in_stk[N];
int id[N],scc_cnt,s[N];
int dout[N];
int n,m;

void add(int a,int b)
{
  e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

void tarjan(int u)
{
    dfn[u]=low[u]=++timestrap;
    stk[++top]=u,in_stk[u]=true;
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(!dfn[j])
        {
            tarjan(j);
            low[u]=min(low[u],low[j]);
        }
        else if(in_stk[j]) low[u]=min(low[u],dfn[j]);
    }
    
    if(dfn[u]==low[u])
    {
        ++scc_cnt;
        int y;
        do{
            y=stk[top--];
            in_stk[y]=false;
            id[y]=scc_cnt;
            s[scc_cnt]++;
        }while(y!=u);
    }
}

int main()
{
    cin>>n>>m;
    memset(h,-1,sizeof h);
    
    while(m--)
    {
        int a,b;
        cin>>a>>b;
        add(a,b);
    }
    
    for(int i=1;i<=n;i++)
     if(!dfn[i])    //因为可能图不是连通图
     {
         tarjan(i);
     }
     
     for(int i=1;i<=n;i++)
        for(int j=h[i];~j;j=ne[j])
        {
            int k=e[j];
            int a=id[i],b=id[k];   //两个点不在同一个极大连通子图，出度加1
            if(a!=b) dout[a]++;
        }
        
        int zero=0,sum=0;
        
        for(int i=1;i<=scc_cnt;i++)
         if(!dout[i])
         {
             zero++;
             sum+=s[i];
             if(zero>1)  //如果”终点“不唯一，那么答案一定为0
             {
                 sum=0;
                 break;
             }
         }
         
         cout<<sum<<endl;
         return 0;
}

 求极大连通子图的目的就是为了缩点，一个极大连通子图可以用有向图中的一个点来表示。其实就是求出终点（可能是缩点之后，出度为0的点）的“大小”。当然不可能有多个终点，这样的话一定有牛没有被其他牛崇拜。也就是求出只能有一个“终点“（缩点）的大小。这就是tarjan算法该上场了。

下面是核心代码：

void tarjan(int u)
{
    dfn[u]=low[u]=++timestrap;
    stk[++top]=u,in_stk[u]=true;
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(!dfn[j])
        {
            tarjan(j);
            low[u]=min(low[u],low[j]);
        }
        else if(in_stk[j]) low[u]=min(low[u],dfn[j]);
    }
    
    if(dfn[u]==low[u])
    {
        ++scc_cnt;
        int y;
        do{
            y=stk[top--];
            in_stk[y]=false;
            id[y]=scc_cnt;
            s[scc_cnt]++;
        }while(y!=u);
    }
}

首先我们进入一个点，这个点的时间戳和追溯值先初始化。然后将这个点放入栈中，并表示这个点在栈中。然后搜索领点，如果领点还没有搜索过，那么就递归进入，然后等到回溯的时候用领点的追溯值更新自己的追溯值（因为领点可以达到的点自己也已i的那个可以达到）。第二种情况就是领点已经被搜索过了，也就是说已经在栈中，这个时候也可以更新自己的追溯值，其实代码应该用low[j]来更新自己，但是为了代码的协调，这里就是dfn[j]来更新自己。第三种情况就是点不在栈中且已经被访问过了，那么就不需要处理。

这里第二个为何判断条件是in_stk呢，因为else if已经说明dfn是成立的了，这个时候就看另一个条件。然后就是在栈中的时候才需要处理。

下面的代码就是你在搜索的过程中如果一个点的领点都搜索完了，且这个点的追溯值和时间戳相等，那么这个点就是极大连通子图的代表点了。然后就是极大连通子图的数量加一，通知这个极大连通子图的点都出栈且标号，因为这个点是代表点，所以这个点在栈的最下面，所以循环走到这个点的时候结束，到这个点之前的其他点都是这个极大连通子图的点，这些点也需要标号，标志他们属于哪个点。

以上就是tarjan算法的过程，主要是为了缩点。

上第二道题。

这个题目翻译一下就是一个有向图，哪几个点可以达到其他所有点（第一问），加几条边可以让这个图变为一个强连通图，两两可达（第二问） 。

想象一下缩点之后的图，第一问很简单，就是问有多少个入度为0的点。第二个就比较困难，是在入读为0的点的数量与出度为0的点的数量之间取最大值。

代码如下:

#include<iostream>
#include<cstring>

using namespace std;
int n;
const int N=110,M=10010;

int h[N],e[M],ne[M],idx;
int dfn[N],low[N],timestramp;
int stk[N],top;
bool in_stk[N];
int id[N],scc_cnt;
int din[N],dout[N];

void add(int a,int b)
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

void tarjan(int u)
{
    dfn[u]=low[u]=++timestramp;
    stk[++top]=u,in_stk[u]=true;
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int j=e[i];
        if(!dfn[j])
        {
            tarjan(j);
            low[u]=min(low[u],low[j]);
        }else if(in_stk[j]) low[u]=min(low[u],dfn[j]);
    }
    if(dfn[u]==low[u])
    {
        ++scc_cnt;
        int y;
        do{
            y=stk[top--];
            in_stk[y]=false;
            id[y]=scc_cnt;
        }while(y!=u);
    }
}

int main()
{
    cin>>n;
    memset(h,-1,sizeof h);
    for(int i=1;i<=n;i++)
    {
        int t;
        while(cin>>t,t) add(i,t);
    }
    
    for(int i=1;i<=n;i++) 
    if(!dfn[i]) tarjan(i);
    
    for(int i=1;i<=n;i++)
      for(int j=h[i];j!=-1;j=ne[j])
      {
          int k=e[j];
          int a=id[i],b=id[k];
          if(a!=b)
          {
              dout[a]++;
              din[b]++;
          }
      }
      
      int a=0,b=0;
      
      for(int i=1;i<=scc_cnt;i++)
      {
          if(!din[i]) a++;
          if(!dout[i]) b++;
      }
      cout<<a<<endl;
      if(scc_cnt==1) cout<<0<<endl;
      else cout<<max(a,b);
}

这题目缩点之后的出度和入度都统计了，而上面的只统计了出度，看题目需求。第一问很好理解，你入度为0的点就类似有向图中的起点，是肯定可以达到其他点。但是第二个不太好证明。我们假设入读为0的点有p个，出度为0的点有q个。有两种情况p>=q和p<=q。

情况二，假设”起点“数量小于”终点“，首先如果p=1，那么只要加q条边，就是讲q个终点往唯一的终点上加一条边，这样这个图就是两两可达的了。若p不等于1，那么一定可以说pi和qi是可以两两配对的。假如互异的pi不到达互异的qi，那么p的数量一定多于等于q。与条件矛盾。因此经过两两配对之后，q指向配对的点p,直到点P还剩下一个。就又是原来的条件了。（说的有点糊，还是看下图。）