[hdu6973]Bookshop

将询问拆成$x$​到$lca$​和$lca$​（$lca$​靠近$y$​的儿子）到$y$​​两部分，分别处理（后者以前者的答案为基础）

两者是类似地，不妨仅考虑前者：用树剖将该询问拆成dfs序上若干个区间，考虑从后往前遍历dfs序（显然即从下到上），若当前位置被覆盖则执行该节点的操作

进一步的，考虑将一个位置上的操作对覆盖其的位置批量处理，即将问题离线并维护一棵平衡树，仍从后往前遍历dfs序，并支持：

1.（在区间右端点时）加入一个数

2.将当前平衡树中大于等于$k$​的数都减去$k$​

3.（在区间左端点时）删除一个数

前两个容易处理（删除可以将下标定为询问编号），对于第三个，对权值分类讨论：

1.权值在$[0,k)$​中的数不需要处理

2.权值在$[k,2k)$中的数，每一个数至多经历$o(log V)$​次此操作即会变为0（之后显然就不会被操作了），将这些数取出后再暴力操作，复杂度为$o(qlog nlog V)$

3.权值在$[2k,infty)$中的数，打懒标记即可（第2类需要暴力处理因为要考虑与$[0,k)$中的数的排名）

总复杂度即$o(nlog ^{2}n)$，可以通过

#include<bits/stdc++.h>
using namespace std;
#define N 100005
#define pii pair<int,int>
#define mp make_pair
#define fi first
#define se second
#define s(p) f[k].ch[p]
vector<int>v,va[N],vd[N];
vector<pii>v0[N],v1[N];
int E,rt,t,n,q,x,y,head[N],a[N],st[N],fa[N],sz[N],mx[N],dep[N],dfn[N],idfn[N],top[N];
struct Edge{
    int nex,to;
}edge[N<<1];
struct Data{
    int fa,val,mx,mn,tag,ch[2];
}f[N];
void add_edge(int x,int y){
    edge[E].nex=head[x];
    edge[E].to=y;
    head[x]=E++;
}
void dfs1(int k,int f,int s){
    fa[k]=f,sz[k]=1,mx[k]=0,dep[k]=s;
    for(int i=head[k];i!=-1;i=edge[i].nex)
        if (edge[i].to!=f){
            dfs1(edge[i].to,k,s+1);
            sz[k]+=sz[edge[i].to];
            if (sz[mx[k]]<sz[edge[i].to])mx[k]=edge[i].to;
        }
}
void dfs2(int k,int fa,int t){
    dfn[k]=++dfn[0],idfn[dfn[0]]=k,top[k]=t;
    if (mx[k])dfs2(mx[k],k,t);
    for(int i=head[k];i!=-1;i=edge[i].nex)
        if ((edge[i].to!=fa)&&(edge[i].to!=mx[k]))dfs2(edge[i].to,k,edge[i].to);
}
int check(int k){
    return f[f[k].fa].ch[1]==k;
}
bool cmp(int x,int y){
    return (f[x].val<f[y].val)||(f[x].val==f[y].val)&&(x<y);
}
void upd(int k,int x){
    f[k].val+=x,f[k].mx+=x,f[k].mn+=x,f[k].tag+=x;
}
void up(int k){
    f[k].mx=max(max(f[s(0)].mx,f[s(1)].mx),f[k].val);
    f[k].mn=min(min(f[s(0)].mn,f[s(1)].mn),f[k].val);
}
void down(int k){
    if (s(0))upd(s(0),f[k].tag);
    if (s(1))upd(s(1),f[k].tag);
    f[k].tag=0;
}
void rotate(int k){
    int F=f[k].fa,G=f[F].fa,p=check(k);
    f[k].fa=G;
    if (G)f[G].ch[check(F)]=k;
    f[s(p^1)].fa=F,f[F].ch[p]=s(p^1);
    f[F].fa=k,s(p^1)=F;
    up(F),up(k);
}
void clear(int k){
    for(int i=k;i;i=f[i].fa)st[++st[0]]=i;
    while (st[0])down(st[st[0]--]);
}
void splay(int k,int fa){
    clear(k);
    for(int i=f[k].fa;i!=fa;i=f[k].fa){
        if (f[i].fa!=fa){
            if (check(i)==check(k))rotate(i);
            else rotate(k);
        }
        rotate(k);
    }
    if (!fa)rt=k;
}
void get_val(int k){
    if (!k)return;
    v.push_back(k);
    get_val(s(0));
    get_val(s(1));
}
int find_pre(int k,int x){
    if (!k)return 0;
    down(k);
    if (!cmp(k,x))return find_pre(s(0),x);
    int ans=find_pre(s(1),x);
    if (ans)return ans;
    return k;
}
int find_nex(int k,int x){
    if (!k)return 0;
    down(k);
    if (!cmp(x,k))return find_nex(s(1),x);
    int ans=find_nex(s(0),x);
    if (ans)return ans;
    return k;
}
void add(int k){
    clear(k);
    int l=find_pre(rt,k),r=find_nex(rt,k);
    if (!l){
        if (!r)rt=k;
        else{
            splay(r,0);
            f[k].fa=rt,f[rt].ch[0]=k;
            up(rt);
        }
    }
    else{
        splay(l,0);
        if (!r){
            f[k].fa=rt,f[rt].ch[1]=k;
            up(rt);
        }
        else{
            splay(r,rt);
            f[k].fa=f[rt].ch[1],f[f[rt].ch[1]].ch[0]=k;
            up(f[rt].ch[1]),up(rt);
        }
    }
}
void dec(int k){
    clear(k);
    int l=find_pre(rt,k),r=find_nex(rt,k);
    if (!l){
        if (!r)rt=0;
        else{
            splay(r,0);
            f[rt].ch[0]=0;
            up(rt);
        }
    }
    else{
        splay(l,0);
        if (!r){
            f[rt].ch[1]=0;
            up(rt);
        }
        else{
            splay(r,rt);
            f[f[rt].ch[1]].ch[0]=0;
            up(f[rt].ch[1]),up(rt);
        }
    }
    f[k].fa=0;
}
void update_force(int x,int y,int z){
    v.clear();
    f[0].val=x,f[q+1].val=y;
    int l=find_pre(rt,0),r=find_nex(rt,q+1);
    if (!l){
        if (!r)get_val(rt);
        else{
            splay(r,0);
            get_val(f[rt].ch[0]);
            up(rt);
        }
    }
    else{
        splay(l,0);
        if (!r){
            get_val(f[rt].ch[1]);
            up(rt);
        }
        else{
            splay(r,rt);
            get_val(f[f[rt].ch[1]].ch[0]);
            up(f[rt].ch[1]),up(rt);
        }
    }
    for(int i=0;i<v.size();i++){
        dec(v[i]);
        f[v[i]].val+=z;
        add(v[i]);
    }
}
void update_tag(int x,int y,int z){
    f[0].val=x,f[q+1].val=y;
    int l=find_pre(rt,0),r=find_nex(rt,q+1);
    if (!l){
        if (!r)upd(rt,z);
        else{
            splay(r,0);
            upd(f[rt].ch[0],z);
            up(rt);
        }
    }
    else{
        splay(l,0);
        if (!r){
            upd(f[rt].ch[1],z);
            up(rt);
        }
        else{
            splay(r,rt);
            upd(f[f[rt].ch[1]].ch[0],z);
            up(f[rt].ch[1]),up(rt);
        }
    }
}
int main(){
    f[0].mn=0x3f3f3f3f;
    scanf("%d",&t);
    while (t--){
        scanf("%d%d",&n,&q);
        for(int i=1;i<=n;i++)scanf("%d",&a[i]);
        E=dfn[0]=0;
        for(int i=1;i<=n;i++)head[i]=-1;
        for(int i=1;i<n;i++){
            scanf("%d%d",&x,&y);
            add_edge(x,y);
            add_edge(y,x);
        }
        dfs1(1,0,0);
        dfs2(1,0,1);
        for(int i=1;i<=q;i++){
            scanf("%d%d%d",&x,&y,&f[i].val);
            v0[i].clear(),v1[i].clear();
            while (top[x]!=top[y]){
                if (dep[top[x]]>dep[top[y]]){
                    v0[i].push_back(mp(dfn[x],dfn[top[x]]));
                    x=fa[top[x]];
                }
                else{
                    v1[i].push_back(mp(dfn[top[y]],dfn[y]));
                    y=fa[top[y]];
                }
            }
            if (dfn[x]>dfn[y])v0[i].push_back(mp(dfn[x],dfn[y]));
            else v1[i].push_back(mp(dfn[x],dfn[y]));
        }
        for(int i=1;i<=n;i++)va[i].clear(),vd[i].clear();
        for(int i=1;i<=q;i++)
            for(int j=0;j<v0[i].size();j++){
                va[v0[i][j].fi].push_back(i);
                vd[v0[i][j].se].push_back(i);
            }
        rt=0;
        for(int i=1;i<=q;i++){
            f[i].fa=f[i].tag=f[i].ch[0]=f[i].ch[1]=0;
            f[i].mx=f[i].mn=f[i].val;
        }
        for(int i=n;i;i--){
            int k=a[idfn[i]];
            for(int j=0;j<va[i].size();j++)add(va[i][j]);
            update_force(k,(k<<1)-1,-k);
            update_tag((k<<1),1e9,-k);
            for(int j=0;j<vd[i].size();j++)dec(vd[i][j]);
        }
        for(int i=1;i<=n;i++)va[i].clear(),vd[i].clear();
        for(int i=1;i<=q;i++)
            for(int j=0;j<v1[i].size();j++){
                va[v1[i][j].fi].push_back(i);
                vd[v1[i][j].se].push_back(i);
            }
        rt=0;
        for(int i=1;i<=q;i++){
            f[i].fa=f[i].tag=f[i].ch[0]=f[i].ch[1]=0;
            f[i].mx=f[i].mn=f[i].val;
        }
        for(int i=1;i<=n;i++){
            int k=a[idfn[i]];
            for(int j=0;j<va[i].size();j++)add(va[i][j]);
            update_force(k,(k<<1)-1,-k);
            update_tag((k<<1),1e9,-k);
            for(int j=0;j<vd[i].size();j++)dec(vd[i][j]);
        }
        for(int i=1;i<=q;i++)printf("%d
",f[i].val);
    }
    return 0;
}