POJ3694 Network（求每次添加边后剩余的桥的数量）

题目链接

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

题意

给定一个无向图，保证连通。有q次加边操作，对每次加边后，输出剩余的桥的总数。

分析

通过tarjan算法可以求出初始桥的总数sum。加一边（u，v）后，从u–>LCA(u,v)–>v–u这个环上的所有桥都没有了。通过父结点向上爬找LCA计数减少的桥数即可。

对无向图进行一遍dfs，建立一颗深搜树来确定桥（可以通过一维数组来标记，用较深的结点代替边）和结点的父节点。
对每次加边（u，v），通过找LCA解决。每次由较深的结点向上爬，累计经过的桥并去掉桥的标记。

AC代码

//1407ms 7.8MB
#include <cstdio>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
using namespace std;

const int maxn=1e5+100;
const int maxe=2e5+100;
//vector<int> g[maxn];//超时？
struct edge//邻接表表示图
{
    int to,next;
}e[maxe<<1];
int head[maxn],cnt;
int dfn[maxn],low[maxn],index,n,m,sum;
stack<int> sta;
int fa[maxn];//父结点
bool bridge[maxn];//桥
void init()//初始化
{
    memset(head,-1,sizeof(head));
    cnt=-1;//边编号
    index=0;//深度
    sum=0;//桥总数
    memset(low,0,sizeof(low));
    memset(dfn,0,sizeof(dfn));
    memset(fa,0,sizeof(fa));
}
void add_edge(int u,int v)//加边
{
    e[++cnt].to=v;
    e[cnt].next=head[u];
    head[u]=cnt;
}
void tarjan(int u,int f)//dfs确定桥
{
    dfn[u]=low[u]=++index;
    sta.push(u);
    for(int i=head[u];i!=-1;i=e[i].next)
    {
        int v=e[i].to;
        if(v==f) continue;
        if(dfn[v])
            low[u]=min(low[u],dfn[v]);
        else
        {
            tarjan(v,u);
            fa[v]=u;
            low[u]=min(low[u],low[v]);
            if(low[v]>dfn[u])//桥的判断条件
            {
                sum++;
                bridge[v]=true;
            }
        }
    }
}
int LCA(int u,int v)//求u-->LCA(u,v)-->v中桥的数量
{
    if(u==v) return 0;
    int ans=0;
    while(u!=v)
    {
        if(dfn[u]<dfn[v]) swap(u,v);//由深结点向上爬
        ans+=bridge[u];//计数桥
        bridge[u]=false;//去掉桥标记
        u=fa[u];//向上爬
    }
    return ans;
}
int main()
{
    int kase=1;
    while(~scanf("%d%d",&n,&m))
    {
        init();
        if(n==0 && m==0) break;
        while(m--)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            add_edge(u,v);
            add_edge(v,u);
        }
        tarjan(1,0);
        int q;
        scanf("%d",&q);
        printf("Case %d:\n",kase++);
        while(q--)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            int ans=LCA(u,v);
            sum-=ans;
            printf("%d\n",sum);
        }
        putchar(10);
    }
    return 0;
}