Strongly connected(hdu4635（强连通分量）)
Strongly connected
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 477 Accepted Submission(s): 212
Problem Description
Give a 易做图 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 易做图 directed graph. Also, after you add these edges, this graph must NOT be strongly connected.
A 易做图 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
解析：
题意：
解析：给出一个有向图，问最多可以加多少边使得任意两点无论正反方向皆可到达
思路：最终添加完边的图，肯定可以分成两个部X和Y，其中只有X到Y的边没有Y到X的边，那么要使得边数尽可能的多，则X部肯定是一个完全图，Y部也是，同时X部中每个点到Y部的每个点都有一条边，假设X部有x个点，Y部有y个点，有x+y=n，同时边数F=x*y+x*(x-1)+y*(y-1)，整理得：F=N*N-N-x*y，当x+y为定值时，二者越接近，x*y越大，所以要使得边数最多，那么X部和Y部的点数的个数差距就要越大，所以首先对于给定的有向图缩点，对于缩点后的每个点，如果它的出度或者入度为0，那么它才有可能成为X部或者Y部，所以只要求缩点之后的出度或者入度为0的点中，包含节点数最少的那个点，令它为一个部，其它所有点加起来做另一个部，就可以得到最多边数的图了
故：1要用tarjan算法进行缩点
2.缩点后重建图
3.找出出度或入度为0且结点最小点，套用公式
46MS 5436K 2350 B C++
*/
#pragma comment(linker, "/STACK:1024000000,1024000000")/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<stack>
#include<algorithm>
#include<iostream>
using namespace std;
const int maxn=100000+10;
int pre[maxn],scc[maxn],low[maxn],st[maxn];
int nodenum[maxn],head1[maxn],head2[maxn],vis[maxn];
int dfsn,sccn,top,ans,t1,t2,m,n;
struct Edge
{
int s;
int t;
int next;
}edge[maxn];
struct Node
{
int fn;//出度
int tn;//入度
int num;//缩点后每个“结点”含有的节点数
}node[maxn];
int min(int a,int b)
{
return a<b? a:b;
}
void init()
{
memset(pre,0,sizeof(pre));
memset(scc,0,sizeof(scc));
memset(low,0,sizeof(low));
memset(st,0,sizeof(st));
memset(vis,0,sizeof(vis));
memset(head1,-1,sizeof(head1));
memset(head2,-1,sizeof(head2));
dfsn=sccn=top=ans=t1=t2=0;
}
void add1(int s,int t)
{
edge[t1].s=s;
edge[t1].t=t;
edge[t1].next=head1[s];
head1[s]=t1++;
}
void add2(int s,int t)
{
edge[t2].s=s;
edge[t2].t=t;
edge[t2].next=head2[s];
head2[s]=t2++;
}
void dfs(int u)//缩点
{
pre[u]=low[u]=++dfsn;
st[top++]=u;
vis[u]=1;//标记已访问的点
for(int i=head1[u];i!=-1;i=edge[i].next)
{
int v=edge[i].t;
if(!pre[v])
{
dfs(v);
low[u]=min(low[u],low[v]);
}
else if(!scc[v])
low[u]=min(low[u],pre[v]);
}
if(low[u]==pre[u])
{
int k=0;
sccn++;
for(;;)
{
int x=st[--top];
scc[x]=sccn;
k++;
if(x==u)
break;
}
node[sccn].num=k;//记录缩点后的信息
node[sccn].fn=0;
node[sccn].tn=0;
}
}
void work()
{
for(int i=1;i<=n;i++)//这样做的目的是保证每个结点都可以访问到
{
if(!vis[i])
dfs(i);
}
//printf("sccn==%d\n",sccn);
if(sccn==1)//如果当且仅当只有用一个强连通分量时，不需要加边
{
ans=-1;
return;
}
for(int i=0;i<t1;i++)//缩点后重建图。并记录每个结点的出度和入度数
{
int u=scc[edge[i].s];
int v=scc[edge[i].t];
add2(u,v);
if(u!=v)
{
node[u].tn++;
node[v].fn++;
}
}
int Min=100000000,sum=0;
for(int i=1;i<=sccn;i++)
{
if(node[i].fn==0||node[i].tn==0)//取出度或入读为0的点
{if(Min>node[i].num)
Min=node[i].num;
}
sum+=node[i].num;
}
ans=sum*sum-sum-Min*(sum-Min)-m;
}
int main()
{
int T,i,j,u,v;
int c=0;
scanf("%d",&T);
while(T--)
{ init();
scanf("%d%d",&n,&m);
for(i=1;i<=m;i++)
{
scanf("%d%d",&u,&v);
add1(u,v);
}
work();
printf("Case %d: %d\n",++c,ans);
}
return 0;
}
补充：综合编程 , 其他综合 ,
