poj 1523(割点与双联通分量)

SPF

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 8157		Accepted: 3731

Description

Consider the two networks shown below. Assuming that data moves around these networks only between directly connected nodes on a peer-to-peer basis, a failure of a single node, 3, in the network on the left would prevent some of the still available nodes from communicating with each other. Nodes 1 and 2 could still communicate with each other as could nodes 4 and 5, but communication between any other pairs of nodes would no longer be possible.

Node 3 is therefore a Single Point of Failure (SPF) for this network. Strictly, an SPF will be defined as any node that, if unavailable, would prevent at least one pair of available nodes from being able to communicate on what was previously a fully connected network. Note that the network on the right has no such node; there is no SPF in the network. At least two machines must fail before there are any pairs of available nodes which cannot communicate.

Input

The input will contain the description of several networks. A network description will consist of pairs of integers, one pair per line, that identify connected nodes. Ordering of the pairs is irrelevant; 1 2 and 2 1 specify the same connection. All node numbers will range from 1 to 1000. A line containing a single zero ends the list of connected nodes. An empty network description flags the end of the input. Blank lines in the input file should be ignored.

Output

For each network in the input, you will output its number in the file, followed by a list of any SPF nodes that exist.

The first network in the file should be identified as "Network #1", the second as "Network #2", etc. For each SPF node, output a line, formatted as shown in the examples below, that identifies the node and the number of fully connected subnets that remain when that node fails. If the network has no SPF nodes, simply output the text "No SPF nodes" instead of a list of SPF nodes.

Sample Input

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

1 2
2 3
3 4
4 5
5 1
0

1 2
2 3
3 4
4 6
6 3
2 5
5 1
0

0

Sample Output

Network #1
  SPF node 3 leaves 2 subnets

Network #2
  No SPF nodes

Network #3
  SPF node 2 leaves 2 subnets
  SPF node 3 leaves 2 subnets

题意：

有一堆计算机相互连接，找出其中的割点并输出去除割点后将图分成多少块。

思路：

这是一道求割点的模板题，用tarjan算法求出割点，图被分成多少块可以通过压缩双联通分量，遍历割点连接的双联通分量来求。

#include<stdio.h>
#include <iostream> 
#include <string.h>
#include <vector> 
using namespace std;  
#define MyMax 1005
typedef vector<int> Edge;
vector<Edge> G(MyMax); 
bool Visited[MyMax] ; 
int dfn[MyMax] ; 
int low[MyMax] ;
int Father[MyMax]; //DFS树中每个点的父节点 
bool bIsCutVetext[MyMax]; //每个点是不是割点 
int nTime; //Dfs时间戳 
int n,m; //n是点数，m是边数
void Tarjan(int u, int father) //father 是u的父节点 
{
	Father[u] = father;  
	low[u] = dfn[u] = nTime ++;  
	for(int i = 0;i < G[u].size() ;i ++ ) 
	{
		int v = G[u][i];   
		if( ! dfn[v]) 
		{    
			Tarjan(v,u);    
			low[u] = min(low[u],low[v]);   
		}   
		else if( father != v ) // 连到父节点的回边不考虑， 否则求不出桥    
			low[u] = min(low[u],dfn[v]);  
	} 
}
void Count() 
{ //计算割点和桥  
	int nRootSons = 0; 
	int i;  
	Tarjan(1,0);  
	for( i = 2;i <= n;i ++ ) 
	{   
		int v = Father[i];   
		if( v == 1 )    
			nRootSons ++; //DFS树中根节点有几个子树   
		else 
		{    
			if( dfn[v] <= low[i])     
				bIsCutVetext[v] = true;   
		}  
	}  
	if( nRootSons > 1)   
		bIsCutVetext[1] = true;  
	int ans=0,vis[1005];
	memset(vis,0,sizeof(vis));
	for( i = 1;i <= n;i ++ )
	{
		int num=0;
		if(bIsCutVetext[i])
		{
			ans++;
			int flag=0;
			for(int j = 0;j < G[i].size();j ++ ) 
			{
				int v=G[i][j];
				if(low[i]==low[v])
					flag=1;
				if(low[i]!=low[v]&&!vis[low[v]])
				{
					num++;
					vis[low[v]]=1;
				}
			}
			if(flag)
				num++;
			printf("  SPF node %d leaves %d subnets\n",i,num);
		}
	}
	if(!ans)
		printf("  No SPF nodes\n");
}
int mark[1005][1005];
int main() 
{  
	freopen("in.txt","r",stdin);
	freopen("out.txt","w",stdout);
	int u,v;  
	int i,tt=1;   
	nTime = 1; 
	n=0;
	while(scanf("%d",&u)!=EOF)
	{
		for(int i=0;i<=n;i++)
			G[i].clear();
		memset(mark,0,sizeof(mark));
		n=0;
		m=1;
		if(u==0)
			break;
		scanf("%d",&v);
		n=max(max(n,u),v);
		G[v].push_back(u);   
		G[u].push_back(v); 
		mark[u][v]=mark[v][u]=1;
		while(scanf("%d",&u)!=EOF&&u)
		{
			scanf("%d",&v);
			if(!mark[u][v])
			{
				m++;
				n=max(max(n,u),v);
				G[v].push_back(u);   
				G[u].push_back(v); 
				mark[u][v]=mark[v][u]=1;
			}
		}
	memset( dfn,0,sizeof(dfn));  
	memset( Father,0,sizeof(Father));  
	memset( bIsCutVetext,0,sizeof(bIsCutVetext));  
	printf("Network #%d\n",tt++);
	Count();  
	printf("\n");
	}
	return 0; 
}