[学习笔记]dsu on a tree（如何远离线段树合并）

https://www.zybuluo.com/ysner/note/1318613

背景

这玩意来源于一种有局限性的算法。

有一种广为人知的，树上离线维护子树信息的做法。

（可以参照luogu3605 [USACO17JAN]Promotion Counting晋升者计数)

用树状数组维护贡献，并把询问挂在点上。

先遍历整棵树。

在进入一个点时，在询问中，把以这个点为根的子树以外的贡献减掉，再遍历这棵树。

当一个点的子树遍历完时，再在树状数组中加上当前点的贡献，并在询问中加上当前所有已遍历部分的贡献。

（这样询问中恰好存有该子树的贡献）

复杂度\(O(nlogn)\)。

看起来很棒棒啊。

这样可以避免线段树的大常数、大码量和大空间。

定义

然而有一种情况，是以上方法不能处理的。

就是不同子树间的信息相互干扰。

所以考虑把树重链剖分一下。

然后父结点只继承它的重儿子的信息，子树其它部分重新统计。

算完后，如果这个点是其父亲的轻儿子，就把贡献清空，否则不管。

这样也能维护子树信息。

这样复杂度为\(O(nlog^2n)\)。

例题

HDU 5709 Claris Loves Painting（离线版本）

求子树中深度不超过\(dep[u]+D\)的颜色种类数。

考虑一下背景里提到的方法。

\(NO\),遍历完这棵子树后的答案\(-\)遍历完这棵子树前的答案\(!=\)这棵子树的答案。

所以老老实实\(dsu\ on\ a\ tree\)吧。

把询问挂在点上，就按照定义里的方法去搞就行。

有点麻烦的地方是如何维护当前状态下，某种颜色是否存在。

这个吗。。。

拿一个数组维护每种颜色的最浅深度，如果把最浅深度的该颜色点排除了，这种颜色就没了。

为什么可以这样？

因为越浅的点排除越晚。

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<vector>
#define ll long long
#define re register
#define il inline
#define mk make_pair
#define pb push_back
#define fi first
#define se second
#define fp(i,a,b) for(re int i=a;i<=b;++i)
#define fq(i,a,b) for(re int i=a;i>=b;--i)
using namespace std;
const int N=1e5+100;
int n,m,h[N],cnt,col[N],mn[N],son[N],sz[N],d[N],ans[N],t[N];
vector<pair<int,int> >V[N];
struct Edge{int to,nxt;}e[N<<1];
il void add(re int u,re int v){e[++cnt]=(Edge){v,h[u]};h[u]=cnt;}
il void Modify(re int x,re int w){for(;x<=n;x+=x&-x) t[x]+=w;}
il int Query(re int x){re int res=0;for(;x;x^=x&-x) res+=t[x];return res;}
il int gi()
{
  re int x=0,t=1;
  re char ch=getchar();
  while(ch!='-'&&(ch<'0'||ch>'9')) ch=getchar();
  if(ch=='-') t=-1,ch=getchar();
  while(ch>='0'&&ch<='9') x=x*10+ch-48,ch=getchar();
  return x*t;
}
il void pre(re int u,re int fa)//找出重儿子
{
  sz[u]=1;d[u]=d[fa]+1;
  for(re int i=h[u];i;i=e[i].nxt)
    {
      re int v=e[i].to;
      pre(v,u);
      sz[u]+=sz[v];
      if(sz[son[u]]<sz[v]) son[u]=v;
    }
}
il void Add(re int x,re int d)//加入新的点，更新颜色最浅深度
{
  if(!mn[x]||mn[x]>d)
    {
      if(mn[x]) Modify(mn[x],-1);
      Modify(mn[x]=d,1);
    }
}
il void clear(re int u)//去除该点，排除该点颜色的影响
{
  if(mn[col[u]]==d[u]) Modify(mn[col[u]],-1),mn[col[u]]=0;
  for(re int i=h[u];i;i=e[i].nxt)
    {
      re int v=e[i].to;
      clear(v);
    }
}
il void upd(re int u)//暴力统计轻儿子子树部分的信息
{
  Add(col[u],d[u]);
  for(re int i=h[u];i;i=e[i].nxt)
    {
      re int v=e[i].to;
      upd(v);
    }
}
il void dfs(re int u,re int tag)
{
  for(re int i=h[u];i;i=e[i].nxt)
    {
      re int v=e[i].to;
      if(v^son[u]) dfs(v,0);
    }//处理轻儿子的答案
  if(son[u]) dfs(son[u],1);//继承重儿子信息
  Add(col[u],d[u]);
  for(re int i=h[u];i;i=e[i].nxt)
    {
      re int v=e[i].to;
      if(v^son[u]) upd(v);
    }//重新统计轻儿子部分信息
  re int sz=V[u].size();
  fp(i,0,sz-1) ans[V[u][i].se]=Query(min(n,d[u]+V[u][i].fi));//回答询问
  if(!tag) clear(u);
}
int main()
{
  n=gi();m=gi();
  fp(i,1,n) col[i]=gi();
  fp(i,2,n)
    {
      re int u=gi(),v=i;
      add(u,v);
    }
  fp(i,1,m)
    {
      re int u=gi(),d=gi();
      V[u].pb(mk(d,i));
    }
  pre(1,1);
  dfs(1,1);
  fp(i,1,m) printf("%d\n",ans[i]);
  return 0;
}