LG-P3384 【模板】树链剖分

P3384 【模板】树链剖分
题目链接
题目描述
如题，已知一棵包含N个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作：

操作1： 格式： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z

操作2： 格式： 2 x y 表示求树从x到y结点最短路径上所有节点的值之和

操作3： 格式： 3 x z 表示将以x为根节点的子树内所有节点值都加上z

操作4： 格式： 4 x 表示求以x为根节点的子树内所有节点值之和

输入格式：
第一行包含4个正整数N、M、R、P，分别表示树的结点个数、操作个数、根节点序号和取模数（即所有的输出结果均对此取模）。

接下来一行包含N个非负整数，分别依次表示各个节点上初始的数值。

接下来N-1行每行包含两个整数x、y，表示点x和点y之间连有一条边（保证无环且连通）

接下来M行每行包含若干个正整数，每行表示一个操作，格式如下：

操作1： 1 x y z

操作2： 2 x y

操作3： 3 x z

操作4： 4 x

输出格式：
输出包含若干行，分别依次表示每个操作2或操作4所得的结果（对P取模）

输入样例：
5 5 2 24
7 3 7 8 0
1 2
1 5
3 1
4 1
3 4 2
3 2 2
4 5
1 5 1 3
2 1 3
输出样例：
2
21
说明
时空限制：1s，128M

数据规模：

对于30%的数据： N≤10 ,M≤10

对于70%的数据： N≤10^3 ,M≤10^3

对于100%的数据： N≤10^5 ,M≤10^5

（ 其实，纯随机生成的树LCA+暴力是能过的，可是，你觉得可能是纯随机的么233 ）

样例说明：

树的结构如下：

各个操作如下：

故输出应依次为2、21(重要的事情说三遍：记得取模)

题解
树链剖分 .

基本定义编辑：
树路径信息维护算法。
将一棵树划分成若干条链，用数据结构去维护每条链，复杂度为O(logN)。
其实本质是一些数据结构/算法在树上的推广
——摘自百度百科

这题很多人写了线段树，其实可以只写树状数组。

代码

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define LL long long
using namespace std;
const int maxn=1e5+5;
int n,m,R,P,tot,lnk[maxn],nxt[maxn<<1],son[maxn<<1],a[maxn];
LL c1[maxn],c2[maxn];
int dep[maxn],siz[maxn],fa[maxn],hv[maxn];
int id[maxn],top[maxn],cnt;
inline LL rad()
{
    LL ret=0,f=1;char ch=getchar();
    while(!isdigit(ch)){if (ch=='-')f=-1;ch=getchar();}
    while (isdigit(ch)) ret=ret*10+ch-'0',ch=getchar();
    return ret*f;
}
inline void add(int x,int y){son[++tot]=y;nxt[tot]=lnk[x];lnk[x]=tot;}
inline void put_(LL *c,int x,int dat){do{c[x]=(c[x]+dat)%P;x+=x&-x;}while(x<=n);}//树状数组的修改 
inline LL   get_(LL *c,int x){LL sum=0;do{sum=(sum+c[x])%P;x-=x&-x;}while(x>=1);return sum;}//树状数组的查询 
inline void putted(int x,int dat){put_(c1,x,dat);put_(c2,x,1ll*dat*(x-1)%P);}
inline LL   getted(int x){return (get_(c1,x)*x%P-get_(c2,x)+P)%P;}
inline void putLR(int L,int R,int dat){putted(L,dat);putted(R+1,P-dat%P);}//区间修改 
inline LL   getLR(int L,int R){return (getted(R)-getted(L-1)+P)%P;}//区间查询 
void dfs1(int x,int f)
{
    dep[x]=dep[fa[x]=f]+1;siz[x]=1;hv[x]=0;//标记深度，父节点；x为根的树包括自身最少1个节点；重儿子给个初值 
    for (int i=lnk[x],y=son[i];i!=0;y=son[i=nxt[i]])//骚气的for循环 
    {
        if (f==y) continue;//如果是父节点就跳过 
        else dfs1(y,x);siz[x]+=siz[y];//累计上子树的节点个数 
        if (siz[hv[x]]<siz[y]) hv[x]=y;//刷重儿子 
    }
}
void dfs2(int x,int tpf)
{
    id[x]=++cnt;top[x]=tpf;//标记新编号（dfs序）和所在重链的顶点 
    if (hv[x]==0) return;else dfs2(hv[x],tpf);//没有重儿子，说明是叶子节点，直接弹；否则就优先遍历重儿子 
    for (int i=lnk[x],y=son[i];i!=0;y=son[i=nxt[i]])//骚气的for循环 
      if (y==fa[x]||y==hv[x]) continue;else dfs2(y,y);
      //父节点不能重新绕回去，重儿子之前已经遍历过了；对于每个轻儿子都有一个从自己开始重链 
}
inline LL query_link(int x,int y)
{
    LL ans=0;while (top[x]!=top[y])
    {
        if (dep[top[x]]<dep[top[y]]) swap(x,y);
        ans=(ans+getLR(id[top[x]],id[x]))%P;x=fa[top[x]];
    }
    if (dep[x]>dep[y]) swap(x,y);
    return (ans+getLR(id[x],id[y]))%P;
}
inline LL query_tree(int x){return getLR(id[x],id[x]+siz[x]-1);}
inline void change_link(int x,int y,int dat)
{
    while (top[x]!=top[y])
    {
        if (dep[top[x]]<dep[top[y]]) swap(x,y);
        putLR(id[top[x]],id[x],dat);x=fa[top[x]];
    }
    if (dep[x]>dep[y]) swap(x,y);putLR(id[x],id[y],dat);
}
inline void change_tree(int x,int dat){putLR(id[x],id[x]+siz[x]-1,dat);}
int main()
{
    n=rad(),m=rad(),R=rad(),P=rad();
    for (int i=1;i<=n;i++) a[i]=rad();
    for (int i=1;i<n;++i){int x=rad(),y=rad();add(x,y);add(y,x);}
    dfs1(R,0);dfs2(R,R);
    for (int i=1;i<=n;i++) putLR(id[i],id[i],a[i]);
    for (int i=1,x,y;i<=m;i++)
    {
        int id=rad();switch(id)
        {
            case 1:x=rad();y=rad();change_link(x,y,rad()%P);break;
            case 2:x=rad();y=rad();printf("%lld\n",query_link(x,y));break;
            case 3:x=rad();change_tree(x,rad()%P);break;
            case 4:x=rad();printf("%lld\n",query_tree(x));break;
        }
    }
    return 0;
}