Strongly connected 挺简单的tarjan

题意：给你一个连通图，问你最多加多少条边，还能保证该图不是强连通图。

对整个图求强连通分量，然后对图缩点，记录一下缩点之后每隔点包含的原来的点的个数，找出最少的那个点，然后对这个点建成完全图，对另外的所有点建成完全图。然后+两个点建边-所有原来的遍就好了。

链接：http://acm.hdu.edu.cn/showproblem.php?pid=4635

 #include <iostream>
 #include <vector>
 #include <queue>
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <stack>

 using namespace std;
 const int maxn = ;

 struct edge
 {
     int u,v,val;
 };
 int dfn[],low[],belong[],inst[];
 int pnum[];
 int in[];
 int inside[];
 int out[];
 vector<edge> edges,es;
 vector<int>g[maxn];
 vector<int>ng[maxn];
 stack<int>st;
 int bcnt,cnt,dfsclock;
 int max(int a,int b)
 {
     if(a > b)
     return a;

     return b;
 }
 void init(int n)
 {
     int i;
     for(i =;i <= n;i++)
     g[i].clear();

     edges.clear();

     es.clear();
     dfsclock = ;bcnt = cnt = ;
     return ;
 }
 void addedge(int u,int v,int val)
 {
     edges.push_back((edge){u,v,});
     g[u].push_back(cnt);
     cnt++;

     return ;
 }
 void tarjan(int i)
 {
     int j;
     dfn[i] = low[i] = ++dfsclock;
     inst[i] = ;
     st.push(i);

     for(j = ;j < g[i].size();j++)
     {
         edge e;
         e = edges[g[i][j]];
         int v;
         v = e.v;
         if(!dfn[v])
         {
             tarjan(v);
             low[i] = min(low[i],low[v]);
         }
         else if(inst[v] && dfn[v] < low[i])
         low[i] = dfn[v];
     }
     if(dfn[i] == low[i])
     {
         bcnt++;
         do
         {
             j = st.top();
             st.pop();
             inst[j] = ;
             belong[j] = bcnt;

         }
         while(j != i);
     }

 }
 void tarjans(int n)
 {
     int i;
     bcnt = dfsclock = ;
     while(!st.empty())st.pop();
     memset(dfn,,sizeof(dfn));

     memset(inst,,sizeof(inst));
     memset(belong,,sizeof(belong));
     for(i = ;i <= n;i++)
     if(!dfn[i])tarjan(i);
 }
 int main()
 {
     int n,m;
     int t;

     scanf("%d",&t);
     int cas = ;
     while(t--)
     {
         scanf("%d %d",&n,&m);
         int a,b,i;
         init(n);
         for(i = ;i < m;i++)
         {
             scanf("%d %d",&a,&b);
             addedge(a,b,);
             struct edge x;
             x.u = a;
             x.v = b;
             x.val = ;
             es.push_back(x);

         }
         tarjans(n);

         printf("Case %d: ",++cas);
         if(bcnt == )
         {
             puts("-1");
             continue;
         }
         int pnum[];
         int in[];
         int out[];
         memset(pnum,,sizeof(pnum));
         memset(in,,sizeof(in));
         memset(out,,sizeof(in));
         memset(inside,,sizeof(inside));
         for(i = ;i <= n;i++)
         {
             pnum[belong[i]]++;
         }

         for(i = ;i < m;i++)
         {
             int u,v;
             u = es[i].u;
             v = es[i].v;
             if(belong[u] != belong[v])
             {
                 out[belong[u]]++;
                 in[belong[v]]++;
             }
         }
         __int64 ans;
         ans = n;

         for(i = ;i <= bcnt;i++)
         {
             if(in[i] ==  || out[i] == )
             {
                 if(ans > pnum[i])
                 ans = pnum[i];
             }
         }

         ans = (__int64)(n-ans)* (__int64)(n-ans-)+ (__int64)ans* (__int64)(ans-)+ (__int64)ans*(__int64)(n-ans)- (__int64)(m);
        // printf("bcnt %d p %d  ams %d ansi %d\n",bcnt,pnum[ansi],ans,ansi);

         printf("%I64d\n",ans);

     }
     return ;
 }