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

传送门

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

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

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

那么对于一条路径\((u,v)\)，它的权值就是\(b_{LCA(u,v)}+\sum_{i\in(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]='\n';
}
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;
}

原文地址：https://www.cnblogs.com/bztMinamoto/p/10237382.html

时间： 2024-08-11 16:06:50

uoj#268. 【清华集训2016】数据交互（动态dp+堆）的相关文章

UOJ268 [清华集训2016] 数据交互 【动态DP】【堆】【树链剖分】【线段树】

题目分析: 不难发现可以用动态DP做. 题目相当于是要我求一条路径,所有与路径有交的链的代价加入进去,要求代价最大. 我们把链的代价分成两个部分:一部分将代价加入$LCA$之中,用$g$数组保存:另一部分将代价加在整条链上,用$d$数组保存. 这时候我们可以发现,一条从$u$到$v$的路径的代价相当于是$d[LCA(u,v)]+\sum_{x \in edge(u,v)}g[x]$. 如果是静态的,可以用树形DP解决. 看过<神奇的子图>的同学都知道,叶子结点是从它的儿子中取两个最大的出来,所

bzoj 4736 /uoj274【清华集训2016】温暖会指引我们前行 lct

[清华集训2016]温暖会指引我们前行 统计 描述 提交 自定义测试 寒冬又一次肆虐了北国大地 无情的北风穿透了人们御寒的衣物 可怜虫们在冬夜中发出无助的哀嚎 “冻死宝宝了!” 这时 远处的天边出现了一位火焰之神 “我将赐予你们温暖和希望!” 只见他的身体中喷射出火焰之力 通过坚固的钢铁,传遍了千家万户 这时,只听见人们欢呼 “暖气来啦!” 任务描述 虽然小R住的宿舍楼早已来了暖气,但是由于某些原因,宿舍楼中的某些窗户仍然开着(例如厕所的窗户),这就使得宿舍楼中有一些路上的温度还是很低. 小R的

【UOJ274】【清华集训2016】温暖会指引我们前行 LCT

[UOJ274][清华集训2016]温暖会指引我们前行 任务描述 虽然小R住的宿舍楼早已来了暖气,但是由于某些原因,宿舍楼中的某些窗户仍然开着(例如厕所的窗户),这就使得宿舍楼中有一些路上的温度还是很低. 小R的宿舍楼中有n个地点和一些路,一条路连接了两个地点,小R可以通过这条路从其中任意一个地点到达另外一个地点.但在刚开始,小R还不熟悉宿舍楼中的任何一条路,所以他会慢慢地发现这些路,他在发现一条路时还会知道这条路的温度和长度.每条路的温度都是互不相同的. 小R需要在宿舍楼中活动,每次他都需要从

【UOJ】#273. 【清华集训2016】你的生命已如风中残烛

题目链接:http://uoj.ac/problem/273 $${Ans=\frac{\prod _{i=1}^{m}i}{w-n+1}}$$ 1 #include<iostream> 2 #include<cstdio> 3 #include<algorithm> 4 #include<vector> 5 #include<cstdlib> 6 #include<cmath> 7 #include<cstring> 8

UOJ 274 【清华集训2016】温暖会指引我们前行 ——Link-Cut Tree

魔法森林高清重置, 只需要维护关于t的最大生成树,然后链上边权求和即可. 直接上LCT 调了将近2h 吃枣药丸 #include <cstdio> #include <cstring> #include <iostream> #include <algorithm> using namespace std; #define F(i,j,k) for (int i=j;i<=k;++i) #define D(i,j,k) for (int i=j;i&g

uoj#269. 【清华集训2016】如何优雅地求和（数论）

传送门 首先,如果\(f(x)=1\),那么根据二项式定理,有\(Q(f,n,k)=1\) 当\(f(x)=x\)的时候,有\[Q=\sum_{i=0}^ni\times \frac{n!}{i!(n-i)!}k^i(1-k)^{n-i}\] \[Q=\sum_{i=0}^nnk\times \frac{(n-1)!}{(i-1)!(n-i)!}k^{i-1}(1-k)^{n-i}\] \[Q=nk\sum_{i=0}^n\frac{(n-1)!}{(i-1)!(n-i)!}k^{i-1}(1-

uoj#273. 【清华集训2016】你的生命已如风中残烛（组合数学）

传送门 一道打表题 我们把那些普通牌的位置看成\(-1\),那么就是要求有多少个排列满足前缀和大于等于\(1\) 考虑在最后放一个\(-1\),那么就是除了\(m+1\)的位置前缀和都要大于等于\(1\) \(m+1\)个数的圆排列的方案数为\(m!\),然后对于每一个圆排列,肯定存在一个前缀和最小且最右边的位置,那么它后面的所有位置肯定前缀和都大于等于\(1\),而对于这个位置如果不把它放最后肯定会有前缀和小于\(1\) 所以对于每一种圆排列有且仅有一种摆放方式合法 然而此时最后的这个\(-1

UOJ#272. 【清华集训2016】石家庄的工人阶级队伍比较坚强

传送门 设运算 \(op1,op2\),一个表示三进制不进位的加法,一个表示不退位的减法 设 \(cnt1[x],cnt2[x]\) 分别表示 \(x\) 转成三进制后 \(1/2\) 的个数 那么 \(f_{i,x}=\sum f_{i-1,y}b_{cnt1[x~op2~y],cnt2[x~op2~y]}\) 设 \(B_{x,y}=b_{cnt1[x~op2~y],cnt2[x~op2~y]}\) 那么可以发现 \(B_{x,y}=B_{x~op2~y,0}\) 那么我们要求的就是 \(f

UOJ #276. 【清华集训2016】汽水

TMD写了一篇博客竟然还不够清醒,那就再写一篇睡觉去了 首先一看题目就会发现这可以先套上个分数规划,即我们现在要最小化\(|\frac{\sum_{i=1}^{len} w_i}{len}-k|\) 考虑二分答案\(x\),顺便拆掉绝对值,即\(-x\le\frac{\sum_{i=1}^{len} w_i}{len}-k\le x\),发现其实只要同时满足: \[\sum_{i=1}^{len} w_i-k+x \ge 0\] \[\sum_{i=1}^{len} w_i-k-x \le 0\