动态 DP

一道入门 DP + 修改 = 动态 DP。

以模板题为例，多次询问树的最大独立集，带修改。

先有 naive 的 DP，记 \(f_{u,0/1}\) 表示 \(u\) 点不选/选时以 \(u\) 为根的子树的最大独立集权值，有

\[\begin{cases}f_{u,0}=\sum\limits_{v\in \operatorname{son}u}\max\{f_{v,0},f_{v,1}\} \\ f_{u,1}=w_u+\sum\limits_{v\in\operatorname{son}u}f_{v,0}\end{cases}
\]

修改一个点的权值，只有这个点到根结点的 DP 值发生了变化，于是我们考虑重链剖分来快速转移。

说到快速转移，又想到了用矩阵。所以我们先来把转移方程改成可用矩阵转移的形式。再记两个 DP 值

\[\begin{cases}g_{u,0}=\sum\limits_{v\in\operatorname{lson}u}\max\{f_{v,0},f_{v,1}\} \\ g_{u,1}=w_u+\sum\limits_{v\in\operatorname{lson}u}f_{v,0}\end{cases}
\]

\(\operatorname{lson}u\) 表示 \(u\) 的所有轻儿子。这样做的目的是将轻重儿子的转移分开，更好维护。

现在重写转移方程

\[\begin{cases}f_{u,0}=g_{u,0}+\max\{f_{\operatorname{hson}u,0},f_{\operatorname{hson}u,1}\} \\ f_{u,1}=g_{u,1}+f_{\operatorname{hson}u,0}\end{cases}
\]

\(\operatorname{son}u\) 表示 \(u\) 的重儿子。这样我们就丢掉了烦人的 \(\sum\) 了。

上面的转移形式很像矩阵 \(A_{i,j}=\max\limits_{k}\{B_{i,k}+C_{k,j}\}\) 的转移形式，所以我们用这个新定义的矩阵乘法来重写刚才的式子（记 \(v=\operatorname{hson}u\)）：

\[\begin{bmatrix}f_{u,0} \\ f_{u,1}\end{bmatrix}=\begin{bmatrix}g_{u,0} & g_{u,0} \\ g_{u,1} & -\infty\end{bmatrix}\begin{bmatrix}f_{v,0} \\ f_{v,1}\end{bmatrix}
\]

这样写后，一个点的 DP 值就等于这个点所在重链的叶子结点的矩阵乘这条链上的所有的转移矩阵，这个可以用线段树来维护。修改时沿着链向上跳，线段树上单点修改即可。

更多细节详见代码（注释自我感觉跟详细）

#include <bits/stdc++.h>
using namespace std;

const int N=1e5+5;
struct matrix
{
    int a[2][2];
    matrix() {memset(a,0xcf,sizeof(a));}
    int* const operator[](const int i) {return a[i];}
    const int* const operator[](const int i) const {return a[i];}
    matrix operator*(matrix b)
    {
        matrix c;
        for(int i=0;i<2;++i)
            for(int j=0;j<2;++j)
                for(int k=0;k<2;++k)
                    c[i][j]=max(c[i][j],a[i][k]+b[k][j]);
        return c;
    }
}g[N],t[N<<2];//g[]是转移矩阵，t[]是线段树
int n,Q,son[N],siz[N],dfn[N],id[N],fa[N],ids,top[N],nd[N];
//id[]是这个点的dfs序，dfn[]是id[]的逆映射，nd[]只有在链顶有定义，代表这条链的底的dfs序
int f[N][2],w[N];//f[]是 DP 值
vector<int> G[N];

void dfs1(int u,int faz)
{
    siz[u]=1,fa[u]=faz;
    for(int v:G[u]) if(v!=faz)
    {
        dfs1(v,u),siz[u]+=siz[v];
        if(siz[v]>siz[son[u]]) son[u]=v;
    }
}

void dfs2(int u,int tp)
{
    top[u]=tp,id[u]=++ids,dfn[ids]=u;
    //按照定义初始化矩阵和 DP 值
    g[u][0][0]=g[u][0][1]=0;
    g[u][1][0]=f[u][1]=w[u],nd[tp]=max(nd[tp],ids);
    if(son[u])
    {
        dfs2(son[u],tp);
        f[u][0]+=max(f[son[u]][0],f[son[u]][1]);
        f[u][1]+=f[son[u]][0];
    }
    for(int v:G[u]) if(v!=fa[u]&&v!=son[u])
    {
        dfs2(v,v);
        f[u][0]+=max(f[v][0],f[v][1]);
        g[u][0][0]+=max(f[v][0],f[v][1]);
        f[u][1]+=f[v][0],g[u][0][1]=g[u][0][0];
        g[u][1][0]+=f[v][0];
        //按照定义转移即可
    }
}

//下面的线段树维护的是链上的转移矩阵之积
void build(int rt,int l,int r)
{
    if(l==r) {t[rt]=g[dfn[l]]; return;}
    int mid=l+r>>1;
    build(rt<<1,l,mid),build(rt<<1|1,mid+1,r);
    t[rt]=t[rt<<1]*t[rt<<1|1];
}

void upd(int rt,int lc,int rc,int p)
{
    if(lc==rc) {t[rt]=g[dfn[lc]]; return;}
    int mid=lc+rc>>1;
    if(p<=mid) upd(rt<<1,lc,mid,p);
    else upd(rt<<1|1,mid+1,rc,p);
    t[rt]=t[rt<<1]*t[rt<<1|1];
}

matrix query(int rt,int lc,int rc,int l,int r)
{
    if(l<=lc&&r>=rc) return t[rt];
    int mid=lc+rc>>1;
    if(r<=mid) return query(rt<<1,lc,mid,l,r);
    else if(l>mid) return query(rt<<1|1,mid+1,rc,l,r);
    else return query(rt<<1,lc,mid,l,r)*query(rt<<1|1,mid+1,rc,l,r);
}

void upd_val(int x,int y)
{
    g[x][1][0]+=y-w[x],w[x]=y; //先将自己的值修改了
    matrix bef,aft; //需要分别记修改前后的转移矩阵，靠这个差值更新
    while(x)
    {
        bef=query(1,1,n,id[top[x]],nd[top[x]]);
        upd(1,1,n,id[x]);
        aft=query(1,1,n,id[top[x]],nd[top[x]]);
        x=fa[top[x]]; //这个点是链顶的父亲，所以这条链对于父亲来说是一条轻链，所以父亲的矩阵必须修改
        g[x][0][0]+=max(aft[0][0],aft[1][0])-max(bef[0][0],bef[1][0]);
        g[x][0][1]=g[x][0][0],g[x][1][0]+=aft[0][0]-bef[0][0];
    }
}

int main()
{
    scanf("%d%d",&n,&Q);
    for(int i=1;i<=n;++i) scanf("%d",w+i);
    for(int i=1,a,b;i<n;++i)
    {
        scanf("%d%d",&a,&b);
        G[a].push_back(b),G[b].push_back(a);
    }
    dfs1(1,0),dfs2(1,1),build(1,1,n);
    for(int i=1,x,y;i<=Q;++i)
    {
        scanf("%d%d",&x,&y);
        upd_val(x,y);
        matrix ans=query(1,1,n,id[1],nd[1]);
        //注意到一个点的 DP 值就是这个点所在链的底到这个点的转移矩阵之积
        //似乎我们在 dfs 后就一直没有用 f[] 了？因为每个叶子结点
        //的转移矩阵刚好与其 f[] 值相等，所以我们不需要了
        printf("%d\n",max(ans[0][0],ans[1][0]));
    }
    return 0;
}