POJ2117_Electricity_求删除割点后最大连通分支的个数_tarjan

题意：

给一个图，给图中结点的连接关系（但图本身就有可能有多个连通分支），让你求删掉一个点后，图中剩余的连通分支的个数最大是多少

题解：

在每个连通分支中找割点，并计算割点对应的可以增加的最大块数，然后加上原来的图中连通分支个数就是答案

不过要注意有可能没有割点，这时候就是直接输出连通分支个数就行

另外有可能没有边，这时候删掉任意一点得到的连通分支数为n-1

代码中注释很少，因为核心算法的思想已经在上一题（POJ1523）中写过了，两者相差无几

题目：

Electricity

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 2867		Accepted: 971

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

代码：

Run ID	User	Problem	Result	Memory	Time	Language	Code Length	Submit Time
11805666	chengtbf	2117	Accepted	1412K	594MS	C++	1404B	2013-07-18 10:32:36

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#define N 10005
using namespace std;
int dfs_time,d[N],low[N];
int visited[N];
int ans;
int node_num;
int subsets[N];
int root;
vector<int>f[N];

int find_min(int a,int b)
{
	return a<b?a:b;
}
int find_max(int a,int b)
{
	return a>b?a:b;
}

void targan(int u,int father)
{
	visited[u]=1;
	if (u!=root)subsets[u]++;
	d[u]=low[u]=++dfs_time;
	for (int i = 0; i < f[u].size(); i++)
	{
		int child=f[u][i];
		if (!visited[child])
		{
			targan(child,u);
			low[u]=find_min(low[u],low[child]);
			if(low[child]>=d[u])subsets[u]++;
		}
		else if(child!=father)
		{
			low[u]=find_min(low[u],d[child]);
		}	
	}
	if (subsets[u]>ans)
	{
		ans=subsets[u];
	}
}
int main()
{
	int c,i,j,a,b;
	int num;
	while (scanf("%d%d",&node_num,&c)!=EOF)
	{
		if(node_num==0&&c==0)break;
		dfs_time=0;
		ans=1;
		num=0;
		memset(visited,0,sizeof(visited));
		memset(subsets,0,sizeof(subsets));
		for ( i = 0; i < node_num; i++)
		{
			f[i].clear();
		}
		for ( i = 0; i < c; i++)
		{
			scanf("%d%d",&a,&b);
			f[a].push_back(b);
			f[b].push_back(a);
		}
		for ( i = 0; i < node_num; i++)
		{
			if (!visited[i])//如果没有访问过，说明到了新的一个连通分量中了
			{
				num++;
				root=i;
				targan(i,-1);
			}
		}
		if (c==0)
			num--;
		printf("%d\n",ans+num-1);
	}
	return 0;
}