BZOJ4182 shopping 点分治+多重背包单调队列优化

预备知识：会求重心，会多重背包的单调队列优化。

                            Shopping

            Time Limit: 30 Sec  Memory Limit: 128 MB

Description

马上就是小苗的生日了，为了给小苗准备礼物，小葱兴冲冲地来到了商店街。商店街有n个商店，
并且它们之间的道路构成了一颗树的形状。

第i个商店只卖第i种物品，小苗对于这种物品的喜爱度是wi，物品的价格为ci物品的库存是di。
但是商店街有一项奇怪的规定：如果在商店u,v买了东西，且有一个商店w在u到v的路径上，那么
必须要在商店w买东西。小葱身上有m元钱，他想要尽量让小苗开心，所以他希望最大化小苗对买
到物品的喜爱度之和。这种小问题对于小葱来说当然不在话下，但是他的身边没有电脑，于是他
打电话给同为OI选手的你，你能帮帮他吗？

Input
输入第一行一个正整数T，表示测试数据组数。
对于每组数据，
第一行两个正整数n;m；
第二行n个非负整数w1,w2...wn；
第三行n个正整数c1,c2...cn；
第四行n个正整数d1,d2...dn；

Output
输出共T 行，每行一个整数，表示最大的喜爱度之和。
Sample Input
1 
3 2
1 2 3
1 1 1
1 2 1
1 2
1 3
Sample Output
4

HINT
 N<=500,M<=4000,T<=5,Wi<=4000,Di<=100

这道题大概就是在树上做背包，并且选中的物品还要在一个联通块上，每个点的物品还可以取多个（有数量限制）。
怎么做呢？
首先考虑点分治，每次考虑重心必选的方案，不选的话就删除重心，递归处理。对于递归到的当前子树，我们以重心为根，因为重心必选，所以就变成了一个树形依赖背包（对于每个点，必须先选了它的父亲才能选它）。
那么，如果每个节点物品只有一个（也就是0|1背包），我们该怎么做呢？
我们可以以重心为根，深搜整棵子树，按dfs序存入数组base[]，并处理好每个店的子树大小sz[]，于是就有一个很经典的转移方程：

$$f[i][j] = max(f[i + 1][j - v[i]] + w[i], f[i + sz[i]][j])$$
$f[i][j]$表示i以及以后dfs序的点占用j的空间的最大价值。
前面是考虑选这个物品，就可以继续考虑他的儿子（第一个儿子->i + 1)，否则直接跳过整棵子树（同一棵子树的dfs序是连续的）。
0|1背包的话，到这里已经结束了，那么多重背包该怎么处理呢？
（一种做法是将多重背包二进制分组，可以将d个物品分成约logd组，总复杂度nmlognlogd)
这里给出一个更优的做法，那就是单调队列优化，复杂度nmlogn
这里是多重背包单调队列优化的代码，可以发现与平常的有些不同（因为要强制至少选一个）

见注释：

    int va[M], vb[M];
    For(j, 0, v - 1){
        int *pb = va, *pe = va - 1;
        int *qb = vb, *qe = vb - 1;
        for(int k = j, i = 0; k <= m; k += v, ++i){
            if(pe == pb + lim){
                if(*qb == *pb) ++qb;
                ++pb;
            }
            int tt = dp[now + 1][k] - i * w;
            if(i) dp[now][k] = *qb + i * w;
            //到了可以选的体积才更新（i > 0)。
            //先更新，再弹队，因为要强制选，所以要防止 k 取到 k(也就是没选）。
            while(qe >= qb && *qe <= tt) --qe;
            *++qe = tt; *++pe = tt;
        }
    }

于是，前面的就可以直接跑多重背包，后面的最后再取max即可。

最后，时刻更新ans即可；
还有，在清空dp数组的时候最好不要用memset，会T，不如for循环将有用状态逐个清空，这样清空的复杂度也是nmlogn的，很稳。

最后贴上未删减版代码：

#include<cstdio>
#include<cstring>

#define N 502
#define M 401
#define E 1005
#define For(a, b, c) for(int a = b; a <= c; ++a)
#define Forr(a, b, c) for(int a = b; a >= c; --a)
using namespace std;
const int inf = 1e9;
int n, m, wei[N], cost[N], cnt[N];

inline int max(int a, int b){ return a > b ? a : b; }

int e, be[N], to[E], ne[E];
inline void Add(int u, int v){
    to[++e] = v, ne[e] = be[u], be[u] = e;
}

int sz[N], f[N], rt, tot;
bool del[N];
inline void dfs1(int x, int fa){    //找重心
    sz[x] = 1, f[x] = 0;
    for(int i = be[x]; i; i = ne[i]){
        int v = to[i];
        if(v == fa || del[v]) continue;
        dfs1(v, x);
        sz[x] += sz[v];
        f[x] = max(f[x], sz[v]);
    }
    f[x] = max(f[x], tot - sz[x]);
    if(f[x] < f[rt]) rt = x;
}
int cod, base[N];
inline void dfs3(int x, int fa){   //处理sz[],base[]
    base[++cod] = x, sz[x] = 1;
    for(int i = be[x]; i; i = ne[i])
        if(to[i] != fa && !del[to[i]]) dfs3(to[i], x), sz[x] += sz[to[i]];
}

int dp[N][M], ans;
inline void Pack(int now, int v, int w, int lim){
//now -> 正在处理的物品   v -> 物品体积   w -> 物品价值   lim -> 物品数量
    if(lim == 1){    //0|1背包
        For(i, v, m) dp[now][i] = dp[now + 1][i - v] + w;
        return ;
    }
    if(lim * v > m - v){    //完全背包
        For(i, v, m) dp[now][i] = max(dp[now + 1][i - v], dp[now][i - v]) + w;
        return ;
    }
    //以上两个是用来优化常数的
    int va[M], vb[M];
    For(j, 0, v - 1){
        int *pb = va, *pe = va - 1;
        int *qb = vb, *qe = vb - 1;
        for(int k = j, i = 0; k <= m; k += v, ++i){
            if(pe == pb + lim){
                if(*qb == *pb) ++qb;
                ++pb;
            }
            int tt = dp[now + 1][k] - i * w;
            if(i) dp[now][k] = *qb + i * w;
            while(qe >= qb && *qe <= tt) --qe;
            *++qe = tt; *++pe = tt;
        }
    }
}
inline void Dp(){
    Forr(i, cod, 1){
        int k = base[i];
        Pack(i, cost[k], wei[k], cnt[k]);
        For(j, 0, m) dp[i][j] = max(dp[i][j], dp[i + sz[k]][j]);
    }
    For(i, 0, m) ans = max(ans, dp[1][i]);   //只在1取答案
    For(i, 1, cod) For(j, 0, m) dp[i][j] = 0;   //清空
}

inline void Solve(int now){    //递归分治
    cod = 0, dfs3(now, 0);
    Dp();
    del[now] = 1;         //将重心删除
    for(int i = be[rt]; i; i = ne[i]){
        int v = to[i];
        if(del[v]) continue;
        tot = sz[v], rt = 0, dfs1(v, now);
        Solve(rt);
    }
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("pro.in", "r", stdin);
    freopen("pro.out","w",stdout);
#endif
    int T;
    scanf("%d", &T);
    while(T--){
        e = 0, ans = 0;
        memset(be, 0, sizeof(be));
        memset(del, 0, sizeof(del));
        scanf("%d%d", &n, &m);
        For(i, 1, n) scanf("%d", &wei[i]);
        For(i, 1, n) scanf("%d", &cost[i]);
        For(i, 1, n) scanf("%d", &cnt[i]);
        For(i, 1, n - 1){
            int u, v;
            scanf("%d%d", &u, &v);
            Add(u, v), Add(v, u);
        }
        rt = 0, f[0] = inf, tot = n;
        dfs1(1, 0);
        Solve(rt);
        printf("%d\n", ans);
    }
    return 0;
}

若有不明白或错误之处还请评论。
转载请注明出处：http://blog.csdn.net/monkey_king2017cn