HDU 4635

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

问：最多加多少条边，使得原图不是强连通图

正向考虑有困难，不妨反向思考，既最少去掉几条边使得原图不是强连通。

总边数sum=n*(n-1)时肯定是强连通，已经给了m条边，sum-=m

这时把已经强连通的部分进行缩点，对于缩好的点我们把他们分成两部分，保证其中一部分到另一部分没有边（这两部分不强连通），再把sum减去两部分能构成所有的边数，取最大值即为答案

具体做时枚举每个小强连通块，找到num[i]*(n-num[i])最小的情况（num[i]为小强连通块点数），其中必须出度或入度为0的连通块才可以被选择

#include <iostream>

#include <algorithm>

#include <cstring>

#include <cstdio>

#include <queue>

#include <map>

using namespace std ;

const int INF=0xfffffff ;

struct node 

{

    int s,t,nxt ;

}e[4000005] ;

int n,m,idx,ans,tp,cnt,num[100005],IN[100005],OUT[100005],dfn[100005],vis[100005],low[100005],head[100005],st[100005],belong[100005] ;

void add(int s,int t)

{

    e[cnt].s=s ;

    e[cnt].t=t ;

    e[cnt].nxt=head[s] ;

    head[s]=cnt++ ;

}

void tarjan(int u)

{

    dfn[u]=low[u]=++idx ;

    vis[u]=1 ;

    st[++tp]=u ;

    int v ;

    for(int i=head[u] ;i!=-1 ;i=e[i].nxt)

    {

        v=e[i].t ;

        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])

    {

        ans++ ;

        while(1)

        {

            v=st[tp--] ;

            vis[v]=0 ;

            belong[v]=ans ;

            num[ans]++ ;

            if(v==u)break ;

        }

    }

}

void sc()

{

    memset(vis,0,sizeof(vis)) ;

    memset(dfn,0,sizeof(dfn)) ;

    memset(num,0,sizeof(num)) ;

    idx=tp=ans=0 ;

    for(int i=1 ;i<=n ;i++)

        if(!dfn[i])

            tarjan(i) ;

}

int main()

{

    int T ;

    scanf("%d",&T) ;

    for(int cas=1 ;cas<=T ;cas++)

    {

        cnt=0 ;

        memset(head,-1,sizeof(head)) ;

        scanf("%d%d",&n,&m) ;

        for(int i=0 ;i<m ;i++)

        {

            int s,t ;

            scanf("%d%d",&s,&t) ;

            add(s,t) ;

        }

        sc() ;

        if(ans==1)

        {

            printf("Case %d: -1\n",cas) ;

            continue ;

        }

        memset(IN,0,sizeof(IN)) ;

        memset(OUT,0,sizeof(OUT)) ;

        for(int u=1 ;u<=n ;u++)

        {

            for(int i=head[u] ;i!=-1 ;i=e[i].nxt)

            {

                int tt=e[i].t ;

                if(belong[tt]==belong[u])continue ;

                IN[belong[tt]]++ ;

                OUT[belong[u]]++ ;

            }

        }

        int ret=-1 ;

        for(int i=1 ;i<=ans ;i++)

        {

            if(!IN[i] || !OUT[i])

                ret=max(ret,n*(n-1)-m-num[i]*(n-num[i])) ;

        }

        printf("Case %d: %d\n",cas,ret) ;

    }

    return 0 ;

}

View Code