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=,fh=;char c=getchar();
     while(c<''||c>''){if(c=='-')fh=-;c=getchar();}
     while(c>=''&&c<=''){ret=ret*+c-'';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]=;
     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+],,sizeof(f[tot+]));
     for(i=tot;i;i--)
     {
         x=id[i]; c=C[x]; d=D[x]; w=W[x];
         memcpy(f[i],f[ed[x]+],sizeof(f[i]));
         for(j=;j<c;j++)
         {
             hd=,tl=,que[++tl]=;
             for(k=;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+][que[hd]*c+j]+(k-que[hd])*w);
                 while(hd<=tl&&f[i+][k*c+j]-k*w>=f[i+][que[tl]*c+j]-que[tl]*w)
                     tl--;
                 que[++tl]=k;
             }
         }
     }
     for(j=;j<=K;j++) ans=max(ans,f[][j]);
 }
 void main_dfs(int u)
 {
     int j,v;
     use[u]=; tot=,lim[u]=K;
     dfs_pre(u,-);
     calc(u);
     for(j=E.head[u];j;j=E.nxt[j])
     {
         v=E.to[j]; if(use[v]) continue;
         mi=inf,G=,gra(v,u,);
         main_dfs(G);
     }
 }
 void MAIN()
 {
     dfs_pre(,-);
     mi=inf,G=,gra(,-,);
     main_dfs(G);
 }
 void init()
 {
     tot=,E.cte=,ans=;
     memset(use,,sizeof(use));
     memset(E.head,,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=;i<=n;i++) W[i]=gint();
         for(i=;i<=n;i++) C[i]=gint();
         for(i=;i<=n;i++) D[i]=gint();
         for(i=;i<n;i++)
         {
             x=gint(), y=gint();
             E.ae(x,y),E.ae(y,x);
         }
         MAIN();
         printf("%d\n",ans);
     }
     return ;
 }