rt，过了样例但是全部 WA。

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=1e5+5,INF=(int)1e18+5;
struct Edge
{
    int u,v,w;
}x[N];
string op;
int n,u,v,k,a[N],b[N];
list<int>edge[N];
class Segment_tree
{
    private:
        int node[N*4],lazy1[N*4],lazy2[N*4];
        void push_up(int id)
        {
            node[id]=max(node[id*2],node[id*2+1]);
        }
        void push_down(int id)
        {
            if(lazy1[id]!=-INF)
            {
                node[id*2]=node[id*2+1]=lazy1[id];
                lazy1[id*2]=lazy1[id*2+1]=lazy1[id];
                lazy2[id*2]=lazy2[id*2+1]=0;
                lazy1[id]=-INF;
            }
            if(lazy2[id]!=0)
            {
                node[id*2]+=lazy2[id];
                node[id*2+1]+=lazy2[id];
                lazy2[id*2]+=lazy2[id];
                lazy2[id*2+1]+=lazy2[id];
                lazy2[id]=0;
            }
        }
    public:
        void build(int id,int l,int r,int a[N])
        {
            if(l==r)
            {
                node[id]=a[l];
                lazy1[id]=-INF;
                lazy2[id]=0;
            }
            else
            {
                lazy1[id]=-INF;
                int mid=(l+r)/2;
                build(id*2,l,mid,a);
                build(id*2+1,mid+1,r,a);
                push_up(id);
            }
        }
        void updata1(int id,int l,int r,int x,int y,int z)
        {
            if(x<=l&&r<=y)
            {
                node[id]=lazy1[id]=z;
                lazy2[id]=0;
            }
            else
            {
                push_down(id);
                int mid=(l+r)/2;
                if(x<=mid)updata1(id*2,l,mid,x,y,z);
                if(y>mid)updata1(id*2+1,mid+1,r,x,y,z);
                push_up(id);
            }
        }
        void updata2(int id,int l,int r,int x,int y,int z)
        {
            if(x<=l&&r<=y)
            {
                node[id]+=z;
                lazy2[id]+=z;
            }
            else
            {
                push_down(id);
                int mid=(l+r)/2;
                if(x<=mid)updata2(id*2,l,mid,x,y,z);
                if(y>mid)updata2(id*2+1,mid+1,r,x,y,z);
                push_up(id);
            }
        }
        int query(int id,int l,int r,int x,int y)
        {
            if(x<=l&&r<=y)return node[id];
            push_down(id);
            int mid=(l+r)/2,res=-INF;
            if(x<=mid)res=max(res,query(id*2,l,mid,x,y));
            if(y>mid)res=max(res,query(id*2+1,mid+1,r,x,y));
            return res;
        }
}T;
int cnt,deep[N],fa[N],siz[N],son[N],top[N],dfn[N];
void build(int u,int v)
{
    edge[u].push_back(v);
    edge[v].push_back(u);
}
void DFS1(int u,int f)
{
    siz[u]=1,fa[u]=f;
    deep[u]=deep[f]+1;
    for(auto v:edge[u])
    {
        if(v==f)continue;
        DFS1(v,u);
        siz[u]+=siz[v];
        if(siz[v]>siz[son[u]])
            son[u]=v;
    }
}
void DFS2(int u)
{
    dfn[u]=++cnt;
    b[cnt]=a[u];
    if(son[fa[u]]==u)
        top[u]=top[fa[u]];
    else top[u]=u;
    if(son[u]!=0)
        DFS2(son[u]);
    for(auto v:edge[u])
    {
        if(v==fa[u]||v==son[u])
            continue;
        DFS2(v);
    }
}
void LCA_updata1(int u,int v,int x)
{
    while(top[u]!=top[v])
    {
        if(deep[top[u]]<deep[top[v]])
            swap(u,v);
        T.updata1(1,1,n,dfn[top[u]],dfn[u],x);
        u=fa[top[u]];
    }
    if(deep[u]<deep[v])
        swap(u,v);
    T.updata1(1,1,n,dfn[v],dfn[u],x);
}
void LCA_updata2(int u,int v,int x)
{
    while(top[u]!=top[v])
    {
        if(deep[top[u]]<deep[top[v]])
            swap(u,v);
        T.updata2(1,1,n,dfn[top[u]],dfn[u],x);
        u=fa[top[u]];
    }
    if(deep[u]<deep[v])
        swap(u,v);
    T.updata2(1,1,n,dfn[v],dfn[u],x);
}
int LCA_query(int u,int v)
{
    int res=-INF;
    while(top[u]!=top[v])
    {
        if(deep[top[u]]<deep[top[v]])
            swap(u,v);
        res=max(res,T.query(1,1,n,dfn[top[u]],dfn[u]));
        u=fa[top[u]];
    }
    if(deep[u]<deep[v])
        swap(u,v);
    return max(res,T.query(1,1,n,dfn[v],dfn[u]));
}
signed main()
{
    cin>>n;
    for(int i=1;i<n;i++)
    {
        cin>>x[i].u>>x[i].v>>x[i].w;
        build(x[i].u,x[i].v);
    }
    DFS1(1,0);
    for(int i=1;i<n;i++)
    {
        if(deep[x[i].u]<deep[x[i].v])
            a[x[i].v]=x[i].w;
        else a[x[i].u]=x[i].w;
    }
    DFS2(1);
    T.build(1,1,n,b);
    for(;;)
    {
        cin>>op;
        if(op=="Stop")break;
        cin>>u;
        if(op=="Change")
        {
            cin>>k;
            if(deep[x[u].u]<deep[x[u].v])
                T.updata1(1,1,n,dfn[x[u].v],dfn[x[u].v],k);
            else T.updata1(1,1,n,dfn[x[u].u],dfn[x[u].u],k);
        }
        if(op=="Cover")
        {
            cin>>v>>k;
            LCA_updata1(u,v,k);
        }
        if(op=="Add")
        {
            cin>>v>>k;
            LCA_updata2(u,v,k);
        }
        if(op=="Max")
        {
            cin>>v;
            cout<<LCA_query(u,v)<<'\n';
        }
    }
    return 0;
}