POJ 3694 Network

Network

Time Limit: 5000MS Memory Limit: 65536K

Description

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
Source

2008 Asia Hefei Regional Contest Online by USTC

题意 ： 1：给定连通图 ；2：Q个询问：每个询问补给一条(a,b)连线，询问当前图桥数（割边）

思路：先tarjan找割边，记录顶点父亲，标记割边的顶点 ； 加入（a,b) 后 ， 深搜树里形成环  。 故可利用LCA算法

把(a,b)到最近公共祖先形成的环中的桥一一删去。

tarjan算法是R.Tarjan发明的。对图深度优先搜索，定义dfn(u)为u在搜索树（以下简称为树）中被遍历到的次序号。定义low(u)为u或u的子树中能通过非父子边追溯到的最早的节点，即dfn序号最小的节点。根据定义，则有：

low(u)=min { dfn(u) dfn(v) (u,v)为后向边(返祖边) 等价于 dfn(v)<dfn(u)且v不为u的父亲节点 low(v) (u,v)为树枝边(父子边) }

一个顶点u是割点，当且仅当满足(1)或(2) 

(1) u为树根，且u有多于一个子树;

(2) u不为树根，且满足存在(u,v)为树枝边(或称父子边，即u为v在搜索树中的父亲)，使得dfn(u)<=low(v)。

一条无向边(u,v)是桥，当且仅当(u,v)为树枝边，且满足dfn(u)<low(v)。  

对于dfn(u) < low(v) 即v在搜索树中有且仅有唯一父子边（v无到祖先的边）则（u，v）为割边   

#include <iostream>
#include <cstdio>
#include <vector>
#include <cstring>
#define maxn 100010
using namespace std;
vector<int> mapp[maxn] ;
int dfn[maxn] , low[maxn] ;
int fa[maxn] ;
bool isbridge[maxn] ;
int ans , nbridge , n ;
void tarjan(int u , int pa , int dep) {             // 割边 
    dfn[u] = low[u] = ++dep ;
    for( int i = 0 ; i < mapp[u].size() ; ++i ) {
        int v  = mapp[u][i] ;
        if( !dfn[v] ) {
            fa[v] = u ;
            tarjan(v , u , dep) ;
            if ( low[v] > dfn[u]  ) {
                ++nbridge ;
                isbridge[v] = true ;
            }
            low[u] = low[u] > low[v]  ? low[v] : low[u] ;
        }
        else if( v != pa ) {
            low[u] = low[u] > dfn[v] ? dfn[v] : low[u] ;
        }
    }
}
void lca ( int a , int b) {                         //从深搜树找最近公共祖先
    if( a < b ) {                                   //并将(a,b)中的桥删掉
        a ^= b ;
        b ^= a ;
        a ^= b;
    }
    while(dfn[a] > dfn[b] ) {                       //从下往上找到同一层     
        if( isbridge[a]) {                          
            --nbridge ;
            isbridge[a] = false ;
        }
        a = fa[a] ;
    }
    while( a != b) {                                //从同一层找到公共祖先
        if( isbridge[a] ) {
            --nbridge ;
            isbridge[a] = false ;
        }
        if( isbridge[b] ) {
            --nbridge ;
            isbridge[b] = false ;
        }
        a = fa[a] , b = fa[b] ;
    }
}
void init( ) {
    memset( dfn, 0 , sizeof(dfn )) ;
    memset( isbridge, 0 , sizeof(isbridge)) ;
    for ( int i = 0 ; i <= n ; ++i ) {
        mapp[i].clear() ;
    }
     nbridge = 0 ;
}
int main(){
    int  m , ncase = 1;
    while(~scanf("%d%d",&n ,&m),(n||m)) {
            init() ;
            int num , goal ;
        while(m--) {
            scanf("%d%d",&num,&goal) ;
            mapp[num].push_back(goal ) ;
            mapp[goal].push_back(num ) ;
        }
        fa[1] =  1 ;
        tarjan(1, -1 , 0) ;
        int q , a , b ;
        printf("Case %d:\n",ncase++) ;
        scanf("%d",&q) ;
        while(q--) {
            scanf("%d %d",&a,&b) ;
            lca(a,b) ;
            cout << nbridge << endl ;
         }
         cout << endl ;
    }
    return 0 ;
}