【模板】树链剖分

题目传送门

type
    rec                                        =record
    l,r                                        :longint;    
    sum,lazy                                :int64;
end;


var
    n,m,r,mo,i,x,y,z,opt,tot,ll                :longint;
    pre,last,other                            :array[0..200050] of longint;
    num                                        :array[0..100050] of longint;
    a,key                                    :array[0..100050] of int64;
    t                                        :Array[0..300050] of rec;
    size,top,dep,father                        :array[0..100050] of longint;
    vis                                        :Array[0..100050] of boolean;
    mson                                    :Array[0..100050] of longint;

procedure swap(var x,y:longint);
var
    z                                        :longint;
begin
    z:=x;
    x:=y;
    y:=z;
end;
    
procedure add(u,v:longint);
begin
    inc(ll);
    pre[ll]:=last[u];
    last[u]:=ll;
    other[ll]:=v;
end;
    
procedure dfs(x:longint);
var
    p,q                                        :longint;
begin
    size[x]:=1;
    p:=last[x];
    while p<>0 do
    begin
        q:=other[p];
        if not vis[q] then
        begin
            father[q]:=x;
            vis[q]:=true;
            dfs(q);
            inc(size[x],size[q]);
            if size[mson[x]]<size[q] then mson[x]:=q;
        end;
        p:=pre[p];
    end;
end;

procedure make(x,topp,depp:longint);
var
    p,q                                        :longint;
begin
    inc(tot);
    num[x]:=tot;
    a[tot]:=key[x];
    top[x]:=topp;
    dep[x]:=depp;
    if mson[x]<>0 then
    begin
        vis[mson[x]]:=true;
        make(mson[x],topp,depp);
    end;
    p:=last[x];
    while p<>0 do
    begin
        q:=other[p];
        if (not vis[q]) and (q<>mson[x]) then
        begin
            vis[q]:=true;
            make(q,q,depp+1);
        end;
        p:=pre[p];
    end;
end;

procedure build(x,l,r:longint);
var
    mid                                        :longint;
begin
    t[x].l:=l; t[x].r:=r;
    if (t[x].l=t[x].r) then
    begin
        t[x].sum:=a[l] mod mo;
        exit;
    end;
    mid:=(t[x].l+t[x].r)>>1;
    build(x*2,l,mid);
    build(x*2+1,mid+1,r);
    t[x].sum:=(t[x*2].sum+t[x*2+1].sum) mod mo;
end;

procedure update(x:longint);
begin
    t[x].sum:=(t[x].sum+t[x].lazy*(t[x].r-t[x].l+1)) mod mo;
    if t[x].l=t[x].r then
    begin
        t[x].lazy:=0;
        exit;
    end;
    t[x*2].lazy:=(t[x*2].lazy+t[x].lazy) mod mo;
    t[x*2+1].lazy:=(t[x*2+1].lazy+t[x].lazy) mod mo;
    t[x].lazy:=0;
end;

procedure change(x,l,r,y:longint);
var
    mid                                        :longint;
begin
    if (t[x].l=l) and (t[x].r=r) then
    begin
        t[x].lazy:=(t[x].lazy+y) mod mo;
        exit;
    end;
    if t[x].lazy<>0 then update(x);
    mid:=(t[x].l+t[x].r)>>1;
    if l>mid then change(x*2+1,l,r,y) else
    if r<=mid then change(x*2,l,r,y) else
    begin
        change(x*2,l,mid,y);
        change(x*2+1,mid+1,r,y);
    end;
    t[x].sum:=(t[x*2].sum+t[x*2+1].sum+t[x*2].lazy*(t[x*2].r-t[x*2].l+1)+t[x*2+1].lazy*(t[x*2+1].r-t[x*2+1].l+1)) mod mo;
end;

function find(x,l,r:longint):longint;
var
    mid                                        :longint;
begin
    if t[x].lazy<>0 then update(x);
    if (t[x].l=l) and (t[x].r=r) then exit(t[x].sum);
    mid:=(t[x].l+t[x].r)>>1;
    if l>mid then exit(find(x*2+1,l,r)) else
    if r<=mid then exit(find(x*2,l,r)) else
    exit((find(x*2,l,mid)+find(x*2+1,mid+1,r)) mod mo);
end;

procedure qchan(x,y,z:longint);
begin
    if dep[x]>dep[y] then swap(x,y);
    while dep[x]<dep[y] do
    begin
        change(1,num[top[y]],num[y],z);
        y:=father[top[y]];
    end;
    while top[x]<>top[y] do
    begin
        change(1,num[top[x]],num[x],z);
        change(1,num[top[y]],num[y],z);
        x:=father[top[x]];
        y:=father[top[y]];
    end;
    x:=num[x];
    y:=num[y];
    if x>y then swap(x,y);
    change(1,x,y,z);
end;

function qfind(x,y:longint):int64;
var
    ans                                        :int64;
begin
    ans:=0;
    if dep[x]>dep[y] then swap(x,y);
    while dep[x]<dep[y] do
    begin
        ans:=(ans+find(1,num[top[y]],num[y])) mod mo;
        y:=father[top[y]];
    end;
    while top[x]<>top[y] do
    begin
        ans:=(ans+find(1,num[top[x]],num[x])) mod mo;
        ans:=(ans+find(1,num[top[y]],num[y])) mod mo;
        x:=father[top[x]];
        y:=father[top[y]];
    end;
    x:=num[x];
    y:=num[y];
    if x>y then swap(x,y);
    ans:=(ans+find(1,x,y)) mod mo;
    writeln(ans);
end;
    
begin
    read(n,m,r,mo);
    for i:=1 to n do read(key[i]);
    for i:=1 to n-1 do
    begin
        read(x,y);
        add(x,y);
        add(y,x);
    end;
    vis[r]:=true;
    dfs(r);
    fillchar(vis,sizeof(vis),false);
    vis[r]:=true;
    make(r,r,1);
    build(1,1,n);
    for i:=1 to m do
    begin
        read(opt);
        if opt=1 then
        begin
            read(x,y,z);
            qchan(x,y,z);
        end else
        if opt=2 then
        begin
            read(x,y);
            qfind(x,y);
        end else
        if opt=3 then 
        begin
            read(x,y);
            change(1,num[x],num[x]+size[x]-1,y);
        end else
        begin
            read(x);
            writeln(find(1,num[x],num[x]+size[x]-1));
        end;
    end;
end.