POJ-3694-Network（Tarjan强联通+并查集+LCA）

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

题目大意：给出n个点，m条边的无向图，从中找出“桥”的个数，桥的定义是去掉该边，图就不联通，该边就是桥。

再给出q次操作，每次操作在两个点之间连接一条线，再次输出“桥”的个数。

思路：我这个算法自认为比较辣鸡，但竟然结果还不错？？跑了300+ms，竟然还排名比较靠前？？（之后又去网上看了看其他人的代码，发现都跑的更慢，900+ms~4000+ms不等）。也不知道有什么快的地方。。下面就说一下我的算法思路：

我们首先得到这个图的强联通分量Cnt。Cnt-1就是桥的个数（易得）。

至于如何使用强联通，因为是无向图，我用向前行存的时候，向下访问的时候不适用反向边，即（使用i边的时候不使用(i^1)，想象一下网络流里面刷新残留网路的做法）。

得到了一些强联通分量，然后以这些强联通分量为节点建一棵LCA树，树上的每个边就都是“桥”了，

对于每次新增加边，我没其他思路，只能一步步的向上刷新这棵树，找到亮点的LCA，然后连接，维护Cnt。

用的是朴素的LCA算法，就是一步步的向上找。最后输出Cnt-1即可。

我一直觉得朴素的LCA可能会超时，但竟然过了？可能是数据水的原因吧。。

深知我的这个算法的效率低下，可惜想不到更好的对LCA树的修改，因为是一步一步修改的，如果有路过的dalao，有什么更好的方法，请务必告诉我这个蒟蒻，十分感谢！！

ACCode：

// luogu-judger-enable-o2
//#pragma comment(linker, "/STACK:1024000000,1024000000")
 
#include<stdio.h>
#include<string.h>
#include<math.h>
 
#include<map>
#include<set>
#include<deque>
#include<queue>
#include<stack>
#include<bitset>
#include<string>
#include<fstream>
#include<iostream>
#include<algorithm>
using namespace std;
 
#define ll long long
#define Pair pair<int,int>
//#define max(a,b) (a)>(b)?(a):(b)
//#define min(a,b) (a)<(b)?(a):(b)
#define clean(a,b) memset(a,b,sizeof(a))// 水印
//std::ios::sync_with_stdio(false);
//  register
const int MAXN=1e5+10;
const int INF32=0x3f3f3f3f;
const ll INF64=0x3f3f3f3f3f3f3f3f;
const int MOD=1e9+7;
const double EPS=1.0e-8;
const double PI=acos(-1.0);

struct Node{
	int v,val,nxt;
	Node(int _v=0,int _val=0,int _nxt=0){
		v=_v;val=_val;nxt=_nxt;
	}
};
Node Edge[MAXN<<2];
int Head[MAXN],Ecnt;
int Dfn[MAXN],Low[MAXN],tot;
int Stk[MAXN],InStk[MAXN],Top;
int Belong[MAXN];
int a[MAXN<<2],b[MAXN<<2];
int Deep[MAXN],Bridge[MAXN];
int Pre[MAXN];
int Cnt;
int n,m;

void Intt(){
	clean(Head,-1);Ecnt=0;
	clean(Dfn,0);clean(Low,0);tot=0;
	clean(InStk,0);Top=0;
	clean(Belong,0);Cnt=0;
	clean(Deep,0);
}
void Add(int u,int v,int val){
	Edge[Ecnt]=Node(v,val,Head[u]);
	Head[u]=Ecnt++;
}
void Tarjan(int u,int fa){
	Dfn[u]=Low[u]=++tot;
	Stk[++Top]=u;InStk[u]=1;
	for(int i=Head[u];i+1;i=Edge[i].nxt){
		if(fa==(i^1)) continue;
		int temp=Edge[i].v;
		if(Dfn[temp]==0){
			Tarjan(temp,i);
			Low[u]=min(Low[u],Low[temp]);
		}
		else if(InStk[temp]){
			Low[u]=min(Low[u],Low[temp]);
		}
	}
	if(Low[u]==Dfn[u]){
		++Cnt;
		int temp;
		while(Stk[Top]!=u){
			temp=Stk[Top--];
			InStk[temp]=0;
			Belong[temp]=Cnt;
		}
		temp=Stk[Top--];
		InStk[temp]=0;
		Belong[temp]=Cnt;
	}
}
void DFS(int u){
	for(int i=Head[u];i+1;i=Edge[i].nxt){
		int temp=Edge[i].v;
		if(Deep[temp]>0) continue;
		Deep[temp]=Deep[u]+1;
		Pre[temp]=u;
		DFS(temp);
	}
}
int LCA(int x,int y){
	int ans=0;
	if(Deep[x]<Deep[y]) swap(x,y);
	ans+=Deep[x]-Deep[y];
	while(Deep[x]>Deep[y]){
		if(Bridge[x]){
			Bridge[x]=0;Cnt--;
		}x=Pre[x];
	}
	while(x!=y){
		if(Bridge[x]){
			Bridge[x]=0;Cnt--;
		}
		if(Bridge[y]){
			Bridge[y]=0;Cnt--;
		}x=Pre[x];y=Pre[y];
	}
}
int main(){
	int Case=0;
	while(~scanf("%d%d",&n,&m)){
		if(n==0&&m==0) break;
		Intt();
		for(int i=1;i<=m;++i){
			scanf("%d%d",&a[i],&b[i]);
			Add(a[i],b[i],1);Add(b[i],a[i],1);
		}
		for(int i=1;i<=n;++i){
			if(Dfn[i]==0){
				Tarjan(i,-1);
			}
		}
		for(int i=1;i<=Cnt;++i){
			Bridge[i]=1;Pre[i]=i;
		}clean(Head,-1);Ecnt=0;
		for(int i=1;i<=m;++i){
			int x=Belong[a[i]],y=Belong[b[i]];
			if(x!=y){// x => y
				Add(x,y,1);Add(y,x,1);
			}
		}
		Deep[1]=1;DFS(1);
		int q;scanf("%d",&q);
		printf("Case %d:\n",++Case);
//		printf("Cnt= %d\n",Cnt);
		while(q--){
			int x,y;scanf("%d%d",&x,&y);
			int xx=Belong[x],yy=Belong[y];
			LCA(xx,yy);
			printf("%d\n",Cnt-1);
		}
	}
}

/*

4 4
1 2
2 3
2 3
1 4
3
2 3
1 2
1 4

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

*/