动态dp 板子

动态dp

瞎扯两句吧

先从序列上理解，维护链的最大独立集。

考虑是从左边转移的，那么矩阵的转移唯一，直接放在线段树上就可以了。

放在树上的话，儿子都可以转移，把轻儿子的转移放在子链链头更新，然后每条链都处理成序列就行了。

注意一点，因为维护的是序列，所以单点存放的矩阵是只含轻儿子和自己的贡献，相当于把轻儿子的子树缩给了自己，而重儿子维护的东西是通过线段树上维护的区间贡献过来的。

---

咕咕模板，最大全独立集

Code:

#include <cstdio>

#include <algorithm>

#include <cctype>

using std::max;

const int N=1e5+10;

const int inf=0x3f3f3f3f;

int n,m,v[N];

int read()

{

    int x=0,f=1;char c=getchar();

    while(!isdigit(c)) {if(c=='-')f=-f;c=getchar();}

    while(isdigit(c)) {x=x*10+c-'0';c=getchar();}

    return x*f;

}

int head[N],to[N<<1],Next[N<<1],cnt;

void add(int u,int v)

{

    to[++cnt]=v,Next[cnt]=head[u],head[u]=cnt;

}

int dfn[N],top[N],bot[N],siz[N],ha[N],f[N],ws[N],dfsclock,dp[N][2],len;

void dfs1(int now)

{

    ++siz[now],dp[now][1]=v[now];

    for(int v,i=head[now];i;i=Next[i])

        if((v=to[i])!=f[now])

        {

            f[v]=now,dfs1(v),siz[now]+=siz[v];

            dp[now][1]+=dp[v][0];

            dp[now][0]+=max(dp[v][0],dp[v][1]);

            if(siz[v]>siz[ws[now]]) ws[now]=v;

        }

}

void dfs2(int now,int anc)

{

    ha[dfn[now]=++dfsclock]=now;

    bot[top[now]=anc]=now;

    if(ws[now]) dfs2(ws[now],anc);

    for(int v,i=head[now];i;i=Next[i])

        if(!dfn[v=to[i]])

            dfs2(v,v);

    bot[now]=bot[anc];

}

struct matrix{int dx[2][2];}mx[N<<2],upt[N];

matrix operator *(matrix a,matrix b)

{

    matrix ret;

    ret.dx[0][0]=max(a.dx[0][0]+b.dx[0][0],a.dx[0][1]+b.dx[1][0]);

    ret.dx[0][1]=max(a.dx[0][0]+b.dx[0][1],a.dx[0][1]+b.dx[1][1]);

    ret.dx[1][0]=max(a.dx[1][0]+b.dx[0][0],a.dx[1][1]+b.dx[1][0]);

    ret.dx[1][1]=max(a.dx[1][0]+b.dx[0][1],a.dx[1][1]+b.dx[1][1]);

    return ret;

}

#define ls id<<1

#define rs id<<1|1

void build(int id,int l,int r)

{

    if(l==r)

    {

        int now=ha[l],g0=0,g1=v[now];

        for(int v,i=head[now];i;i=Next[i])

            if((v=to[i])!=ws[now]&&v!=f[now])

                g0+=max(dp[v][0],dp[v][1]),g1+=dp[v][0];

        upt[l]=mx[id]=(matrix){g0,g0,g1,-inf};

        return;

    }

    int mid=l+r>>1;

    build(ls,l,mid),build(rs,mid+1,r);

    mx[id]=mx[ls]*mx[rs];

}

matrix query(int id,int L,int R,int l,int r)

{

    if(l==L&&r==R) return mx[id];

    int Mid=L+R>>1;

    if(r<=Mid) return query(ls,L,Mid,l,r);

    else if(l>Mid) return query(rs,Mid+1,R,l,r);

    else return query(ls,L,Mid,l,Mid)*query(rs,Mid+1,R,Mid+1,r);

}

void change(int id,int l,int r,int p)

{

    if(l==r) {mx[id]=upt[l];return;}

    int mid=l+r>>1;

    if(p<=mid) change(ls,l,mid,p);

    else change(rs,mid+1,r,p);

    mx[id]=mx[ls]*mx[rs];

}

void modify(int now,int w)

{

    upt[dfn[now]].dx[1][0]+=w-v[now],v[now]=w;

    while(233)

    {

        matrix a=query(1,1,n,dfn[top[now]],dfn[bot[now]]);

        change(1,1,n,dfn[now]);

        matrix b=query(1,1,n,dfn[top[now]],dfn[bot[now]]);

        now=f[top[now]];

        if(!now) break;

        upt[dfn[now]].dx[0][0]+=max(b.dx[0][0],b.dx[1][0])-max(a.dx[0][0],a.dx[1][0]);

        upt[dfn[now]].dx[0][1]=upt[dfn[now]].dx[0][0];

        upt[dfn[now]].dx[1][0]+=b.dx[0][0]-a.dx[0][0];

    }

}

int main()

{

    n=read(),m=read();

    for(int i=1;i<=n;i++) v[i]=read();

    for(int u,v,i=1;i<n;i++) u=read(),v=read(),add(u,v),add(v,u);

    dfs1(1),dfs2(1,1),build(1,1,n);

    for(int u,w,i=1;i<=m;i++)

    {

        u=read(),w=read();

        modify(u,w);

        matrix ans=query(1,1,n,1,dfn[bot[1]]);

        printf("%d\n",max(ans.dx[0][0],ans.dx[1][0]));

    }

    return 0;

}

---

2019.1.2