hdu 2767 Proving Equivalences（强连通分量+缩点）

题意：给一个n个点，m条边的图，问最少增加多少条边，原图可以变成强连通图。

思路：分两步，第一步，求双连通分量，我使用的是tarjan算法。我尝试着解释一下：对于一个强连通图G，从它的a点出发遍历全图，最终遍历的终点也是a，实际上在便利过程中可以出现多次回溯操作，即存在多个终点，但是因为在每次更新low[u]的值时都取最小的，所以最后更新的最小值一定时low[a]。

第二步：缩点得到一个有向无环图，统计所有点的入度和出度，取入度为0的节点数和出度为0的节点数其中的较大值。

#include<stdio.h>
#include<string.h>
#define N 100005
#define M 100005
int head[N],path[M],next[M],vis[N],stack[N];
int dfn[N],low[N],belong[N];
int in[N],out[N];
int no,cnt;
int n,m;
int stack_head,stack_tail;
int type;
int min(int x,int y)
{
    return x<y?x:y;
}
void addEdge(int x,int y)
{
    path[no]=y,next[no]=head[x],head[x]=no++;
    return ;
}
void tarjan(int u)
{
    vis[u]=1;
    dfn[u]=low[u]=++cnt;
    stack[stack_tail++]=u;
    for(int i=head[u];i!=-1;i=next[i])
    {
        int v=path[i];
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        } else if(vis[v])
            low[u]=min(low[u],dfn[v]);
    }
    if(dfn[u]==low[u])
    {
        type++;
        do{
            stack_tail--;
            vis[stack[stack_tail]]=0;
            belong[stack[stack_tail]]=type;
        }while(stack[stack_tail]!=u);
    }
    return ;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        memset(head,-1,sizeof(head));
        memset(next,-1,sizeof(next));
        cnt=0;
        no=0;
        for(int i=1;i<=m;i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            addEdge(x,y);
        }
        memset(vis,0,sizeof(vis));
        memset(dfn,0,sizeof(dfn));
        memset(low,0,sizeof(low));
        stack_head=stack_tail=0;
        memset(stack,0,sizeof(stack));
        type=0;
        for(int i=1;i<=n;i++)
        {
            if(!dfn[i]) tarjan(i);
        }
        if(type==1)
        {
            printf("0\n");
            continue;
        }
        memset(in,0,sizeof(in));
        memset(out,0,sizeof(out));
        for(int i=1;i<=n;i++)
        {
            for(int j=head[i];j!=-1;j=next[j])
            {
                int v=path[j];
                if(belong[v]!=belong[i])
                {
                    out[belong[i]]++;
                    in[belong[v]]++;
                }
            }
        }
        int count_in,count_out;
        count_in=count_out=0;
        for(int i=1;i<=type;i++)
        {
            if(out[i]==0) count_out++;
            if(in[i]==0) count_in++;
        }
        printf("%d\n",count_in>count_out?count_in:count_out);
    }
    return 0;
}