poj 3694 Network (tarjan+lca)

题目链接：http://poj.org/problem?id=3694

A network administrator manages a large network. The network consists of N computers and M links between pairs of computers. Any pair of computers are connected directly or indirectly by successive links, so data can be transformed between any two computers. The administrator finds that some links are vital to the network, because failure of any one of them can cause that data can't be transformed between some computers. He call such a link a bridge. He is planning to add some new links one by one to eliminate all bridges.

You are to help the administrator by reporting the number of bridges in the network after each new link is added.

Input

The input consists of multiple test cases. Each test case starts with a line containing two integers N(1 ≤ N ≤ 100,000) and M(N - 1 ≤ M ≤ 200,000).
Each of the following M lines contains two integers A and B ( 1≤ A ≠ B ≤ N), which indicates a link between computer A and B. Computers are numbered from 1 to N. It is guaranteed that any two computers are connected in the initial network.
The next line contains a single integer Q ( 1 ≤ Q ≤ 1,000), which is the number of new links the administrator plans to add to the network one by one.
The i-th line of the following Q lines contains two integer A and B (1 ≤ A ≠ B ≤ N), which is the i-th added new link connecting computer A and B.

The last test case is followed by a line containing two zeros.

Output

For each test case, print a line containing the test case number( beginning with 1) and Q lines, the i-th of which contains a integer indicating the number of bridges in the network after the first i new links are added. Print a blank line after the output for each test case.

Sample Input

3 2
1 2
2 3
2
1 2
1 3
4 4
1 2
2 1
2 3
1 4
2
1 2
3 4
0 0
Sample Output

Case 1:
1
0

Case 2:
2
0

题意： 
给定一个图，对这个图进行加边，求出每加一条边后，图中桥的个数。 
思路： 
首先肯定是要先求出原图中桥的个数，并且把桥标记起来。思考加一条边以后桥的数量会减少多少，联想到之前的那道题，就是加一条边，能够使桥的数量最少是多少。之前那个做法就是缩点后树的直径，这个就是可以减少的最多的桥的数量。因为如果这是一条链，将两个端点连起来，这上面的桥都消失了。。 
所以按照这个思路，可以考虑，对于每个要加的边，求出他们的lca，在这个路径上如果碰到一个桥就减一。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <stack>
#include <cmath>
using namespace std;
const int maxn = 1e5 + 100;
int low[maxn], dfn[maxn], father[maxn];
bool isbridge[maxn]; //标记桥 树边<u,v> 是桥则 isbridge[v] = true
int index, num;
int n, m;
vector<int> G[maxn];
void init()
{
	for (int i = 0; i <= n; i++) G[i].clear();
	memset(dfn, 0, sizeof(dfn));
	memset(isbridge, false, sizeof(isbridge));
	index = num = 0;
}
int dfs(int u, int fa)
{
	father[u] = fa;
	int lowu = dfn[u] = ++index;
	for (int i = 0; i < G[u].size(); i++)
	{
		int v = G[u][i];
		if (!dfn[v])
		{
			int lowv = dfs(v, u);
			lowu = min(lowu, lowv);
			if (lowv > dfn[u])
			{
				num++;
				isbridge[v] = true;
			}
		}
		else if (dfn[v] < dfn[u] && v != fa) lowu = min(lowu, dfn[v]);
	}
	low[u] = lowu;
	return lowu;
}
void lca(int u, int v)
{
	while (dfn[u] > dfn[v])
	{
		if (isbridge[u])
		{
			num--;
			isbridge[u] = false;
		}
		u = father[u];
	}
	while (dfn[v] > dfn[u])
	{
		if (isbridge[v])
		{
			num--;
			isbridge[v] = false;
		}
		v = father[v];
	}
	while (u != v)
	{
		if (isbridge[u])
		{
			num--;
			isbridge[u] = false;
		}
		if (isbridge[v])
		{
			num--;
			isbridge[v] = false;
		}
		u = father[u];
		v = father[v];
	}
}
int main()
{
	//freopen("C://input.txt", "r", stdin);
	int k = 1;
	while (scanf("%d %d", &n, &m) == 2)
	{
		if (n == 0 || m == 0) break;
		init();
		for (int i = 1; i <= m; i++)
		{
			int a, b;
			scanf("%d %d", &a, &b);
			G[a].push_back(b);
			G[b].push_back(a);
		}
		dfs(1, -1);
		int q;
		scanf("%d", &q);
		printf("Case %d:\n", k++);
		while (q--)
		{
			int u, v;
			scanf("%d %d", &u, &v);
			lca(u, v);
			printf("%d\n", num);
		}
		printf("\n");
	}
	return 0;
}