P2147 [SDOI2008]洞穴勘测 并查集&分治

题目描述
辉辉热衷于洞穴勘测。

某天，他按照地图来到了一片被标记为JSZX的洞穴群地区。经过初步勘测，辉辉发现这片区域由n个洞穴（分别编号为1到n）以及若干通道组成，并且每条通道连接了恰好两个洞穴。假如两个洞穴可以通过一条或者多条通道按一定顺序连接起来，那么这两个洞穴就是连通的，按顺序连接在一起的这些通道则被称之为这两个洞穴之间的一条路径。 洞穴都十分坚固无法破坏，然而通道不太稳定，时常因为外界影响而发生改变，比如，根据有关仪器的监测结果，123号洞穴和127号洞穴之间有时会出现一条通道，有时这条通道又会因为某种稀奇古怪的原因被毁。

辉辉有一台监测仪器可以实时将通道的每一次改变状况在辉辉手边的终端机上显示：

如果监测到洞穴u和洞穴v之间出现了一条通道，终端机上会显示一条指令 Connect u v

如果监测到洞穴u和洞穴v之间的通道被毁，终端机上会显示一条指令 Destroy u v

经过长期的艰苦卓绝的手工推算，辉辉发现一个奇怪的现象：无论通道怎么改变，任意时刻任意两个洞穴之间至多只有一条路径。

因而，辉辉坚信这是由于某种本质规律的支配导致的。因而，辉辉更加夜以继日地坚守在终端机之前，试图通过通道的改变情况来研究这条本质规律。 然而，终于有一天，辉辉在堆积成山的演算纸中崩溃了……他把终端机往地面一砸（终端机也足够坚固无法破坏），转而求助于你，说道：“你老兄把这程序写写吧”。

辉辉希望能随时通过终端机发出指令 Query u v，向监测仪询问此时洞穴u和洞穴v是否连通。现在你要为他编写程序回答每一次询问。 已知在第一条指令显示之前，JSZX洞穴群中没有任何通道存在。

输入格式
第一行为两个正整数n和m，分别表示洞穴的个数和终端机上出现过的指令的个数。 以下m行，依次表示终端机上出现的各条指令。每行开头是一个表示指令种类的字符串s（"Connect”、”Destroy”或者”Query”，区分大小写），之后有两个整数u和v (1≤u, v≤n) 分别表示两个洞穴的编号。

输出格式
对每个Query指令，输出洞穴u和洞穴v是否互相连通：是输出”Yes”，否则输出”No”。（不含双引号）

输入输出样例
输入 #1 复制
200 5
Query 123 127
Connect 123 127
Query 123 127
Destroy 127 123
Query 123 127
输出 #1 复制
No
Yes
No
输入 #2 复制
3 5
Connect 1 2
Connect 3 1
Query 2 3
Destroy 1 3
Query 2 3
输出 #2 复制
Yes
No
说明/提示
数据说明

10%的数据满足n≤1000, m≤20000

20%的数据满足n≤2000, m≤40000

30%的数据满足n≤3000, m≤60000

40%的数据满足n≤4000, m≤80000

50%的数据满足n≤5000, m≤100000

60%的数据满足n≤6000, m≤120000

70%的数据满足n≤7000, m≤140000

80%的数据满足n≤8000, m≤160000

90%的数据满足n≤9000, m≤180000

100%的数据满足n≤10000, m≤200000

保证所有Destroy指令将摧毁的是一条存在的通道

本题输入、输出规模比较大，建议c\c++选手使用scanf和printf进行I\O操作以免超时

题解：（离线）
首先，题目要求的是两点连通性，即用并查集维护。
但又需支持删除操作，这就需要一些技巧。
①暴力：
对于每个操作u,v，设fa_x是u的连通块的根，把fa_x到u的链的边全部取反，即可使u成为根，
在根上操作。
时间复杂度O(nm)。但数据随机，平均下来可以过。。。巨短无比QAQ
代码来源 @spli

   #include <cstdio>
    using namespace std;
    #define read(a) a=getnum()
    inline int getnum() { int ret=0; char c; for(c=getchar(); c<'0' || c>'9'; c=getchar()); for(; c>='0' && c<='9'; c=getchar()) ret=ret*10+c-'0'; return ret; }
    const int N=10005;
    int n, m, u, v, f[N];
    inline void sroot(int x) { for(int c=0, fa=f[x]; x; fa=f[x]) { f[x]=c; c=x; x=fa; } }
    int main() {
        read(n); read(m); char c;
        for(int i=0; i<m; ++i) {
            for(c=getchar(); c<'A'||c>'Z'; c=getchar());
            read(u); read(v);
            sroot(u);
            if(c=='C') f[u]=v;
            else if(c=='D') f[v]=0;
            else {
                for(; v!=u && v; v=f[v]);
                puts(v==u?"Yes":"No");
            }
        }
        return 0;
}

②正解：
需要支持删除，那就需要保存合并之前的状态，而每条边在时间上覆盖是一段区间，又为了避免额外的操作，于是可以想到对时间进行分治，这样区间中每次增删就只有一次了，优秀！
或者可以这样理解，在每次合并之后，删除之前，只对当前区间之内有影响，对区间划分不是分块就是分治，这道题显然就是分治。
注意 @abcde
保存合并前状态的栈应开全局，不然会MLE。
代码来源 zhanghongyu

#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<cstdio>
#include<stack>
#include<vector>
#include<map>
#define M 200005
#define N 100005
#define map_int map<pair<int, int>, int >::iterator 
#define vector_int vector<pair<int, int> >::iterator 
using namespace std;
int n,m,fa[N],size[N];
int ans[M],quer[M][4];
map<pair<int, int>, int> ti;
struct State
{
	int x,y,size_x,size_y;
};
stack<State> state;
struct node	
{
	int l,r;

	vector<pair<int, int> > q;
}t[M*4];
int get(int x){
	if(fa[x]==x)return x;
	return get(fa[x]);
}
void build(int p,int l,int r){
	t[p].l=l;t[p].r=r;
	if(l==r)return ;
	int mid=(l+r)>>1;
	build(p*2,l,mid);build(p*2+1,mid+1,r);
}
void insert(int p,int u,int v,int begi,int en){
	if(t[p].l>=begi&&t[p].r<=en){
		t[p].q.push_back(make_pair(u,v));
		//cout<<p<<endl;
		return ;
	}
	int mid=(t[p].l+t[p].r)>>1;
	if(begi<=mid)insert(p*2,u,v,begi,en);
	if(en>mid)insert(p*2+1,u,v,begi,en);
}
State merge(pair<int, int> t){
	int x=t.first,y=t.second,fa_x=get(x),fa_y=get(y);
	if(size[fa_x]>size[fa_y])swap(fa_x,fa_y);
	State p=State{fa_x,fa_y,size[fa_x],size[fa_y]};
	fa[fa_x]=fa_y;size[fa_y]+=size[fa_x];
	return p;
}
void undo(State t){
	fa[t.x]=t.x;
	size[t.y]=t.size_y;
}
void dfs(int p,vector_int it_q){
    if(it_q!=t[p].q.end()){
		pair<int, int> q=*it_q;
		State t=merge(q);
		dfs(p,++it_q);
		undo(t);
		return;
	}
	if(t[p].l==t[p].r){
		if(quer[t[p].l][0]){
			ans[t[p].l]=get(quer[t[p].l][1])==get(quer[t[p].l][2])?1:2;
		}
		return ;
	}
	dfs(p*2,t[p*2].q.begin());
	dfs(p*2+1,t[p*2+1].q.begin());
	
}
int main()
{
	scanf("%d%d",&n,&m);
	build(1,1,m);
	for(int i=1;i<=n;i++){fa[i]=i;size[i]=1;}
	for(int i=1;i<=m;i++){
		char str[10];int x,y;
		scanf("%s%d%d",str,&x,&y);
		if(x>y)swap(x,y);
		if(str[0]=='C'){
			ti.insert(make_pair(make_pair(x,y),i));
		}else{
			if(str[0]=='D'){
				map_int it=ti.find(make_pair(x,y));
				pair<pair<int, int>, int> p=*it;
				int u=p.first.first,v=p.first.second,begi=p.second;
				//cout<<begi<<" "<<i<<endl;
				insert(1,u,v,begi,i);
				ti.erase(it);
		    }else{
		    	quer[i][0]=1;
		    	quer[i][1]=x;quer[i][2]=y;
		    }
		}
	}
	for(map_int it=ti.begin();it!=ti.end();it++){
		pair<pair<int, int>, int> p=*it;
		int u=p.first.first,v=p.first.second,begi=p.second;
		insert(1,u,v,begi,m);
	}
	dfs(1,t[1].q.begin());
	for(int i=1;i<=m;++i){
		if(ans[i]==1)printf("Yes\n");
		if(ans[i]==2)printf("No\n");
	}
	return 0;
}/*
200    5
Query    123    127
Connect    123    127
Query    123    127
Destroy    127    123
Query    123    127
*/