[APIO2019] [LOJ 3145] 桥梁(分块+并查集)(有详细注释)

[APIO2019] [LOJ 3145] 桥梁(分块+并查集)(有详细注释)

题面

略

分析

考试的时候就感觉子任务4是突破口，结果却写了个Kruskal重构树，然后一直想怎么在线用数据结构维护

实际上是离线算法。考虑只有查询的时候。我们可以离线对查询的权值从大到小排序，边也按边权从大到小排序，然后对于权值比询问大的边，把边两端结点集合合并。答案就是查询点所在点集的大小。只需要用并查集维护，然后双指针扫描，由于一条边只会被加进去一次，时间复杂度为$ O(n\log n)$

考虑有修改的情况。所以我们可以对查询分块(按时间每B个询问分为一块)，然后对每个块里的询问按上述方法暴力维护。最后还要更新块内修改操作，因为这些修改会对下一块有影响。注意修改会影响点集联通情况，用可撤销的并查集维护。.（因为每次操作都要把m条边扫描一遍）.总复杂度\(O(q\sqrt {q \log n} )\)

细节较多，注释见代码

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#define maxn 500000
#define maxm 1000000
#define bsz 1000
using namespace std;
inline void qread(int &x){
	x=0;
	int sign=1;
	char c=getchar();
	while(c<'0'||c>'9'){
		if(c=='-') sign=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9'){
		x=x*10+c-'0';
		c=getchar();
	}
	x=x*sign;
}
inline void qprint(int x){
	if(x<0){
		putchar('-');
		qprint(-x);
	}else if(x==0){
		putchar('0');
		return;
	}else{
		if(x>=10) qprint(x/10);
		putchar(x%10+'0');
	}
}

int n,m,q;
struct edge{
	int from;
	int to;
	int val;
	int id;
}E[maxm+5];

int fa[maxn+5];
int sz[maxn+5];
int find(int x){
//	printf("%d\n",x);
	if(fa[x]==x) return x;
	else return find(fa[x]);
}
void ini(int n){
	for(int i=1;i<=n;i++){
		fa[i]=i;
		sz[i]=1;
	}
}
int bel[maxn+5];
int lastx[maxm+5],lasty[maxm+5];//用于记录并查集之前状态，回滚时用
void merge(int id){
	int x=E[id].from;
	int y=E[id].to;
	int fx=find(x),fy=find(y);
	if(fx!=fy){
		if(sz[fx]>sz[fy]) swap(fx,fy);
		lastx[id]=fx;
		lasty[id]=fy;
		fa[fx]=fy;
		sz[fy]+=sz[fx];
	}
}

struct oper{
	int type;
	int x;
	int val;
}in[maxn+5];
struct query{//询问
	int id;
	int x;
	int val;
	query(){

	}
	query(int _id,int _x,int _val){
		id=_id;
		x=_x;
		val=_val;
	}
	friend bool operator < (query p,query q){
		return p.val>q.val;
	}
};
vector<query>Q;
struct update{//需要合并的边
	int id;
	int val;
	update(){

	}
	update(int _id,int _val){
		id=_id;
		val=_val;
	}
	friend bool operator < (update p,update q){
		return p.val>q.val;
	}
};
int ans[maxn+5];
bool vis[maxn+5];//标记哪些边的边权需要修改
bool tmp[maxn+5];//标记当前块需要修改的边
vector<update>U1;//不需要修改，但是需要合并的边
vector<int>U2;//需要修改，需要合并的边
vector<int>back;//回滚用
void rebuild(int last){
	for(int i=1;i<=m;i++){
		U1.push_back(update(i,E[i].val));
		lastx[i]=0;
	}
	ini(n);
	sort(U1.begin(),U1.end());
	sort(Q.begin(),Q.end());
	for(int i=0,j=0;i<Q.size();i++){////遍历每个询问
		back.clear();
		while(j<U1.size()&&U1[j].val>=Q[i].val){//双指针找出可以经过的边
			if(!vis[U1[j].id]){
				merge(U1[j].id);
				lastx[U1[j].id]=0;//不需要回滚
			}
			j++;
		}
		for(int p=last;p<Q[i].id;p++){
			if(in[p].type==1) tmp[in[p].x]=1;
		}
		for(int p=0;p<U2.size();p++){//修改前边权比当前询问要大，
		//由于在后续可能涉及修改，需要进行回滚
			if(!tmp[U2[p]]&&Q[i].val<=E[U2[p]].val){
				merge(U2[p]);
				back.push_back(U2[p]);
			}
		}
		for(int p=Q[i].id;p>=last;p--){
		//查询时序之前被修改了，并且修改后边权比当前查询负载要大
        //注意：只有修改后边权比当前查询大的边才会进行合并，所以通过from[s[p]]=-1在回撤时过滤掉不符合要求的边
			if(in[p].type==1) tmp[in[p].x]=0;//回滚tmp数组
			if(in[p].type==2||lastx[in[p].x]) continue;//跳过query
			lastx[in[p].x]=-1;
			back.push_back(in[p].x);
			if(in[p].val>=Q[i].val) merge(in[p].x);//如果修改后变得对答案有影响，就合并
		}
		ans[Q[i].id]=sz[find(Q[i].x)];
		for(int p=back.size()-1;p>=0;p--){//回滚
			if(lastx[back[p]]!=-1){
				sz[lasty[back[p]]]-=sz[lastx[back[p]]];
				fa[lastx[back[p]]]=lastx[back[p]];
			}
			lastx[back[p]]=0;
		}
	}
}
int main(){
	qread(n);
	qread(m);
	for(int i=1;i<=m;i++){
		qread(E[i].from);
		qread(E[i].to);
		qread(E[i].val);
		E[i].id=i;
	}
	qread(q);
	for(int i=1;i<=q;i++) bel[i]=i/bsz+1;
	int last=1;
	for(int i=1;i<=q;i++){
		qread(in[i].type);
		qread(in[i].x);
		qread(in[i].val);
		if(in[i].type==1){
			if(!vis[in[i].x]) U2.push_back(in[i].x);
			vis[in[i].x]=1;
		}else{
			Q.push_back(query(i,in[i].x,in[i].val));
		}
		if(bel[i]!=bel[i+1]){
			///存满一个块，进行一次离线操作
			rebuild(last);
			while(last<=i){//last记录修改和查询到哪里
				vis[in[last].x]=0;
				if(in[last].type==1) E[in[last].x].val=in[last].val;
				else{
					qprint(ans[last]);
					putchar('\n');
				}
				last++;
			}
			U1.clear();
			U2.clear();
			Q.clear();
			back.clear();
		}

	}
}