连通图专题------D - Network

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

利用Tarjan强连通算法可以直接算出桥的个数，如果说每次加边后根据图算一次桥的个数的话，是错的，因为会有重边，就是两个点间出现多条边，这样就不能用Tarjan求了；
所以换中思路，如果把不是桥的边的两点进行合并为一个集合，就是缩点，最后会形成一颗树，每个树边都是桥，然后再看加边操作的时候，如果两点在一个集合里，那么ans值（桥边数）就不会变，如果两点不在一个集合里，那么对于这个图来说，已经不是树了，因为出现环了，所以需要继续缩点，找到u，v（加的边）的最近公共祖先，一路上的集合都一起缩为一个点，ans减去消失的桥边数就是答案；
依次对每个加的边这样处理即可

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
typedef long long LL;
const int inf = 0x3f3f3f3f;
#define mp make_pair
#define pb push_back
#define fi first
#define se second
const int N = 1e5 + 5;

vector<int>ve[N];
int low[N],dfn[N],pre[N],fa[N];
int n,m,cnt;

int Find(int x){
    if(x == pre[x])
        return x;
    return pre[x] = Find(pre[x]);
}

int join(int x,int y)
{
    int p = Find(x);
    int q = Find(y);
    if(p == q) return false;
    pre[p] = q;
    return true;
}

int ans = 0;
void Tarjan(int u,int father)
{
    fa[u] = father;
    low[u] = dfn[u] = cnt++;
    int len = ve[u].size();
    for(int i = 0;i < len;++i){
        int v = ve[u][i];
        //cout << u << " " << v << endl;
        if(dfn[v] == -1){
            Tarjan(v,u);
            low[u] = min(low[u],low[v]);
            if(low[v] > dfn[u]){
                ans++;
            }else join(u,v);
        }else if(v != father){
            low[u] = min(low[u],dfn[v]);
        }
    }
}

void lca(int u,int v)
{
    //使得u的dfs搜索树的访问顺序在v的前面
    if(dfn[u] > dfn[v]) swap(u,v);
    //v不断的往前找祖先，知道dfn值小于u的，说明找到了最近公共祖先
    while(dfn[v] > dfn[u]){
        if(join(u,v))
            ans--;
        v = fa[v];
    }
    //u点往祖先点移动，将路上的点都缩成一个点
    while(v != u){
        if(join(u,v))
            ans--;
        u = fa[u];
    }
}

void solve()
{
    memset(low,-1,sizeof(low));
    memset(dfn,-1,sizeof(dfn));
    memset(fa,0,sizeof(fa));
    ans = 0,cnt = 1;
    for(int i = 1;i <= n;++i){
        pre[i] = i;
    }
    Tarjan(1,0);
   // cout << ans << endl;
    int q;
    scanf("%d",&q);
    for(int i = 0;i < q;++i){
        int a,b;
        scanf("%d %d",&a,&b);
        lca(a,b);
        printf("%d\n",ans);
    }
}

int main()
{
    int t = 0;
    while(~scanf("%d %d",&n,&m) && (n + m)){
        for(int i = 1;i <= n;++i)
            ve[i].clear();
        for(int i = 0;i < m;++i){
            int a,b;
            scanf("%d %d",&a,&b);
            ve[a].pb(b);
            ve[b].pb(a);
        }
        printf("Case %d:\n",++t);
        solve();
    }
    return 0;
}