6362. 【NOIP2019模拟2019.9.18】数星星

题目

题目大意

给你一棵带点权的树和许多条路径。
然后有一堆询问，每次询问一段区间内所有路径的并的点权和。

---

思考历程

比赛时看到这题，已经没有什么时间了。
果断地打了个树链剖分加莫队，信心满满地觉得自己能过。
维护的时候类似于扫描线。
才打了20分钟。
在比赛的最后一刻，我突然意识到这个做法的时间复杂度非常大。
甚至不如暴力。
于是TLE了……

---

正解

其实题目有个比较显而易见的方法（然而我居然没有想到）。按照询问右端点排个序，在所有路径中从左到右扫。对于每个点，记录最后被覆盖的时间。
在树状数组维护每条边覆盖的点，并且这些点最后一次是被这条边覆盖的，满足这些条件的点的权值和。（也就是说，每个点向最后被覆盖的时间的那个位置，贡献它的点权）

现在考虑如何维护这个东西。

题解中有个比较奇妙的做法：
假设这棵树是一条链（如果不是一条链就树链剖分）。
现在每次要覆盖一个区间。
其实这就是一个区间染色的问题。每次覆盖的区间所有点的颜色必然就会被修改。
于是就可以用传说中的珂朵莉树……
其实题解也没有说是这个数据结构，不过实际上就是。
珂朵莉树的核心思想是，将相同状态的点合并成区间，一同处理。
至于具体实现，常规是用set，或者如果你喜欢也可以打平衡树或线段树之类的。每个节点维护的是一个相同状态的点组成的一个区间。
在平常的题目中，珂朵莉树要满是数据随机才可以达到$O(n\lg n)$的时间复杂度。但这题不一样。
在这题中，每个颜色相同的区间合在一起处理。在染色的时候，就要将这个区间覆盖的所有区间连同它们的贡献删去，再加入这个区间（相交的区间就分裂一下）。
显然，每次加入的区间新的区间个数是一个；并且它覆盖原来的区间之后，原来的那些区间都要被暴力删除，而它们只会被暴力删除一次。
所以这题的时间复杂度是有保障的，就是$O(n\lg n)$。
树链剖分之后时间复杂度要乘个$\lg n$。

或者还有一种非常简单的而且常数很小的方法：
直接上$LCT$。$LCT$上的每条链表示的是颜色相同的点（不过颜色相同的点不一定在同一条链里面），于是就可以将整条链的贡献在树状数组里面加加减减。
在修改的时候，求出$LCA$（不要用$LCT$直接求，因为在这里不是可以随便使用access的）。然后将$LCA$和它父亲的那条边断掉。
接着access(u)和access(v)。在$access$的过程中，同时在树状数组上进行修改。
时间复杂度也是$O(n{\lg }^{2}n)$，常数极小，代码简短。
提醒一下：这题是不能mroot的，因为mroot需要用到access，而access是不能随便用的。

还有一种强大的分治做法，不过常数似乎很大。
设当前的大区间为$[L,R]$。一个询问$[l,r]$可以分成：$[l,mid]$和$[mid+1,r]$两部分。
首先将$[L,R]$中的所有点建立一棵虚树。时间复杂度是$O(n\lg n)$的。
然后先处理$[mid+1,r]$的路径。显然我们只需要记录每个节点它最早出现的时间，因为询问区间是从中点向两边延伸的。
于是就用传统的并查集染色做法扫过去，并且用树状数组维护一下每一条路径能覆盖到了的所有新点的和。
右边处理完之后就处理左边。先将并查集清空，同样地用并查集染色的做法。不过这次染到的新点就要在树状数组中减去它的贡献，同时用一个变量来存它的贡献。
因为指针一直都往左边移，在左边出现过的就需要在右边加上了。
在这时候同时处理询问，就是用右边树状数组存下的值加上左边这个变量存下的值。
时间复杂度也是$O(n{\lg }^{2}n)$

---

代码

$LCT$做法

using namespace std;
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cassert>
#define N 100010
#define ll long long
int n,m,Q;
int a[N];
ll t[N];
#define lowbit(x) ((x)&-(x))
inline void add(int x,ll c){
	if (x<=0)
		return;
	for (;x<=m;x+=lowbit(x))
		t[x]+=c;
}
inline ll query(int x){
	ll res=0;
	for (;x;x-=lowbit(x))
		res+=t[x];
	return res;
}
struct Node *null;
struct Node{
	Node *fa,*c[2];
	int col;
	int val;
	ll sum;
	inline void upd(){sum=c[0]->sum+c[1]->sum+val;}
	inline bool getson(){return fa->c[0]!=this;}
	inline void rotate(){
		Node *y=fa,*z=y->fa;
		if (y->col)
			col=y->col,y->col=0;
		else
			z->c[y->getson()]=this;
		int k=getson();
		fa=z;
		y->c[k]=c[k^1],c[k^1]->fa=y;
		c[k^1]=y,y->fa=this;
		sum=y->sum,y->upd();
	}
	void splay(){
		for (;!col;rotate())
			if (!fa->col)
				getson()!=fa->getson()?rotate():fa->rotate();
	}
} d[N];
inline void cover(Node *x,int c){
	Node *y=null;
	for (;x!=null;y=x,x=x->fa){
		x->splay();
		x->c[1]->col=x->col;
		x->c[1]=y;
		add(y->col,-y->sum),add(x->col,y->sum);
		y->col=0;
		x->upd();
	}
	add(y->col,-y->sum);
	add(y->col=c,y->sum);
}
struct EDGE{
	int to;
	EDGE *las;
} e[N*2];
int ne;
EDGE *last[N];
int fa[N][17],dep[N];
void init(int x){
	dep[x]=dep[fa[x][0]]+1;
	for (int i=1;1<<i<dep[x];++i)
		fa[x][i]=fa[fa[x][i-1]][i-1];
	for (EDGE *ei=last[x];ei;ei=ei->las)
		if (ei->to!=fa[x][0])
			fa[ei->to][0]=x,init(ei->to);
}
inline int LCA(int u,int v){
	if (dep[u]<dep[v])
		swap(u,v);
	for (int k=dep[u]-dep[v],i=0;k;k>>=1,++i)
		if (k&1) u=fa[u][i];
	if (u==v) return u;
	for (int i=16;i>=0;--i)
		if (fa[u][i]!=fa[v][i])
			u=fa[u][i],v=fa[v][i];
	return fa[u][0];
}
struct Path{
	int u,v;
} p[N];
struct Oper{
	int l,r,num;
} o[N];
inline bool cmpo(const Oper &x,const Oper &y){return x.r<y.r;}
ll ans[N];
int main(){ 
	freopen("star.in","r",stdin);
	freopen("star.out","w",stdout);
	scanf("%d%d%d",&n,&m,&Q);
	null=d;
	*null={null,null,null,0,0,0};
	for (int i=1;i<=n;++i)
		scanf("%d",&a[i]);
	for (int i=1;i<n;++i){
		int u,v;
		scanf("%d%d",&u,&v);
		e[ne]={v,last[u]};
		last[u]=e+ne++;
		e[ne]={u,last[v]};
		last[v]=e+ne++;
	}
	init(1);
	for (int i=1;i<=n;++i)
		d[i]={&d[fa[i][0]],null,null,-1,a[i],a[i]};
	for (int i=1;i<=m;++i)
		scanf("%d%d",&p[i].u,&p[i].v);
	for (int i=1;i<=Q;++i)
		scanf("%d%d",&o[i].l,&o[i].r),o[i].num=i;
	sort(o+1,o+Q+1,cmpo);
	for (int i=1,j=1;i<=m;++i){
		int u=p[i].u,v=p[i].v,lca=LCA(u,v);
		Node *anc;
		d[lca].splay();
		if (d[lca].c[0]!=null){
			anc=&d[fa[lca][0]];
			anc->splay();
			anc->c[1]=null;
			anc->upd();
			d[lca].col=anc->col;
		}
		else
			anc=d[lca].fa;
		d[lca].fa=null;
		cover(&d[u],i),cover(&d[v],i);
		d[lca].splay();
		d[lca].fa=anc;
		for (;j<=Q && o[j].r<=i;++j)
			ans[o[j].num]=query(o[j].r)-query(o[j].l-1);
	}
	for (int i=1;i<=Q;++i)
		printf("%lld\n",ans[i]);
	return 0;
}

---

总结

$LCT$真是太好打了……
看到类似于染色的题目，不要忘了$LCT$啊……