HDU 4635 Strongly connected ——（强连通分量）

　　好久没写tarjan了，写起来有点手生，还好1A了- -。

　　题意：给定一个有向图，问最多添加多少条边，让它依然不是强连通图。

　　分析：不妨考虑最大时候的临界状态（即再添加一条边就是强连通图的状态），假设这时候的边的数量是F，那么答案就是F-m（m是一开始边的数量）。因此，F越大，答案越大。那么，怎么考虑F的值呢？最后的状态一定是这样的：整个图不是强连通的，但是他的两个分部x和y都是强连通的，并且其中任意一个分量（不妨设其为x），到另外一个分量（y），x中的每一个点到y中的每一个点都有边，而且，y中的每一个点到x中的每一个点都没有边；另外，x和y内部任意两点间都是有边的。这样的话任意添加一条边都会使得原图变成一个强连通图（因为再添加边只能是y中一点到x一点，这样整个图中任意两点间都可达了）。那么我们不妨设x中点的个数为a，y中点的个数为b=n-a（共有n个点），因此F=a*（a-1）+b*（b-1）+a*b（x到y的边）。这样，ans=F-m，化简得到ans=n*n-a*b-n-m。对a和b进行基本不等式可知，他们相等时乘积最大，因此他们相差最大时ans最大（也可以直接枚举任意两个强连通分量来得到答案）。另外要注意的一点是，x和y必须一个有任意一个是入度或者出度为0的，这样的话，才能使得他们构造成为F的状态。还想提的一点是，一个点也能成为强连通分量。

　　具体见代码：

 #include <stdio.h>
 #include <algorithm>
 #include <string.h>
 #include <vector>
 #include <map>
 #include <set>
 #include <queue>
 #include <iostream>
 #include <stdlib.h>
 #include <string>
 #include <stack>
 using namespace std;
 const int inf = 0x3f3f3f3f;
 typedef long long ll;
 typedef pair<int,int> pii;
 const int N =  + ;

 int n,m,dfs_clock,dfn[N],low[N];
 int belong[N],scc_cnt,cnt[N],in[N],out[N];
 stack<int> S;
 vector<int> G[N];

 void init()
 {
     for(int i=;i<=n;i++) G[i].clear();
     dfs_clock = ;
     memset(dfn,,sizeof(dfn));
     memset(belong,,sizeof(belong));
     scc_cnt = ;
     memset(cnt,,sizeof(cnt));
     memset(in,,sizeof(in));
     memset(out,,sizeof(out));
 }

 void tarjan(int u)
 {
     dfn[u]=low[u]=++dfs_clock;
     S.push(u);
     for(int i=;i<G[u].size();i++)
     {
         int v = G[u][i];
         if(!dfn[v])
         {
             tarjan(v);
             low[u]=min(low[u],low[v]);
         }
         else if(!belong[v])
         {
             low[u]=min(low[u],dfn[v]);
         }
     }
     if(low[u]==dfn[u])
     {
         scc_cnt++;
         int num = ;
         for(;;)
         {
             num ++;
             int x = S.top();S.pop();
             belong[x] = scc_cnt;
             if(x==u) break;
         }
         cnt[scc_cnt] = num;
     }
 }

 void solve()
 {
     for(int i=;i<=n;i++)
     {
         if(!dfn[i]) tarjan(i);
     }

     for(int i=;i<=n;i++)
     {
         int x = belong[i];
         for(int j=;j<G[i].size();j++)
         {
             int v = G[i][j];
             if(belong[i] == belong[v]) continue;

             int y = belong[v];
             out[x]++;
             in[y]++;
         }
     }

     ll ans = ;
     for(int i=;i<=scc_cnt;i++)
     {
         if(in[i] && out[i]) continue;

         int a = cnt[i];
         int b = n-a;
         ans = max(ans,(ll)n*n-(ll)a*b-n-m);
     }
     if(scc_cnt == ) ans = -;
     cout << ans << endl;
 }

 int main()
 {
     int T;
     scanf("%d",&T);
     for(int kase=;kase<=T;kase++)
     {
         init();
         printf("Case %d: ",kase);
         scanf("%d%d",&n,&m);
         for(int i=;i<=m;i++)
         {
             int u,v;
             scanf("%d%d",&u,&v);
             G[u].push_back(v);
         }
         solve();
     }
 }