描述
Blackouts and Dark Nights (also known as ACM++) is a company that provides electricity. The company owns several power plants, each of them supplying a small area that surrounds it. This organization brings a lot of problems - it often happens that there is not enough power in one area, while there is a large surplus in the rest of the country.
ACM++
has therefore decided to connect the networks of some of the plants
together. At least in the first stage, there is no need to connect all
plants to a single network, but on the other hand it may pay up to
create redundant connections on critical places - i.e. the network may
contain cycles. Various plans for the connections were proposed, and the
complicated phase of evaluation of them has begun.
One of the
criteria that has to be taken into account is the reliability of the
created network. To evaluate it, we assume that the worst event that can
happen is a malfunction in one of the joining points at the power
plants, which might cause the network to split into several parts. While
each of these parts could still work, each of them would have to cope
with the problems, so it is essential to minimize the number of parts
into which the network will split due to removal of one of the joining
points.
Your task is to write a software that would help
evaluating this risk. Your program is given a description of the
network, and it should determine the maximum number of non-connected
parts from that the network may consist after removal of one of the
joining points (not counting the removed joining point itself).
输入
The input consists of several instances.
The
first line of each instance contains two integers 1 <= P <= 10
000 and C >= 0 separated by a single space. P is the number of power
plants. The power plants have assigned integers between 0 and P - 1. C
is the number of connections. The following C lines of the instance
describe the connections. Each of the lines contains two integers 0
<= p1, p2 < P separated by a single space, meaning that plants
with numbers p1 and p2 are connected. Each connection is described
exactly once and there is at most one connection between every two
plants.
The instances follow each other immediately, without any separator. The input is terminated by a line containing two zeros.
输出
The
output consists of several lines. The i-th line of the output
corresponds to the i-th input instance. Each line of the output consists
of a single integer C. C is the maximum number of the connected parts
of the network that can be obtained by removing one of the joining
points at power plants in the instance.
样例输入
3 3
0 1
0 2
2 1
4 2
0 1
2 3
3 1
1 0
0 0
样例输出
1
2
2
题意
有N个点编号0-N-1，让你去掉一个点，最多剩下的连通图数
题解
去掉一个点使得连通数尽可能多，可以想到去掉的是割点
如果low[v]>=low[u] cut[u]=true说明u是割点
如果改成cut[u]++，说明去掉u点会多形成cut[u]个连通图
如果u是根节点
1.cut[u]=0 说明u为孤立点 则去掉后连通数少1
2.cut[u]=1 说明u只有一个儿子 则去掉后连通数不变
3.cut[u]>=2 说明u有>=2个儿子 则去掉后连通数多cut[u]-1
代码
#include<bits/stdc++.h>
using namespace std; const int maxn=1e4+; vector< vector<int> >G(maxn);
int dfn[maxn],low[maxn],cut[maxn];
int n,m,ans,tot; void tarjan(int u,int fa)
{
dfn[u]=low[u]=++tot;
for(int i=;i<G[u].size();i++)
{
int v=G[u][i];
if(v==fa)continue;
if(!dfn[v])
{
tarjan(v,u);
low[u]=min(low[u],low[v]);
if(low[v]>=dfn[u])cut[u]++;
}
low[u]=min(low[u],dfn[v]);
}
}
int main()
{
while(scanf("%d%d",&n,&m)!=EOF,n||m)
{
ans=tot=;
for(int i=;i<n;i++)low[i]=dfn[i]=cut[i]=,G[i].clear();
for(int i=,u,v;i<m;i++)
{
scanf("%d%d",&u,&v);
G[u].push_back(v);
G[v].push_back(u);
}
for(int i=;i<n;i++)
{
if(!dfn[i])
{
ans++;
tarjan(i,-);
cut[i]--;
}
}
printf("%d\n",ans+*max_element(cut,cut+n));
}
return ;
}