线段树分治-优快云博客

线段树分治是说，我有很多个区间的信息，我最后想知道每个点的一些信息，那我可以用线段树划分区间的思路，把一个作用于 $[l, r]$ 的操作拆成 $l o g k$ 个区间，然后保存在这些区间的节点里，然后我们直接遍历整颗线段树，到达一个节点，就执行这个节点里的操作，递归返回时再撤销这个结点的操作。递归到叶子，就是到达一个点，且可以覆盖这个点的所有操作都已经执行完毕了，直接查询信息生成答案。

这个区间也能转化为时间轴，具体表现就是可以给出一个插入和删除边的顺序，这就相当于一个边的存在时间是时间轴上的一个区间，然后我们可能是要求每次插入后的答案，那我们可以在时间轴上建树，最后递归到叶子节点，就是某个时刻的答案

可以注意到这需要我们有一个支持撤销的ds，所以线段树分治往往就和可撤销并查集之类的问题集合起来

struct DSU{
    int n = 0, tot = 0, fa[N], sz[N], s[N];
    void ins(){n++, fa[n] = n, sz[n] = 1;}//插入节点
    int F(int x){return fa[x] == x? x : F(fa[x]);}//即find查找函数
    void U(int x, int y){//合并函数
        x = F(x), y = F(y);
        if(x == y) return;
        if(sz[x] < sz[y]) swap(x, y);
        s[++tot] = y, fa[y] = x, sz[x] += sz[y];
    }
    void D(){//删除栈顶边
        if(!tot) return;
        int y = s[tot--]; sz[fa[y]] -= sz[y], fa[y] = y;
    }
    void back(int t = 0){while(tot > t) D();}//删除到只剩t条边
}dsu;
void solve(){
	int n,m,k;
	cin>>n>>m>>k;
	vvi tr(4*k+1);
	vi x(m+1),y(m+1),l(m+1),r(m+1);

	auto &&upd=[&](auto &&upd,int ql,int qr,int l,int r,int val,int idx)->void{
		//cout<<l<<' '<<r<<'\n';
		if(ql<=l&&r<=qr){
			tr[idx].push_back(val);
			return;
		}
		int mid=l+r>>1;
		if(ql<=mid)upd(upd,ql,qr,l,mid,val,idx<<1);
		if(qr>mid)upd(upd,ql,qr,mid+1,r,val,idx<<1|1);
	};
	rep(i,1,m){
		cin>>x[i]>>y[i]>>l[i]>>r[i];
		upd(upd,l[i]+1,r[i],1,k,i,1);
	}
	
	rep(i,1,2*n)dsu.ins();
	vi ans;
	
	auto &&work=[&](auto &&work,int u,int l,int r)->void{
		int level=dsu.tot;
		//cout<<l<<' '<<r<<'\n';
		bool ok=1;
		for(int idx:tr[u]){
			int fx=dsu.F(x[idx]);
			int fy=dsu.F(y[idx]);
			if(fx==fy){
				//cout<<l<<' '<<r<<'\n';
				rep(i,l,r){
					ans.push_back(0);
				}
				ok=0;
				break;
			}
			dsu.U(x[idx],y[idx]+n);
			dsu.U(y[idx],x[idx]+n);
		}
		if(ok){
			if(l==r){
				//cout<<l<<' '<<r<<'\n';
				ans.push_back(1);
			}			
			else{
				int mid=l+r>>1;
				work(work,u<<1,l,mid);
				work(work,u<<1|1,mid+1,r);
			}
		}
		dsu.back(level);
	};
	work(work,1,1,k);
	for(int x:ans){
		if(x)cout<<"Yes\n";
		else cout<<"No\n";
	}
}