【Ynoi2011】成都七中【树论】【点分树】【离线】【树状数组】

题意：给一棵树，点有颜色，$q$ 次询问，每次给定 $l,r,x$ ，求只保留编号在 $[l,r]$ 中的点时点 $x$ 所在连通块的颜色数。

所有数 $\le 10^5$

题目背景好评

首先所有颜色不同的话就是数连通块大小，先想想这个怎么做。

然后不会做，拜拜了您嘞

---

考察所求的 $x$ 所在连通块在点分治中的过程，这个连通块一直是完整的直到一个分治中心踩到了这个连通块中的一个点。建出点分树后，我们预处理每个点 与所有点分树上的祖先在原树上的路径经过的点编号的最小值与最大值，然后每个询问把 $x$ 暴力跳祖先就可以找到这个点。

这个点点分树上的子树的点包含了所求的连通块，且这个点在连通块内。对于子树内的点，它在连通块内当且仅当到子树的根的路径的编号范围被询问区间完全包含。所以对每个点 dfs 一遍子树，然后就是喜闻乐见的主对角线矩形数颜色问题。

把询问离线（这道题里面本来就是离线的）挂在右端点上，然后移动右端点，维护每种颜色的点的左端点的最大值，树状数组上加一下就可以了。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cctype>
#include <vector>
#include <algorithm>
#define MAXN 100005
using namespace std;
const int INF=0x7fffffff;
inline int read()
{
	int ans=0;
	char c=getchar();
	while (!isdigit(c)) c=getchar();
	while (isdigit(c)) ans=(ans<<3)+(ans<<1)+(c^48),c=getchar();
	return ans;
}
int col[MAXN];
struct node{int l,r,val;};
//ancestor: val=the index of the ancestor
//son: val=the color of the son
//query: val=the index of the query  
vector<int> e[MAXN];
vector<node> p[MAXN],s[MAXN],q[MAXN];
int rt,siz[MAXN],maxp[MAXN],vis[MAXN];
void findrt(int u,int f,int sum)
{
	siz[u]=1,maxp[u]=0;
	for (int i=0;i<(int)e[u].size();i++)
		if (!vis[e[u][i]]&&e[u][i]!=f)
		{
			findrt(e[u][i],u,sum);
			siz[u]+=siz[e[u][i]];
			maxp[u]=max(maxp[u],siz[e[u][i]]);
		}
	maxp[u]=max(maxp[u],sum-siz[u]);
	if (maxp[u]<maxp[rt]) rt=u;
}
void dfs(int u,int f,int l,int r)
{
	p[u].push_back((node){l,r,rt});
	s[rt].push_back((node){l,r,col[u]});
	siz[u]=1;
	for (int i=0;i<(int)e[u].size();i++)
		if (!vis[e[u][i]]&&e[u][i]!=f)
		{
			dfs(e[u][i],u,min(l,e[u][i]),max(r,e[u][i]));
			siz[u]+=siz[e[u][i]];
		}
}
void build()
{
	vis[rt]=1;
	dfs(rt,0,rt,rt);
	int u=rt;
	for (int i=0;i<(int)e[u].size();i++)
		if (!vis[e[u][i]])
		{
			rt=0,findrt(e[u][i],0,siz[e[u][i]]);
			build();
		}
}
const int N=1e5;
struct BIT
{
	int s[MAXN];
	inline int lowbit(const int& x){return x&-x;}
	inline void modify(int x,int v){for (;x<=N;s[x]+=v,x+=lowbit(x));}
	inline int query(int x,int ans=0){for (;x;ans+=s[x],x-=lowbit(x));return ans;}
}bit;
int mx[MAXN];
vector<node> tf[MAXN],tq[MAXN];
vector<int> lis;
int ans[MAXN];
int main()
{
	maxp[0]=INF;
	int n,m;
	n=read(),m=read();
	for (int i=1;i<=n;i++) col[i]=read();
	for (int i=1;i<n;i++) 
	{
		int u,v;
		u=read(),v=read();
		e[u].push_back(v),e[v].push_back(u);
	}
	findrt(1,0,n),build();
	for (int T=1;T<=m;T++)
	{
		int l,r,x;
		l=read(),r=read(),x=read();
		for (int i=0;i<(int)p[x].size();i++)
			if (l<=p[x][i].l&&p[x][i].r<=r)
			{
				q[p[x][i].val].push_back((node){l,r,T});
				break;
			}
	}
	for (int u=1;u<=n;u++)
	{
		lis.clear();
		for (int i=0;i<(int)s[u].size();i++)
			tf[s[u][i].r].push_back(s[u][i]),lis.push_back(s[u][i].r);
		for (int i=0;i<(int)q[u].size();i++)
			tq[q[u][i].r].push_back(q[u][i]),lis.push_back(q[u][i].r);
		sort(lis.begin(),lis.end());
		lis.erase(unique(lis.begin(),lis.end()),lis.end());
		for (int t=0;t<(int)lis.size();t++)
		{
			int r=lis[t];
			for (int i=0;i<(int)tf[r].size();i++)
				if (tf[r][i].l>mx[tf[r][i].val])
				{
					if (mx[tf[r][i].val]) bit.modify(mx[tf[r][i].val],-1);
					bit.modify(mx[tf[r][i].val]=tf[r][i].l,1);
				}
			for (int i=0;i<(int)tq[r].size();i++)
				ans[tq[r][i].val]=bit.query(r)-bit.query(tq[r][i].l-1);
		}
		for (int i=0;i<(int)s[u].size();i++)
		{
			if (mx[s[u][i].val]) bit.modify(mx[s[u][i].val],-1);
			mx[s[u][i].val]=0;
		}
		for (int i=0;i<(int)lis.size();i++) tf[lis[i]].clear(),tq[lis[i]].clear();
	}
	for (int i=1;i<=m;i++) printf("%d\n",ans[i]);
	return 0;
}