树上问题
很多处理区间的问题（像是RMQ，区间修改）。可以用线段树，树状数组，ST表这些数据结构来维护。但是如果将这些问题挪到了树上，就不能直接用这些数据结构来处理了。这时就用到了dfs序和树链剖分。
DFS序
dfs序就是按照dfs的顺序对一棵树上的结点进行编号。这样完成编号的优点是：每棵子树上的结点的编号都是连续的，这要只要记录下一棵子树开始的结点编号，和结束的节点编号，然后就可以用线段树等来维护这个有序数列了。
dfs序主要是用于处理对于整棵子树的修改，像是子树每个节点权值加减v。查询树上某个点的值。。。。。。
一道例题:
思路
进行一遍dfs，找出dfs序。因为是单点修改区间查询，所以可以直接用树状数组来维护。注意里面查询的时候的写法是，用子树结尾点的编号的前缀和减去开始编号的前一个编号的前缀和。
代码：
#include<cstdio>
#include<cstring>
#include<iostream>
#define lob(x) x&(-x)
using namespace std;
const int N=100000*2;
int head[N],ejs;
struct node
{
int v,nxt;
}edg[N];
void add(int u,int v)
{
edg[ejs].v=v;edg[ejs].nxt=head[u];head[u]=ejs;ejs++;
}
int tot,tree[N],n,in[N],out[N],app[N],m;
void dfs(int x)
{
in[x]=++tot;
for(int i=head[x];i!=-1;i=edg[i].nxt)
dfs(edg[i].v);
out[x]=tot;
}
void change(int pos,int x)
{
for(int i=pos;i<=tot;i+=lob(i))
tree[i]+=x;
}
int find(int pos)
{
int ans=0;
for(int i=pos;i>=1;i-=lob(i))
ans+=tree[i];
return ans;
}
int main()
{
memset(head,-1,sizeof(head));
scanf("%d",&n);
for(int i=1,x,y;i<n;++i)
{
scanf("%d%d",&x,&y);
add(x,y);
}
dfs(1);
for(int i=1;i<=n;++i)
{
app[i]=1;
change(in[i],1);
}
scanf("%d",&m);
char bz;
int x;
for(int i=1;i<=m;++i)
{
cin>>bz>>x;
if(bz=='C')
{
if(app[x]!=0)
{
change(in[x],-1);
app[x]=0;
}
else
change(in[x],1),app[x]=1;
}
else
{
printf("%d\n",find(out[x])-find(in[x]-1));
}
}
return 0;
}
树链剖分
树链剖分其实就是为了更加便利的解决树上的问题，将树拆成链，然后对于拆成的链就可以用线段树，树状数组……来维护，以降低复杂度。
做法就是先进行两遍dfs处理出七个数组来维护一些需要的东西。
第一遍dfs处理的内容：
- dep: 维护每个点的深度，这个在进行最后操作的时候要用
- son: 顾名思义，就是来存当前点的子节点，但是这个子节点是指重儿子（以该儿子为根的子树是所有儿子子树中最大的）。
- faz: 有儿子就有爹，这个也是以后进行操作的时候用
- siz: 用来存以当前节点为根的子树的大小，最后利用这个来找重儿子
第二遍dfs处理的内容：
- rank: 将节点原来的编号与按照先搜重儿子的顺序的搜索编号进行对应
- wt: 用来对应原节点的权值
- top： 用来记录每个节点所在树链的顶端节点是谁
具体的方法见代码：
void dfs1(int u,int fa,int depth) {
f[u]=fa;
d[u]=depth;
size[u]=1;
for(int i=head[u]; i; i=e[i].next) {
int v=e[i].to;
if(v==fa)
continue;
dfs1(v,u,depth+1);
size[u]+=size[v];
if(size[v]>size[son[u]])
son[u]=v;
}
}
void dfs2(int u,int t) {
top[u]=t;
id[u]=++cnt;
rk[cnt]=u;
if(!son[u])
return;
dfs2(son[u],t);
for(int i=head[u]; i; i=e[i].next) {
int v=e[i].to;
if(v!=son[u]&&v!=f[u])
dfs2(v,v);
}
}
查询与修改：
现在树上节点的编号就被我们对应成了连续的即rank数组。然后就可以用一科线段树或者其他数据结构来维护了。那么怎么保证我们能正确的进行查询与修改呢。
举个栗子，如果让我们修改从节点a到节点b这条路径上节点的长度。如果a和b在同一条链上，就很好办了，因为他们对应的rank数组是连续的。但是更短情况下a与b是不连续的。我们可以将不连续转化为连续，只要a与b不在同一条链上（也就是他们的top不同），就将其中深度（dep）更深的那个向上跳，也就是先修改这个点的top节点到其这一段，然后将这个节点变为他top节点的faz。不断进行上述操作，直到a与b处在了同一条链上，这时修改a到b然后就完成了整个修改。
查询操作同理，不断向上跳，同时查询途经节点的值。
具体做法见代码：
#include<iostream>
#include<cstdio>
#define int long long
using namespace std;
const int maxn=1e5+10;
struct edge{
int next,to;
}e[2*maxn];
struct Node{
int sum,lazy,l,r,ls,rs;
}node[2*maxn];
int rt,n,m,r,p,a[maxn],cnt,head[maxn],f[maxn],d[maxn],size[maxn],son[maxn],rk[maxn],top[maxn],id[maxn];
int mod(int a,int b)
{
return (a+b)%p;
}
void add_edge(int x,int y)
{
e[++cnt].next=head[x];
e[cnt].to=y;
head[x]=cnt;
}
void dfs1(int u,int fa,int depth)
{
f[u]=fa;
d[u]=depth;
size[u]=1;
for(int i=head[u];i;i=e[i].next)
{
int v=e[i].to;
if(v==fa)
continue;
dfs1(v,u,depth+1);
size[u]+=size[v];
if(size[v]>size[son[u]])
son[u]=v;
}
}
void dfs2(int u,int t)
{
top[u]=t;
id[u]=++cnt;
rk[cnt]=u;
if(!son[u])
return;
dfs2(son[u],t);
for(int i=head[u];i;i=e[i].next)
{
int v=e[i].to;
if(v!=son[u]&&v!=f[u])
dfs2(v,v);
}
}
void pushup(int x)
{
node[x].sum=(node[node[x].ls].sum+node[node[x].rs].sum+node[x].lazy*(node[x].r-node[x].l+1))%p;
}
void build(int li,int ri,int cur)
{
if(li==ri)
{
node[cur].l=node[cur].r=li;
node[cur].sum=a[rk[li]];
return;
}
int mid=(li+ri)>>1;
node[cur].ls=cnt++;
node[cur].rs=cnt++;
build(li,mid,node[cur].ls);
build(mid+1,ri,node[cur].rs);
node[cur].l=node[node[cur].ls].l;
node[cur].r=node[node[cur].rs].r;
pushup(cur);
}
void update(int li,int ri,int c,int cur)
{
if(li<=node[cur].l&&node[cur].r<=ri)
{
node[cur].sum=mod(node[cur].sum,c*(node[cur].r-node[cur].l+1));
node[cur].lazy=mod(node[cur].lazy,c);
return;
}
int mid=(node[cur].l+node[cur].r)>>1;
if(li<=mid)
update(li,ri,c,node[cur].ls);
if(mid<ri)
update(li,ri,c,node[cur].rs);
pushup(cur);
}
int query(int li,int ri,int cur)
{
if(li<=node[cur].l&&node[cur].r<=ri)
return node[cur].sum;
int tot=node[cur].lazy*(min(node[cur].r,ri)-max(node[cur].l,li)+1)%p;
int mid=(node[cur].l+node[cur].r)>>1;
if(li<=mid)
tot=mod(tot,query(li,ri,node[cur].ls));
if(mid<ri)
tot=mod(tot,query(li,ri,node[cur].rs));
return tot%p;
}
int sum(int x,int y)
{
int ans=0;
int fx=top[x],fy=top[y];
while(fx!=fy)
{
if(d[fx]>=d[fy])
{
ans=mod(ans,query(id[fx],id[x],rt));
x=f[fx],fx=top[x];
}
else
{
ans=mod(ans,query(id[fy],id[y],rt));
y=f[fy],fy=top[y];
}
}
if(id[x]<=id[y])
ans=mod(ans,query(id[x],id[y],rt));
else
ans=mod(ans,query(id[y],id[x],rt));
return ans%p;
}
void updates(int x,int y,int c)
{
int fx=top[x],fy=top[y];
while(fx!=fy)
{
if(d[fx]>=d[fy])
{
update(id[fx],id[x],c,rt);
x=f[fx],fx=top[x];
}
else
{
update(id[fy],id[y],c,rt);
y=f[fy],fy=top[y];
}
}
if(id[x]<=id[y])
update(id[x],id[y],c,rt);
else
update(id[y],id[x],c,rt);
}
signed main()
{
scanf("%d%d%d%d",&n,&m,&r,&p);
for(int i=1;i<=n;i++)
scanf("%d",&a[i]);
for(int i=1;i<n;i++)
{
int x,y;
scanf("%d%d",&x,&y);
add_edge(x,y);
add_edge(y,x);
}
cnt=0;
dfs1(r,0,1);
dfs2(r,r);
cnt=0;
rt=cnt++;
build(1,n,rt);
for(int i=1;i<=m;i++)
{
int op,x,y,z;
scanf("%lld",&op);
if(op==1)
{
scanf("%lld%lld%lld",&x,&y,&z);
updates(x,y,z);
}
else if(op==2)
{
scanf("%lld%lld",&x,&y);
printf("%lld\n",sum(x,y));
}
else if(op==3)
{
scanf("%lld%lld",&x,&z);
//子树也有连续区间的性质
update(id[x],id[x]+size[x]-1,z,rt);
}
else if(op==4)
{
scanf("%lld",&x);
printf("%lld\n",query(id[x],id[x]+size[x]-1,rt));
}
}
return 0;
}