树上分块
大部分时候，树上问题是由树剖，LCT，树分治来解决。但在某些情况下(比如你根本想不到这玩意该怎么搞的时候，或者有时数据宽松)，树分块也是一种选择。
概述
和序列分块一样，树分块也是一种暴力。大致思想仍是将将树按“某种思路”划分进数个块中，然后维护块内整体信息的算法。
根据不同的题目，“某种思路”各不相同。一般情况下，树分块在处理树的路径等具有联通性质问题的时候表现强劲。
树上分块的方法很多，接下来介绍几种常用的方法。
dfs序分块法
如题所述，我们大力求树的 dfs 序，然后对 dfs 序进行分块，处理子树信息效果不错，但是不保证块内直径长度和联通性。
Size分块法
检查当前父节点所在块的大小，如果 (<sqrt n) 就把当前节点加进去，如果不然就新开一个块。块大小最大 (sqrt n) ，同时保证块内联通和直径大小。但是不保证块的数量(某种菊花图可以卡这玩意)。
给定一棵树，树上每个点有一个权值，需要支持修改点权和查路径最小值。
用这个方法分块，然后对每个点统计它到块内最浅的点的答案。
查询的时候将路径拆成按 (lca) 两部分，再将两部分拆成数块，统计即可。
注意LCA会多出一个零散块。
修改直接修改块内统计信息即可。
关键点法(树上撒点)
设置一个阈值 (S) ，随机找 (frac{n}{S}) 个关键点，使得每个关键点到离它最近的祖先关键点的距离不超过 (S)。对于所有点找到它的第一个关键祖先，将它和关键祖先分为一块。可以保证块联通，期望直径长度为 (S)，块大小为 (frac{n}{S})，但是常数较大。
-
( (From) 神犇 (color{#A0F}{mrsrz}) ) 确定性算法：严格保证每个关键点到离它最近的祖先关键点的距离。
我们每次选择一个深度最大的非关键点，如果这个点的 (1sim S) 级祖先都不是关键点，那么把它的 (S) 级祖先设为关键点。由这个过程可知，距离不会超过 (x)。并且每标记一个关键点，至少有 (S) 个点不会被标记。关键点数量也是对的。
Count on a tree II
给定一棵 (n) 节点的树，树上节点带颜色。有 (m) 组询问，给出两互异节点 (u,v) ，求路径 (u o v) 上有多少不同颜色。强制在线。
(1le nle 4 imes 10^4, 1le mle 10^5)
我们在上面分块的基础上，考虑如何统计颜色数目。
先看一条由根到叶节点的路径上的数个关键点 (x_1,x_2,x_3dots x_k) 。我们使用 bitset 来维护相邻两个关键点之间出现的颜色。然后，我们可以根据递推式：(b_{x_i o x_j}=b_{x_i o x_{j-1}} ext{or }b_{x_{j-1} o x_j})，处理出两两之间的 bitset。处理的复杂度 (O(frac{n^2}{S}+frac{n^3}{S^2}))。
考虑如何求答案。
我们设 (t=lca(u,v)) ，分别求出 (u,v) 祖先中，离 (u,v) 最近的关键点 (u_0,v_0) 以及离 (t) 最近且在 (t) 子树内的关键点 (u_1,v_1)。整个路径被划为六块：(u_1 o t, v_1 o t, u o u_1, v o v_1, u_0 o u_1, v_0 o v_1) 前四种都是零散块，暴力跳即可。后两块我们已经预处理了，直接取并。
求颜色个数直接调用答案 bitset 的 count() 成员函数。
时间复杂度 (O(frac{n^2}{S}+frac{n^3}{S^2}+frac{nm}{w}+mS))，空间复杂度 (O(frac{n^3}{S^2}))
我们发现这里的时间随 (S) 线性增长，空间随 (S) 平方下降，所以我们可以通过调 (S) 的大小来卡空间。
#include <bits/stdc++.h>
using namespace std;
const int N=4e4+5,S=1000;
bitset<N> bs[42][42],nw;
vector<int> vec;
int head[N],ver[N<<1],nxt[N<<1],tot=0;
void add(int x,int y)
{
ver[++tot]=y; nxt[tot]=head[x]; head[x]=tot;
ver[++tot]=x; nxt[tot]=head[y]; head[y]=tot;
}
int n,m;
int poi[N];
int sz[N],dpt[N],maxd[N],fa[N],son[N],tp[N];
int id[N],cnt=0;
int sta[N],top,gg[N],FF[N];
void dfs(int x)//找关键点
{
sz[x]=1;
maxd[x]=dpt[x];
for(int i=head[x];i;i=nxt[i])
{
int y=ver[i];
if(dpt[y]) continue;//判父节点
dpt[y]=dpt[x]+1;fa[y]=x;
dfs(y);
sz[x]+=sz[y];
if(maxd[y]>maxd[x]) maxd[x]=maxd[y];
if(sz[son[x]]<sz[y]) son[x]=y;
}
if(maxd[x]-dpt[x]>=S)
id[x]=++cnt,maxd[x]=dpt[x];//标记关键点
}
void dfs2(int x)//预处理bitset
/*利用栈来构建路径上关键点的序列*/
{
for(int i=head[x];i;i=nxt[i])
{
int y=ver[i];
if(dpt[y]>dpt[x])
{
if(id[y])
{
int ip=id[sta[top]],in=id[y];//找到栈顶的下一个相邻点
for(int t=y;t!=sta[top];t=fa[t])
bs[ip][in].set(poi[t]);//暴力统计颜色
nw=bs[ip][in];
for(int j=1;j<top;++j)//栈内其他关键点的处理
{
bitset<N> &bt=bs[id[sta[j]]][in];
bt=bs[id[sta[j]]][ip];
bt|=nw;
}
FF[y]=sta[top]; gg[y]=gg[sta[top]]+1;//记录关键点的前驱和深度
sta[++top]=y;//放入栈内
}
dfs2(y);
if(id[y]) --top;//回溯
}
}
}
void dfs3(int x)//树剖
{
if(son[x]) tp[son[x]]=tp[x],dfs3(son[x]);
for(int i=head[x];i;i=nxt[i])
{
int y=ver[i];
if(y!=son[x]&&dpt[y]>dpt[x])
dfs3(tp[y]=y);
}
}
inline int LCA(int x,int y)
{
while(tp[x]!=tp[y])
if(dpt[tp[x]]>dpt[tp[y]]) x=fa[tp[x]];
else y=fa[tp[y]];
return dpt[x]<dpt[y]?x:y;
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
scanf("%d",&poi[i]),vec.push_back(poi[i]);
sort(vec.begin(),vec.end()),vec.erase(unique(vec.begin(),vec.end()),vec.end());
for(int i=1;i<=n;i++)
poi[i]=lower_bound(vec.begin(),vec.end(),poi[i])-vec.begin();//离散化
for(int i=1;i<n;i++)
{
int u,v;
scanf("%d%d",&u,&v);
add(u,v);
}
dfs(dpt[1]=1);
if(!id[1]) id[1]=++cnt;
top=1;
sta[top]=gg[1]=1;
dfs2(1),dfs3(1);
int ans=0;
for(int i=1;i<=m;i++)
{
int u,v;
scanf("%d%d",&u,&v);
u^=ans; nw.reset();
int lca=LCA(u,v);
while(u!=lca&&!id[u]) nw.set(poi[u]),u=fa[u];
while(v!=lca&&!id[v]) nw.set(poi[v]),v=fa[v];//寻找离u，v最近的关键点
if(u!=lca)
{
int tmp=u;
while(dpt[FF[tmp]]>=dpt[lca]) tmp=FF[tmp];//寻找离lca最近的关键点
if(tmp!=u) nw|=bs[id[tmp]][id[u]];
while(tmp!=lca) nw.set(poi[tmp]),tmp=fa[tmp];//暴力统计
}
if(v!=lca)
{
int tmp=v;
while(dpt[FF[tmp]]>=dpt[lca]) tmp=FF[tmp];
if(tmp!=v) nw|=bs[id[tmp]][id[v]];
while(tmp!=lca) nw.set(poi[tmp]),tmp=fa[tmp];
}
nw.set(poi[lca]);//记得统计LCA;
printf("%d
",ans=nw.count());
}
return 0;
}
王室联邦分块法
我们 dfs ，把子树中大于 (B) 的分为一组，剩余的上传分到父亲那组。由于父亲那组大于 (B)，加进去小于 (3B) 。每一组即比较平均了，(B) 的大小会影响空间和时间的优劣，需要根据题目给定的时间和空间，时间多空间小 (B) 就开大，空间多时间少 (B) 开小。
这样分块是为了莫队的排序，而不是预处理保存信息。比如，((u,v)) 转移到 ((a,b)) ，由于 (u) 和 (a) 在一个组里面，即距离不太远，转移时间不太大。
王室联邦分块法可以保证每个块的大小和直径都不超过 (2sqrt N−1)，但是不保证块联通
『SCOI2005』王室联邦
本题就是这个分块做法的来源。
见代码，算法执行完成分块也就完成了。
#include <bits/stdc++.h>
using namespace std;
const int N=1e4;
int n,B;
int head[N], ver[N<<1],nxt[N<<1],tot=0;
void add(int x,int y)
{
ver[++tot]=y; nxt[tot]=head[x]; head[x]=tot;
ver[++tot]=x; nxt[tot]=head[y]; head[y]=tot;
}
int sta[N],top=0;//栈
int id[N],root[N],cnt=0;//每个点所在分块,每个块的关键点(首都),计数器
void dfs(int x,int f)
{
int nw=top;//由于这是全局栈，所以要记录当前栈顶
for(int i=head[x];i;i=nxt[i])
{
int y=ver[i];
if(y==f) continue;
dfs(y,x);
if(top-nw>=B)//如果当前栈内点数够
{
root[++cnt]=x;
while(top!=nw) id[sta[top--]]=cnt;//分到一个块里面去
}
}
sta[++top]=x;
}
int main()
{
scanf("%d%d",&n,&B);
for(int i=1;i<n;i++)
{
int x,y;
scanf("%d%d",&x,&y);
add(x,y);
}
dfs(1,0);
if(cnt==0) root[++cnt]=1;
while(top) id[sta[top--]]=cnt;//剩余节点的处理
printf("%d
",cnt);//分块数(划分的省数量)
for(int i=1;i<=n;i++)
printf("%d ",id[i]);
printf("
");
for(int i=1;i<=cnt;i++)
printf("%d ",root[i]);
return 0;
}