[poj1523 SPF]tarjan算法求割点

SPF

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 6304		Accepted: 2897

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

Source

Greater New York 2000

题意是给一个无向连通图，问是否存在割点，如果存在，求出哪些是割点，并且删除该割点后可以把整个图分成多少块。
这题我是暴力瞎搞的，先求出割点，然后并查集直接看剩下的点有几个连通分量-.-
但是其实可以做到更好，求割点时就可以更新出连通块的答案了。。。新手太笨︿(￣︶￣)︿

1523

Accepted

564K

0MS

G++

2311B

代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;

const int MAX = 1024;
vector<int> G[MAX];

bool vis[MAX];
int dfn[MAX], low[MAX];
vector<int> google;
int num;

void dfs(int u) {
	vis[u] = true;
	dfn[u] = low[u] = ++num;
	int flag = false;
	int son = 0;
	for (int i = 0; i < G[u].size(); ++i) {
		int v = G[u][i];
		if (vis[v]) {
			if (low[u] > dfn[v]) low[u] = dfn[v];
			continue;
		}
		dfs(v);
		++son;
		if (low[v] < low[u]) low[u] = low[v];
		if (low[v] >= dfn[u]) flag = true;
	}
	if (dfn[u] == 1) {
		if (son >= 2) {
			google.push_back(u);
		}
	} else if (flag && son >= 1) {
		google.push_back(u);
	}
}

void tarjan() {
	num = 0;
	google.clear();
	memset(vis, false, sizeof(vis));
	fill(dfn, dfn + MAX, MAX);
	dfs(1);
}

int father[MAX];
int find(int x) {
	return x == father[x] ? x : father[x] = find(father[x]);
}
void Union(int x, int y) {
	int fx = find(x), fy = find(y);
	if (fx != fy) father[fx] = father[fy];
}
int nodes;
void Print() {
	sort(google.begin(), google.end());
	for (int i = 0; i < google.size(); ++i) {
		for (int j = 1; j <= nodes; ++j) father[j] = j;
		int tt = google[i];
		for (int j = 1; j <= nodes; ++j) {
			if (j == tt) continue;
			for (int k = 0; k < G[j].size(); ++k) {
				int v = G[j][k];
				if (v == tt) continue;
				Union(j, v);
			}
		}
		int yy = 0;
		for (int j = 1; j <= nodes; ++j) {
			if (j != tt && father[j] == j) ++yy;
		}
		printf("  SPF node %d leaves %d subnets\n", tt, yy);
	}
}

int read() {
	char ch;
	while ((ch = getchar()) < '0' || ch > '9');
	int x = ch - '0';
	while ((ch = getchar()) >= '0' && ch <= '9') {
		x = (x << 3) + (x << 1) + ch - '0';
	}
	return x;
}

int main() {
	int u, v;
	while (u = read()) {
		nodes = u;
		for (int i = 0; i < MAX; ++i) G[i].clear();
		v = read();
		if (v > nodes) nodes = v;
		G[u].push_back(v);
		G[v].push_back(u);
		while (u = read()) {
			v = read();
			if (u > nodes) nodes = u;
			if (v > nodes) nodes = v;
			G[u].push_back(v);
			G[v].push_back(u);
		}
		tarjan();
		static int __ = 0;
		if (__) puts("");
		printf("Network #%d\n", ++__);
		if (google.size() == 0) {
			puts("  No SPF nodes");
		} else {
			Print();
		}
	}
	return 0;
}