uoj#268. 清华集训2016数据交互（动态dp+堆）

Posted 2021-02-01 bztminamoto

传送门

动态dp我好像还真没咋做过……通过一个上午的努力光荣的获得了所有AC的人里面的倒数rk3

首先有一个我一点也不觉得显然的定理，如果两条路径相交，那么一定有一条路径的(LCA)在另一条路径上

于是我们可以对于每一个点记录两个值，一个(a_i)表示(LCA)在(i)点的所有路径的权值之和，一个是(b_i)，表示经过点(i)且(LCA)不在点(i)的所有路径的权值之和

那么对于一条路径((u,v))，它的权值就是(b_{LCA(u,v)}+sum_{iin(u,v)}a_i)

我们先把树给轻重链剖分，记(u)为路径中深度最浅的点也就是(LCA)，记(v)为与(u)在同一条重链中且深度最大的点，那么整条路径是由(v)引出的一条链（可以为空）(+uv)之间的重链(+u)引出的一条链（可以为空）组成记(g_u)为(u)的某个轻儿子的(sum a)最大值，那么一条路径的权值就是(g_u+g_v+w_{u,v}+b_u)，其中(w_{u,v})为重链上(uv)路径上所有点的(a)之和（注意，如果(u=v)，那么就是(u)引出去的最长链加次长链）

对于链的插入，把(LCA)的(a)单点修改，然后把除(LCA)外的点的(b)整体修改。因为在答案中(b)只与(u)有关，也就是说只与区间的左端点有关，那么我们可以在线段树上打标记到时候再下传。对于答案，就是一个连续最大和的形式再加上(g_u,g_v,b_u)，都可以在线段树上维护好，维护一下左右最值即可。因为查询的是整棵树的答案，我们可以对每条重链的答案都放到一个堆里整体查询。

因为改了(LCA)的(a)的时候它的所有祖先的(g_i)都会改变，所以我们要沿着重链往上跳并不断更改，对于每个点开一个可删堆来维护轻儿子的(sum a)

然后就是注意卡卡常……找个夜深人静的时候交……

//minamoto
#include<bits/stdc++.h>
#define R register
#define ls (p<<1)
#define rs (p<<1|1)
#define ll long long
#define fp(i,a,b) for(R int i=a,I=b+1;i<I;++i)
#define fd(i,a,b) for(R int i=a,I=b-1;i>I;--i)
#define go(u) for(int i=head[u],v=e[i].v;i;i=e[i].nx,v=e[i].v)
inline ll max(const R ll &x,const R ll &y){return x>y?x:y;}
inline void swap(R ll &x,R ll &y){x^=y^=x^=y;}
using namespace std;
char buf[1<<21],*p1=buf,*p2=buf;
inline char getc(){return p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++;}
int read(){
    R int res,f=1;R char ch;
    while((ch=getc())>'9'||ch<'0')(ch=='-')&&(f=-1);
    for(res=ch-'0';(ch=getc())>='0'&&ch<='9';res=res*10+ch-'0');
    return res*f;
}
inline char getop(){char ch;while((ch=getc())!='-'&&ch!='+');return ch;}
char sr[1<<21],z[20];int C=-1,Z=0;
inline void Ot(){fwrite(sr,1,C+1,stdout),C=-1;}
void print(R ll x){
    if(C>1<<20)Ot();if(x<0)sr[++C]='-',x=-x;
    while(z[++Z]=x%10+48,x/=10);
    while(sr[++C]=z[Z],--Z);sr[++C]='
';
}
const int N=1e5+5;
struct eg{int v,nx;}e[N<<1];int head[N],tot;
inline void add(R int u,R int v){e[++tot]={v,head[u]},head[u]=tot;}
int n,m;
struct Heap{
    priority_queue<ll>A,B;
    inline void push(R ll x){A.push(x);}
    inline void pop(R ll x){B.push(x);}
    ll top(){
        while(!B.empty()&&A.top()==B.top())A.pop(),B.pop();
        return A.empty()?0:A.top();
    }
    ll se(){
        while(!B.empty()&&A.top()==B.top())A.pop(),B.pop();
        if(A.empty())return 0;
        R ll x=A.top();A.pop();
        while(!B.empty()&&A.top()==B.top())A.pop(),B.pop();
        if(B.empty())return A.push(x),0;
        R ll y=A.top();A.push(x);
        return y;
    }
}g[N],ans;
struct tree{
    int dfn[N],top[N],end[N],sz[N],son[N],fa[N],dep[N],rk[N];
    int cnt;
    void dfs1(int u){
        sz[u]=1,dep[u]=dep[fa[u]]+1;
        go(u)if(v!=fa[u]){
            fa[v]=u,dfs1(v),sz[u]+=sz[v];
            if(sz[v]>sz[son[u]])son[u]=v;
        }
    }
    void dfs2(int u,int t){
        top[u]=t,dfn[u]=end[u]=++cnt,rk[cnt]=u;
        if(!son[u])return(void)(ans.push(0));
        dfs2(son[u],t),end[u]=end[son[u]];
        go(u)if(v!=fa[u]&&v!=son[u])g[u].push(0),dfs2(v,v);
    }
    int LCA(int u,int v){
        while(top[u]!=top[v]){
            if(dep[top[u]]<dep[top[v]])swap(u,v);
            u=fa[top[u]];
        }return dep[u]<=dep[v]?u:v;
    }
    struct node{
        ll lv,rv,sum,mx;
        node(){lv=rv=sum=mx=0;}
        node operator +(const node &b){
            node res;
            res.lv=max(lv,sum+b.lv);
            res.rv=max(b.rv,b.sum+rv);
            res.sum=sum+b.sum;
            res.mx=max(max(mx,b.mx),rv+b.lv);
            return res;
        }
    }tr[N<<2];
    ll tag[N<<2],gg[N<<2],se[N<<2];
    inline void ppd(R int p,R ll v){tag[p]+=v,tr[p].rv+=v,tr[p].mx+=v;}
    inline void pd(R int p){
        if(tag[p]){
            ppd(ls,tag[p]),ppd(rs,tag[p]);
            tag[p]=0;
        }
    }
    void update_s(int p,int l,int r,int x,int op,ll v){
        if(l==r){
            if(!op){
                tr[p].lv+=v,tr[p].rv+=v,tr[p].sum+=v,tr[p].mx+=v;
            }else if(op==1){
                ll y=v-gg[p];gg[p]=v;
                tr[p].lv+=y,tr[p].rv+=y,tr[p].mx+=y;
            }else{
                ll y=v-se[p];se[p]=v;
                tr[p].mx+=y;
            }return;
        }
        int mid=(l+r)>>1;pd(p);
        x<=mid?update_s(ls,l,mid,x,op,v):update_s(rs,mid+1,r,x,op,v);
        tr[p]=tr[ls]+tr[rs];
    }
    void update_tag(int p,int l,int r,int ql,int qr,ll v){
        if(ql<=l&&qr>=r)return ppd(p,v);
        int mid=(l+r)>>1;pd(p);
        if(ql<=mid)update_tag(ls,l,mid,ql,qr,v);
        if(qr>mid)update_tag(rs,mid+1,r,ql,qr,v);
        tr[p]=tr[ls]+tr[rs];
    }
    node query(int p,int l,int r,int ql,int qr){
        if(ql<=l&&qr>=r)return tr[p];
        int mid=(l+r)>>1;pd(p);
        if(qr<=mid)return query(ls,l,mid,ql,qr);
        if(ql>mid)return query(rs,mid+1,r,ql,qr);
        return query(ls,l,mid,ql,qr)+query(rs,mid+1,r,ql,qr);
    }
    ll tans[N];
    void jump(int u,int lca,int w){
        int x=u;
        for(;u;u=fa[top[u]]){
            int p=fa[top[u]];
            node res=query(1,1,n,dfn[top[u]],end[u]);
            g[p].pop(res.lv);
            if(tans[top[u]])ans.pop(tans[top[u]]);
            if(u==x&&!lca)update_s(1,1,n,dfn[u],0,w);
            else{
                if(lca){
                    int l=max(dfn[top[u]],dfn[lca]+1);
                    if(l<=dfn[u])update_tag(1,1,n,l,dfn[u],w);
                }update_s(1,1,n,dfn[u],1,g[u].top());
            }
            if(g[u].se()!=-1)update_s(1,1,n,dfn[u],2,g[u].se());
            res=query(1,1,n,dfn[top[u]],end[u]);
            g[p].push(res.lv);
            ans.push(tans[top[u]]=res.mx);
        }
    }
    void update(int u,int v,int w){
        int lca=LCA(u,v);
        jump(lca,0,w);
        jump(u,lca,w);
        jump(v,lca,w);
    }
}T;
struct qaq{
    int quq[N],qvq[N],qwq[N];
    int u,v,tim;char op;
    void MAIN(){
        n=read(),m=read();
        fp(i,1,n-1)u=read(),v=read(),add(u,v),add(v,u);
        T.dfs1(1),T.dfs2(1,1);
        fp(i,1,m){
            op=getop();
            if(op=='+'){
                quq[i]=read(),qvq[i]=read(),qwq[i]=read();
                T.update(quq[i],qvq[i],qwq[i]);
            }else tim=read(),T.update(quq[tim],qvq[tim],-qwq[tim]);
            print(ans.top());
        }
    }
}loli;
int main(){
//  freopen("testdata.in","r",stdin);
//  freopen("testdata.out","w",stdout);
    loli.MAIN();
    return Ot(),0;
}