HDU 4635 Strongly connected ( 强连通分量 )

Strongly connected

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)

Total Submission(s): 3735    Accepted Submission(s): 1481

Problem Description

Give a simple directed graph with N nodes and M edges. Please tell me the maximum number of the edges you can add that the graph is still a simple directed graph. Also, after you add these edges, this graph must NOT be strongly connected.
A simple directed graph is a directed graph having no multiple edges or graph loops.
A strongly connected digraph is a directed graph in which it is possible to reach any node starting from any other node by traversing edges in the direction(s) in which they point.

 

Input

The first line of date is an integer T, which is the number of the text cases.
Then T cases follow, each case starts of two numbers N and M, 1<=N<=100000, 1<=M<=100000, representing the number of nodes and the number of edges, then M lines follow. Each line contains two integers x and y, means that there is a edge from x to y.

 

Output

For each case, you should output the maximum number of the edges you can add.
If the original graph is strongly connected, just output -1.

 

Sample Input

3 3 3 1 2 2 3 3 1 3 3 1 2 2 3 1 3 6 6 1 2 2 3 3 1 4 5 5 6 6 4

 

Sample Output

Case 1: -1 Case 2: 1 Case 3: 15

 

Source

2013 Multi-University Training Contest 4

 

Recommend

zhuyuanchen520

题意：一个有向图，问最多能添加多少条边使这个图仍不强连通

可假设最后所求的图由两个强连通图（图U和图V）组成，且图U和图V之前只有单向边，此时既满足整个图不强连通，又能保证有最多的边。

设图U的顶点数为x,图V的顶点数为y  ( x+y=n )

图U强连通，边数最多为 x*(x-1)

图V强连通，边数最多为 y*(y-1)

图U和图V之前只有单向边,则边数最多为 x*y

图的总边数 sum = x*y+x*(x-1)+y*(y-1) = n*n-n-x*y

即可转化为求 x*y 的最小值，即求顶点数最小的强连通分量

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <stack>
#include <vector>
#define maxn 100010
using namespace std;
int n,m,q,cnt,sum,index;
int dfn[maxn],low[maxn],belong[maxn],instack[maxn];
int in[maxn],out[maxn],num[maxn];
stack<int>s;
vector<int>g[maxn];
struct li
{
	int a,b;
}link[maxn];
void tarjan(int x)
{
	int i,j;
	low[x]=dfn[x]=++index;
	s.push(x);
	instack[x]=1;
	for(i=0;i<g[x].size();i++)
	{
		int k=g[x][i];
		if(!dfn[k])
		{
			tarjan(k);
			low[x]=min(low[x],low[k]);
		}
		else if(instack[k])
			low[x]=min(low[x],dfn[k]);
	}
	if(dfn[x]==low[x])
	{
		sum++;
		while(!s.empty())
		{
			j=s.top();
			s.pop();
			instack[j]=0;
			num[sum]++;
			belong[j]=sum;
			if(j==x)
				break;
		}
	}
}
int main ()
{
	int i,j,a,b,t,cas=1;
	scanf("%d",&t);
	while(t--)
	{
		while(!s.empty())
			s.pop();
		memset(belong,0,sizeof(belong));
		memset(instack,0,sizeof(instack));
		memset(dfn,0,sizeof(dfn));
		memset(low,0,sizeof(low));
		memset(g,0,sizeof(g));
		memset(in,0,sizeof(in));
		memset(out,0,sizeof(out));
		memset(num,0,sizeof(num));
		index=sum=0;
		scanf("%d %d",&n,&m);
		for(i=1;i<=m;i++)
		{
			scanf("%d %d",&a,&b);
			link[i].a=a;
			link[i].b=b;
			g[a].push_back(b);
		}
		for(i=1;i<=n;i++)
		{
			if(!dfn[i])
				tarjan(i);
		}
		for(i=1;i<=m;i++)
		{
			if(belong[link[i].a]!=belong[link[i].b])
			{
				out[belong[link[i].a]]++;
				in[belong[link[i].b]]++;
			}
		}
		long long ans=-1;
		for(i=1;i<=sum;i++)
		{
			if(in[i]==0||out[i]==0)
			{
				long long k=num[i];
				ans=max(ans,k*(n-k)+k*(k-1)+(n-k)*(n-k-1)-m);
			}
		}
		printf("Case %d: ",cas++);
		if(sum<=1)
			printf("-1\n");
		else
			printf("%d\n",ans);
	}
	return 0;
}