前言：

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

动态DP

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

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

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

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

全局平衡二叉树

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

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

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

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

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

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

这样，可以发现，对于任意一个点，其上方所有重链的深度之和是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());
    }
}