[APIO2019]桥梁

Description

给出一张n个点m条边的图，每条边有边权di
有q次操作，第i次操作会修改一条边的边权，或者问从点x出发，只经过边权>=y的边，能到达多少个点
n<=50000,m,q<=10^5

Solution

数据结构学傻了.jpg
考虑对操作分块，我们只考虑一段操作带来的影响
将这个操作块内的询问和修改分开，将询问按权值排序，将所有边按边权排序，先不考虑修改操作的边
依次枚举每个询问，将边权>=询问权值的边加入并查集中，再枚举每个修改，将修改涉及的边中满足条件的边加入并查集中，然后将这些边撤销
然后修改所涉及边的边权并重新排序
设块大小为k，由于每块我们都要枚举所有边所以这里是O(q/km)的
然后后面暴力枚举的复杂度是O(qklog n)的，因为要撤销只能按秩合并
重新排序我们只需要对呗修改到的边重新排序即可，然后归并两个序列就不用log了
平衡规划一下复杂度可以达到O($q\sqrt{mlogn}$)

Code

#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,a,b) for(int i=a;i>=b;i--)
#define mp(a,b) make_pair(a,b)
using namespace std;

int read() {
	char ch;
	for(ch=getchar();ch<'0'||ch>'9';ch=getchar());
	int x=ch-'0';
	for(ch=getchar();ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x;
}

const int N=1e5+5,M=555;

struct Edge{int x,y,d,id;}e[N],e1[N],e2[N];
bool cmp(Edge a,Edge b) {return a.d>b.d;}

struct Ar{int x,y,id;};

int n,m,u[N],v[N],d[N],tmp[N],apply[N],an[N];

vector<Ar> mdf,ask;
bool cmp1(Ar a,Ar b) {return a.y>b.y;}

struct DSU{
	int fa[N],rk[N],sz[N],opt[N*3],top;
	pair<int,int> sta[N*3];

	void clear() {fo(i,1,n) fa[i]=rk[i]=0,sz[i]=1;top=0;}

	int get(int x) {return fa[x]?get(fa[x]):x;}

	void merge(int x,int y) {
		x=get(x);y=get(y);
		if (x==y) return;
		if (rk[x]<rk[y]) swap(x,y);
		opt[++top]=0;sta[top]=mp(y,fa[y]);fa[y]=x;
		opt[++top]=1;sta[top]=mp(x,sz[y]);sz[x]+=sz[y];
		if (rk[x]==rk[y]) rk[x]++,opt[++top]=2,sta[top]=mp(x,0);
	}

	void down(int now) {
		for(;top>now;top--) {
			if (opt[top]==0) fa[sta[top].first]=sta[top].second;
			if (opt[top]==1) sz[sta[top].first]-=sta[top].second;
			if (opt[top]==2) rk[sta[top].first]--;
		}
	}
}dsu;

int main() {
	n=read();m=read();
	fo(i,1,m) {
		e[i].x=u[i]=read(),e[i].y=v[i]=read();
		e[i].d=d[i]=tmp[i]=read(),e[i].id=i;
	}
	sort(e+1,e+m+1,cmp);
	for(int ca=read();ca;) {
		int q=min(ca,M);ca-=q;
		fo(i,1,q) {
			int opt=read(),x=read(),y=read();
			if (opt==1) {
				mdf.push_back((Ar){x,y,i});
				apply[x]=y;
			} 
			if (opt==2) ask.push_back((Ar){x,y,i});
			an[i]=0;
		}
		sort(ask.begin(),ask.end(),cmp1);
		dsu.clear();
		int j=0;
		for(auto i:ask) {
			int y=i.y,x=i.x,id=i.id;
			while (j<m&&e[j+1].d>=y) {
				++j;
				if (!apply[e[j].id]) dsu.merge(e[j].x,e[j].y);
			}
			int now=dsu.top;
			for(auto k:mdf) if (k.id<id) d[k.x]=k.y;
			for(auto k:mdf) if (d[k.x]>=y) dsu.merge(u[k.x],v[k.x]);
			for(auto k:mdf) if (k.id<id) d[k.x]=tmp[k.x];
			an[id]=dsu.sz[dsu.get(x)];
			dsu.down(now);
		}
		fo(i,1,q) if (an[i]) printf("%d\n",an[i]);
		int t1=0,t2=0;
		fo(i,1,m) {
			if (!apply[e[i].id]) e1[++t1]=e[i];
			else e2[++t2]=e[i],e2[t2].d=apply[e[i].id];
		}
		sort(e2+1,e2+t2+1,cmp);
		int i=1,k=0;j=1;
		while (i<=t1&&j<=t2) {
			if (e1[i].d>e2[j].d) e[++k]=e1[i++];
			else e[++k]=e2[j++];
		}
		while (i<=t1) e[++k]=e1[i++];
		while (j<=t2) e[++k]=e2[j++];
		for(auto k:mdf) d[k.x]=tmp[k.x]=k.y,apply[k.x]=0;
		mdf.clear();ask.clear();
	}
	return 0;
}