poj 2117 Electricity【点双连通求删除点后最多的bcc数】

Electricity

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 4727		Accepted: 1561

Description

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

Input

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. 

Output

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.

Sample Input

3 3
0 1
0 2
2 1
4 2
0 1
2 3
3 1
1 0
0 0

Sample Output

1
2
2

题意：有p个发电厂，之间有c条路（这c条路不一定能把所有点连接起来，即有孤立点，所以要算出图被分为几部分）让你求去掉一个点后最多有多少个bcc

#include<stdio.h>
#include<string.h>
#include<stack>
#include<algorithm>
#define MAX 21000
#define MAXM 2001000
#define INF 0x7fffff
using namespace std;
int dfn[MAX],low[MAX];
int dfsclock,ebccnt;
int addbcc[MAX];//记录去掉割点后bcc个数
int head[MAX],ans,num;
int iscut[MAX];//记录是否是割点
struct node
{
    int beg,end,next;
}edge[MAXM];
void init()
{
    ans=0;
    memset(head,-1,sizeof(head));
}
void add(int u,int v)
{
    edge[ans].beg=u;
    edge[ans].end=v;
    edge[ans].next=head[u];
    head[u]=ans++;
}
void tarjan(int u,int fa)
{
    int i,v;
    dfn[u]=low[u]=++dfsclock;
    int son=0;//记录子节点数目
    for(i=head[u];i!=-1;i=edge[i].next)
    {      
        v=edge[i].end;
        if(!dfn[v])
        {
            son++;
            tarjan(v,u);
            low[u]=min(low[u],low[v]);
            if(dfn[u]<=low[v])//是割点，先不考虑是不是根节点
            {
                addbcc[u]++;//这是割点的一个子节点，bcc数目加1
                iscut[u]=1;
            }
        }
        else 
            low[u]=min(dfn[v],low[u]);
    }
    if(fa<0&&son<2)//不是根节点
    {
        iscut[u]=0;
        addbcc[u]=0;
    }
    if(fa<0&&son>1)//是根节点
    {
        iscut[u]=1;
        addbcc[u]=son-1;//这里当是根节点时去掉割点bcc数目为子节点数目son
                 //但是因为上边我们for循环中求bcc时全部当做非根节点求这样
                 //其非根节点割点去掉之后bcc个数 为son+1，为了最后输出时统一加1
                 //这里我们让 addbcc[u]=son-1;
    } 
}
void find(int l,int r)
{
    dfsclock=0;
    memset(low,0,sizeof(low));
    memset(dfn,0,sizeof(dfn));
    memset(addbcc,0,sizeof(addbcc));
    memset(iscut,0,sizeof(iscut));
    num=0;
    for(int i=l;i<=r;i++)
    {
        if(!dfn[i])
        {
        	tarjan(i,-1);
        	num++;//计算原始的图被分为几部分 
        }    
    }
}
int main()
{
    int n,m,j,i,a,b;
    while(scanf("%d%d",&n,&m),n|m)
    {
    	if(m==0)
    	{
    		printf("%d\n",n-1);
    		continue;
    	}
        init();
        while(m--)
        {
            scanf("%d%d",&a,&b);
            add(a,b);
            add(b,a);
        }
        find(0,n-1);
        int sum=-1;
        for(i=0;i<n;i++) 
            sum=max(sum,addbcc[i]+num);
        printf("%d\n",sum);
    }
    return 0;
}