题目地址：HDU 2767

这题的意思是求再加多少边可以使得图为强连通图。

方法是先缩点，缩点很简单，只要加个数组，在找到一个强连通分量的时候让那些点都标记为该强连通分量的标号即可。

然后再遍历一遍所有边，如果该边的起点和终点不在同一个强连通分量里边，那这两个点的入度和出度就可以算作是该强连通分量的入度和出度的一部分，累加上去。最后分别统计入度和出度为0的强连通分量个数，取最大值就是答案。道理很显然，要成为一个强连通分量的话，任意两个点之间都要连接，那就至少入度为1，出度为1.每增加一个入度相当于增加了另一个出度。所以只要增加最大值个边数即可。

代码如下：

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <queue>
#include <map>
#include <set>
#include <algorithm>

using namespace std;
int head[21000], cnt, stak[21000], index, top, ans, cntin, cntout;
int dfn[21000], instack[21000], belong[21000], low[21000];
int in[21000], out[21000];
struct node
{
    int u, v, next;
}edge[60000];
void add(int u, int v)
{
    edge[cnt].v=v;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}
void tarjan(int u)
{
    dfn[u]=low[u]=++index;
    stak[++top]=u;
    instack[u]=1;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(instack[v])
            low[u]=min(low[u],dfn[v]);
    }
    if(dfn[u]==low[u])
    {
        ans++;
        while(1)
        {
            int v=stak[top--];
            instack[v]=0;
            belong[v]=ans;
            if(u==v) break;
        }
    }
}
void init()
{
    memset(head,-1,sizeof(head));
    cnt=0;
    memset(dfn,0,sizeof(dfn));
    memset(instack,0,sizeof(instack));
    index=top=ans=0;
    memset(in,0,sizeof(in));
    memset(out,0,sizeof(out));
    cntin=cntout=0;
}
int main()
{
    int t, n, m, u, v, i, j;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        init();
        while(m--)
        {
            scanf("%d%d",&u,&v);
            add(u,v);
        }
        for(i=1;i<=n;i++)
        {
            if(!dfn[i])
                tarjan(i);
        }
        if(ans==1)
        {
            printf("0\n");
            continue ;
        }
        for(i=1;i<=n;i++)
        {
            for(j=head[i];j!=-1;j=edge[j].next)
            {
                int v=edge[j].v;
                if(belong[v]!=belong[i])
                {
                    in[belong[v]]++;
                    out[belong[i]]++;
                }
            }
        }
        for(i=1;i<=ans;i++)
        {
            if(!in[i])
                cntin++;
            if(!out[i])
                cntout++;
        }
        printf("%d\n",max(cntin,cntout));
    }
    return 0;
}

HDU 2767 Proving Equivalences(强连通分量）