BZOJ 4182 Shopping (点分治+树上多重背包)

题目大意：给你一颗树，你有$m$元钱，每个节点都有一种物品，价值为$w$，代价为$c$，有$d$个，如果在$u$和$v$两个城市都购买了至少一个物品，那么$u,v$路径上每个节点也都必须买至少一个物品

单调队列数组开小了调了2h

通过这道题，本蒟蒻终于$get$到了树上带权背包的正确姿势

合并背包的代价是$O(m^{2})$的，非常不友好，而在序列上处理背包时，是不需要合并背包的，所以我们把树拍成$dfs$序

显然，树上背包需要用子节点更新父节点的信息，所以倒序枚举时间戳$i$

设$f[i][j]$表示时间戳为$i$，总代价为$j$时，所有时间戳$>=i$的节点，树上背包能得到的最大价值，令$x$表示时间戳为$i$的节点编号

如果不选节点$x$，那么它子树内的节点都不能选，为了保证$f[i]$是$i$后面所有节点构成的最优解，所以跳过$x$子树的状态，用$f[ed_{x}+1]$更新$f[i]$，$ed_{x}$表示节点$x$的出栈时间

如果选节点$x$，那么可以选$x$的子树内的节点，用$f[i+1]$更新$f[i]$

两者取最优解即可

树上带权$01$背包的时间被我们优化成了$O(nm)$

多重背包可以用单调队列优化，时间一样是$O(nm)$

而上面的$dp$方程仅适用于必须链并经过根节点的情况

所以使用点分治每次选择一个重心作为根跑$DP$

总时间$O(Tnmlogn)$

代码巨丑

#include <cmath>
#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define N1 510
#define M1 4010
#define ll long long
#define inf 233333333
using namespace std;

int gint()
{
    int ret=0,fh=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')fh=-1;c=getchar();}
    while(c>='0'&&c<='9'){ret=ret*10+c-'0';c=getchar();}
    return ret*fh;
}
int n,K,T;
struct Edge{
int to[M1],nxt[M1],head[N1],cte;
void ae(int u,int v)
{cte++;to[cte]=v,nxt[cte]=head[u],head[u]=cte;}
}E;

int W[N1],C[N1],D[N1];
int st[N1],ed[N1],id[N1],tot;
int sz[N1],lim[N1];
int use[N1],mi,G;
void gra(int u,int dad,int szfa)
{
    int j,v,ma=szfa;
    if(szfa>mi) return;
    for(j=E.head[u];j;j=E.nxt[j])
    {
        v=E.to[j]; if(use[v]||v==dad) continue;
        ma=max(ma,sz[v]);
        gra(v,u,szfa+sz[u]-sz[v]);
    }
    if(ma<mi) mi=ma,G=u;
}
void dfs_pre(int u,int dad)
{
    int j,v; sz[u]=0;
    st[u]=++tot; id[tot]=u;
    for(j=E.head[u];j;j=E.nxt[j])
    {
        v=E.to[j]; if(use[v]||v==dad) continue;
        lim[v]=lim[u]-C[u]; 
        dfs_pre(v,u); sz[u]+=sz[v];
    }
    sz[u]++; ed[u]=tot;
}
int que[M1],hd,tl;
int f[N1][M1],ans,de;
void calc(int u)
{
    int i,j,k,p,x,w,d,c;
    memset(f[tot+1],0,sizeof(f[tot+1]));
    for(i=tot;i;i--)
    {
        x=id[i]; c=C[x]; d=D[x]; w=W[x]; 
        memcpy(f[i],f[ed[x]+1],sizeof(f[i]));
        for(j=0;j<c;j++)
        {
            hd=1,tl=0,que[++tl]=0;
            for(k=1;k*c+j<=lim[x];k++)
            {
                while(hd<=tl&&k-que[hd]>d)
                    hd++;
                f[i][k*c+j]=max(f[i][k*c+j],f[i+1][que[hd]*c+j]+(k-que[hd])*w);
                while(hd<=tl&&f[i+1][k*c+j]-k*w>=f[i+1][que[tl]*c+j]-que[tl]*w)
                    tl--;
                que[++tl]=k;
            }
        }
    }
    for(j=0;j<=K;j++) ans=max(ans,f[1][j]);
}
void main_dfs(int u)
{
    int j,v;
    use[u]=1; tot=0,lim[u]=K;
    dfs_pre(u,-1);
    calc(u);
    for(j=E.head[u];j;j=E.nxt[j])
    {
        v=E.to[j]; if(use[v]) continue;
        mi=inf,G=0,gra(v,u,0);
        main_dfs(G);
    }
}
void MAIN()
{
    dfs_pre(1,-1); 
    mi=inf,G=0,gra(1,-1,0);
    main_dfs(G);
}
void init()
{
    tot=0,E.cte=0,ans=0;
    memset(use,0,sizeof(use));
    memset(E.head,0,sizeof(E.head));
}

int main()
{
    freopen("t2.in","r",stdin);
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&K);
        int i,x,y,z; init();
        for(i=1;i<=n;i++) W[i]=gint();
        for(i=1;i<=n;i++) C[i]=gint();
        for(i=1;i<=n;i++) D[i]=gint();
        for(i=1;i<n;i++)
        {
            x=gint(), y=gint();
            E.ae(x,y),E.ae(y,x);
        }
        MAIN();
        printf("%d
",ans);
    }
    return 0;
}