【总结】动态DP&全局平衡二叉树

本文主要介绍了动态DP的概念,指出其是树剖DDP算法的加速形式,适用于部分可并转移的DP问题,并提及动态DP的题目通常会提供普通DP解法作为备选。接着讲解了全局平衡二叉树,这是一种优化树剖重链处理的方法,通过构造特定二叉树结构,确保从任意节点到根节点经过的重链总长度为logN,从而提高效率。最后提到了一道相关的板子题——洛谷P4719。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

前言:

本算法是树剖DDP算法的加速版,复杂度更小(不是特意卡树剖其实看不出来),
但还是比较好写,因此在这里提一下


动态DP

动态DP听起来很黑科技,但其实并不难

首先,能动态的DP本身就很少,需要满足很多限制

而且一般动态DP的题都会给普通DP留部分分,如果有暴力写得好的,甚至可以在低风险下拿到和DDP差不多的分。

扯回正题,动态DP就是把常规DP的转移用矩阵(其实不一定是矩阵,用数据结构特有的维护方式也行,如线段树的区间标记什么的),使得转移可并,然后就能快速地用矩阵加速or树剖解决。

全局平衡二叉树

这玩意感觉没什么用,不过代码挺好写的可以学学

首先,树剖的复杂度是O(Nlog2N)O(Nlog^2N)O(Nlog2N)的,这在一些题目中会被卡

其慢就慢在重链有logNlogNlogN条,每条上面都是logNlogNlogN的复杂度处理。

所以,其效率的瓶颈就在于重链的处理上。

那么,全局平衡二叉树,就是用于优化重链的处理:
对于一条重链,把它按照划分重心的方式,建一颗二叉树。

换言之,第一层的根节点,是整个树链的重心(这里计算重心要包括轻子树的大小,所以是带权重心),然后它的左右儿子是它左右两个子链的重心……

这样,可以发现,对于任意一个点,其上方所有重链的深度之和是logN的!换言之,从任意一个点出发,一定能经过logN条轻边,logN条重链上的二叉边,到达根节点。

这个很显然,就不证明了

板子题

洛谷 P4719

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#define SF scanf
#define PF printf
#define MAXN 100010
#define INF 0x3FFFFFFF
using namespace std;
int n,m;
struct Matrix{
    int num[2][2];
    Matrix operator *(const Matrix &a) const {
        Matrix tmp;
        tmp.num[0][0]=tmp.num[0][1]=tmp.num[1][0]=tmp.num[1][1]=-INF;
        for(int k=0;k<2;k++)
            for(int i=0;i<2;i++)
                for(int j=0;j<2;j++)
                    tmp.num[i][j]=max(tmp.num[i][j],num[i][k]+a.num[k][j]);
        return tmp;
    }
    int maxv(){
        return max(num[0][0],num[0][1]);	
    }
}w[MAXN],mul[MAXN];
vector<int> a[MAXN];
int s[MAXN][2];
int siz[MAXN],son[MAXN],lsiz[MAXN];
void dfs(int x){
    siz[x]=1;
    for(int i=0;i<int(a[x].size());i++){
        int u=a[x][i];
        if(siz[u])
            continue;
        dfs(u);
        siz[x]+=siz[u];
        if(siz[u]>siz[son[x]])
            son[x]=u;
    }
    lsiz[x]=siz[x]-siz[son[x]];
}
void pushup(int x){
    if(s[x][0])
        mul[x]=mul[s[x][0]]*w[x];
    else
        mul[x]=w[x];
    if(s[x][1])
        mul[x]=mul[x]*mul[s[x][1]];
}
int fa[MAXN];
void setchild(int u,int v){
    w[u].num[1][0]+=mul[v].maxv();
    w[u].num[0][0]=w[u].num[1][0];
    w[u].num[0][1]+=mul[v].num[0][0];
    fa[v]=u;
}
bool used[MAXN];
int st[MAXN],tp;
int build(int l,int r){
    if(l>r)
        return 0;
    int tots=0,pres=0;
    for(int i=l;i<=r;i++)
        tots+=lsiz[st[i]];
    for(int i=l;i<=r;i++){
        pres+=lsiz[st[i]];
        if(pres*2>=tots){
            int x=st[i];
            s[x][0]=build(l,i-1);
            if(s[x][0])
                fa[s[x][0]]=x;
            s[x][1]=build(i+1,r);
            if(s[x][1])
                fa[s[x][1]]=x;
            pushup(st[i]);
            return st[i];
        }
    }
}
int build_tree(int x){
    for(int i=x;i;i=son[i])
        used[i]=1;	
    for(int i=x;i;i=son[i])
        for(int j=0;j<int(a[i].size());j++){
            int u=a[i][j];
            if(used[u])
                continue;
            int ls=build_tree(u);
            setchild(i,ls);
        }
    tp=0;
    for(int i=x;i;i=son[i])
        st[++tp]=i;
    reverse(st+1,st+1+tp);
    return build(1,tp);
}
int val[MAXN];
void Change(int u,int Val){
    w[u].num[0][1]+=Val-val[u],val[u]=Val;
    for(int i=u;i;i=fa[i]){
        if(fa[i]&&s[fa[i]][0]!=i&&s[fa[i]][1]!=i){
            w[fa[i]].num[1][0]-=mul[i].maxv();
            w[fa[i]].num[0][0]=w[fa[i]].num[1][0];
            w[fa[i]].num[0][1]-=mul[i].num[0][0];
            pushup(i);
            w[fa[i]].num[1][0]+=mul[i].maxv();
            w[fa[i]].num[0][0]=w[fa[i]].num[1][0];
            w[fa[i]].num[0][1]+=mul[i].num[0][0];
        }
        else
            pushup(i);
    }
}
int main(){
    SF("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        SF("%d",&val[i]);
        w[i].num[0][1]=val[i];
        w[i].num[1][1]=-INF;
    }
    int u,v;
    for(int i=1;i<n;i++){
        SF("%d%d",&u,&v);
        a[u].push_back(v);
        a[v].push_back(u);	
    }
    dfs(1);
    int rt=build_tree(1);
    int Val;
    for(int i=1;i<=m;i++){
        SF("%d%d",&u,&Val);
        Change(u,Val);
        PF("%d\n",mul[rt].maxv());
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值