POJ 2117 无向图割点

                                                                                           Electricity

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 3074		Accepted: 1043

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

题意：去掉一个点后，可以生成的最多的连通块。

解题思路：割点模板，不解释。

代码：
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<map>
using namespace std;
int head[20000],tol,low[20000],dfn[20000],Stack[30000],instack[20000],add_bloak[20000],indexx,top,cut[20000],n;
struct node
{
        int to,next;
}edge[1000000];
map<int,int> mp,mm;
void add(int u,int v)
{
        edge[tol].to=v;
        edge[tol].next=head[u];
        head[u]=tol++;
}
void tarjin(int u,int pre)
{
        int i,v;
        low[u]=dfn[u]=++indexx;
        Stack[top++]=u;
        int son=0;
        for(i=head[u];i!=-1;i=edge[i].next)
        {
                v=edge[i].to;
                if(v==pre)continue;
                if(!dfn[v])
                {
                        son++;
                       tarjin(v,u);
                       if(low[u]>low[v])low[u]=low[v];
                       if(u!=pre&&low[v]>=dfn[u])
                       {
                               cut[u]=1;
                               add_bloak[u]++;
                       }
                }
                else if(low[u]>dfn[v])low[u]=dfn[v];
        }
        if(u==pre)add_bloak[u]=son-1;
        if(u==pre&&son>1)cut[u]=1;
        top--;
}
void solve()
{
        memset(dfn,0,sizeof(dfn));
        memset(instack,0,sizeof(instack));
        memset(add_bloak,0,sizeof(add_bloak));
        memset(cut,0,sizeof(cut));
        indexx=top=0;
        int cnt=0;
        for(int i=0;i<n;i++)if(!dfn[i])tarjin(i,i),cnt++;
        int ans=0;
        for(int i=0;i<n;i++)if(ans<add_bloak[i]+cnt)ans=add_bloak[i]+cnt;
        printf("%d\n",ans);
}
int main()
{
        int i,j,k,m,t=0,p,q;
        while(~scanf("%d%d",&n,&m))
        {
                if(n==0&&m==0)break;
                memset(head,-1,sizeof(head));tol=0;
                while(m--)
                {
                        scanf("%d%d",&p,&q);
                        add(p,q);
                        add(q,p);
                }
               solve();
        }
        return 0;
}