HDU - 4635 Strongly connected 强连通

题意：

给一个n个点的简单有向图，问最多能加多少条边使得该图仍然是简单有向图，且不是强连通图。

简单有向图定义：没有重边，无自环。

强连通图：整个图缩点后就只有一个点，里面包含n个原点，也就是一个连通分量。

如果一开始就是一个强连通图，则输出-1。

分析：

要加边最多那么加边后的图连通分量越少越好，那么连通分量最少也就是2个。先用n个点构造一个完全图（有向图有：n*(n-1)条

边，无向图有：n*(n-1)/2条边），再用构造的边 减去原来有的m条边=ans。再用强连通算法缩点，记录每个新点包含点的个数，从

入度为0或出度为0的新点中找出包含点数最小的minnum，再用上面剩余的边ans - minnum*(n-minnum)就是所要的答案。因为如果

不减入度为0或出度为0相关的边，那么该点本身包含有入边和出边，加的边永远都是强连通图。所以只能去掉与入度为0或出度为0

点的相关边，只减掉一个方向的边，要么全是（n-minnum）点数到minnum点数的入边，那么是minnum点数到(n-minnum)点数的

出边。

#include<cstring>
#include<cstdio>
#include<queue>
#include<vector>

using namespace std;

const int maxn=1e5+10;
const int maxm=1e5+10;

struct node{
    int to,next;
}edge[maxm];

int head[maxn],tot;

int low[maxn],dfn[maxn],sta[maxn],belong[maxn];
int index,top;
int scc;            //强连通分量的个数。
bool instack[maxn];
int num[maxn];          //各个强连通分量所包含的点数。

void addedge(int u,int v){
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}

void tarjan(int u){
    int v;
    low[u]=dfn[u]=++index;
    sta[top++]=u;
    instack[u]=true;
    for(int i=head[u];i!=-1;i=edge[i].next){
        v=edge[i].to;
        if(!dfn[v]){
            tarjan(v);
            if(low[u]>low[v]) low[u]=low[v];
        }else if(instack[v]&&low[u]>dfn[v]){
            low[u]=dfn[v];
        }

    }
    if(low[u]==dfn[u]){
        scc++;
        do{
            v=sta[--top];
            instack[v]=false;
            belong[v]=scc;
            num[scc]++;
        }while(v!=u);
    }
}

int in[maxn],out[maxn];

void init(){
    scc=top=tot=index=0;
    memset(head,-1,sizeof head);
    memset(dfn,0,sizeof dfn);
    memset(instack,0,sizeof instack);
    memset(num,0,sizeof num);
    memset(in,0,sizeof in);
    memset(out,0,sizeof out);
}

typedef long long ll;

int main(){
    int T;
    scanf("%d",&T);
    for(int cs=1;cs<=T;cs++){
        int n,m;
        init();
        scanf("%d%d",&n,&m);
        for(int i=0;i<m;i++){
            int u,v;
            scanf("%d%d",&u,&v);
            addedge(u,v);
        }
        ll ans=(ll)n*(ll)(n-1);
        ans-=m;
//        printf("%d\n",ans);
        for(int i=1;i<=n;i++){
            if(!dfn[i]) tarjan(i);
        }
        if(scc!=1){
            for(int u=1;u<=n;u++){
                for(int i=head[u];i!=-1;i=edge[i].next){
                    int v=edge[i].to;
                    if(belong[u]!=belong[v])
                        out[belong[u]]++,in[belong[v]]++;
                }
            }
            int tmp=maxn;
            for(int i=1;i<=scc;i++){
                if(!in[i]||!out[i]){
//                    printf("--%d\n",num[i]);
                    tmp=min(tmp,num[i]);
                }
            }
//            printf("%d\n",tmp);
            printf("Case %d: %lld\n",cs,ans-(ll)tmp*(ll)(n-tmp));
        }else printf("Case %d: -1\n",cs);

    }
    return 0;
}
/*
3
6 6
1 2
2 3
3 1
4 5
5 6
6 4
*/