树链剖分板子求调，样例过不了

qwq

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=2e5+10;
int n,m,r,p;
int h[N],e[N],ne[N],idx;
void add(int a,int b)
{e[idx]=b,ne[idx]=h[a],h[a]=idx++;}
int w[N],new_w[N];
struct Node{int sum,tag;}tree[N<<2];
void pushup(int p)
{
    tree[p].sum=tree[p<<1].sum+tree[p<<1|1].sum;
}
void addtag(int p,int pl,int pr,int d)
{
    tree[p].tag+=d;
    tree[p].sum=(tree[p].sum+(pr-pl+1)*d%p)%p;
}
void pushdown(int p,int pl,int pr)
{
    if(tree[p].tag!=0)
    {
        int mid=pl+pr>>1;
        addtag(p<<1,pl,mid,tree[p].tag);
        addtag(p<<1|1,mid+1,pr,tree[p].tag);
        tree[p].tag=0;
    }
}
void build(int p,int pl,int pr)
{
    if(pl==pr) 
    {
        tree[p].sum=new_w[pl];
        return;
    }
    int mid=pl+pr>>1;
    build(p<<1,pl,mid);
    build(p<<1|1,mid+1,pr);
    pushup(p);
}
void update(int p,int pl,int pr,int L,int R,int d)
{//printf("p=%d pl=%d pr=%d\n",p,pl,pr);
    if(L<=pl&&pr<=R)
    {
        addtag(p,pl,pr,d);
        return;
    }
    pushdown(p,pl,pr); 
    int mid=pl+pr>>1;
    if(mid>=L) update(p<<1,pl,mid,L,R,d);
    if(mid<R) update(p<<1|1,mid+1,pr,L,R,d);
    pushup(p);
}
int query(int p,int pl,int pr,int L,int R)
{

    if(L<=pl&&pr<=R) return tree[p].sum;
    pushdown(p,pl,pr);
    int mid=pl+pr>>1,res=0;
    if(mid>=L) res+=query(p<<1,pl,mid,L,R);
    if(mid<R) res+=query(p<<1|1,mid+1,pr,L,R);
    return res;
}

int son[N],id[N],fa[N],deep[N],siz[N],top[N],cnt;
//重儿子、节点新编号、父节点、深度、子树大小(包括自己)、节点所在重链链头编号
void dfs1(int u,int father)//得到son、fa、deep、siz
{
    deep[u]=deep[father]+1;
    fa[u]=father;
    siz[u]=1;
    for(int i=h[u];~i;i=ne[i])
    {
        int v=e[i];
        if(v==father) continue;
        dfs1(v,u);
        siz[u]+=siz[v];
        if(!son[u]||siz[son[u]]<siz[v])//u没赋过重儿子或v更重就赋值v是u的重儿子 
            son[u]=v;
    }
}
void dfs2(int u,int topu)//得到id、top、new_w
//topx:当前节点所在链头
{
    id[u]=++cnt;//按照dfs序重新给编号（使每条重链和每棵子树编号连续，便于在连续区间查询） 
    new_w[cnt]=w[u];
    top[u]=topu;//记录链头 注意top的下标是原编号，存的对应链头也是原编号 
    if(!son[u]) return;//u是叶子，直接返回
    dfs2(son[u],topu);//先搜重儿子
    for(int i=h[u];~i;i=ne[i])
    {
        int v=e[i];
        if(v!=son[u]&&v!=fa[u]) dfs2(v,v);//每个轻儿子有一条从自己开始的链 
    } 
}
void update_range(int x,int y,int d)//与树剖求LCA过程类似 
{
    while(top[x]!=top[y])//每次x和y中较深的往上跳一条链，最后一定会在同一条链上 
    {
        if(deep[top[x]]<deep[top[y]]) swap(x,y);
        update(1,1,n,id[top[x]],id[x],d);//修改跳过的一条重链内部
        x=fa[top[x]];//跳过一条轻边到达上一条重链 
    }
    //x和y已经在同一条链上了，只需要修改这一条链上x到y的部分
    if(deep[x]>deep[y]) swap(x,y); 
    update(1,1,n,id[x],id[y],d);
} 
//一棵树的子树上所有编号一定从根开始连续（由dfs性质） 
void update_tree(int x,int d)
{
    update(1,1,n,id[x],id[x]+siz[x]-1,d);
}
int query_range(int x,int y)//与修改最短路径类似
{
    int ans=0;
    while(top[x]!=top[y])
    {
        if(deep[top[x]]<deep[top[y]]) swap(x,y);
        ans=(ans+query(1,1,n,id[top[x]],id[x]))%p;//得到跳过的这条重链的区间和
        x=fa[top[x]];
    }
    if(deep[x]>deep[y]) swap(x,y); 
    ans=(ans+query(1,1,n,id[x],id[y]))%p;//x和y在一条重链上，查询x到y
    return ans; 
} 
int query_tree(int x)
{
    return query(1,1,n,id[x],id[x]+siz[x]-1);
}
int main()
{
    memset(h,-1,sizeof h);
    scanf("%d%d%d%d",&n,&m,&r,&p);
    for(int i=1;i<=n;i++) scanf("%d",&w[i]);
    int a,b,k,x,y,z;
    for(int i=1;i<n;i++) scanf("%d%d",&a,&b),add(a,b),add(b,a);
    dfs1(r,0);
    dfs2(r,r);
    build(1,1,n);
    for(int i=1;i<=m;i++)
    {
        scanf("%d",&k);
        if(k==1) scanf("%d%d%d",&x,&y,&z),update_range(x,y,z);
        if(k==2) scanf("%d%d",&x,&y),printf("%d\n",query_range(x,y));
        if(k==3) scanf("%d%d",&x,&z),update_tree(x,z);
        if(k==4) scanf("%d",&x),printf("%d\n",query_tree(x));
    }
    return 0;
}