树上连通有关背包：【BZOJ4182】shopping &【HDU6566】The Hanged Man

最新推荐文章于 2021-09-04 16:56:11 发布
最新推荐文章于 2021-09-04 16:56:11 发布
阅读量237 收藏 1
点赞数
分类专栏： # 树链剖分 # 树分治 # 背包dp 文章标签： 动态规划 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ez_lcw/article/details/119920857
版权

选这两道题是因为这两道题都是树上背包，而且选的点的要求都与连通性有关，而且都是按 dfs 序 DP 来模拟不断加入物品，而且都能用树剖和点分治优化（不过优化的点一个跟子树大小有关一个跟深度有关），比较相似。

【BZOJ4182】shopping

题意：树上多重背包，要求选了的点是一个连通块。

暴力想法设 f u , i f_{u,i} fu,i​ 表示选了以 u u u 为根且在 u u u 子树内的连通块，花费为 i i i 的最大收益。

如果使用暴力合并子树的方法的话，时间复杂度 O ( n m 2 ) O(nm^2) O(nm2)，而且看起来没什么可以优化的地方。

变换思路，我们不考虑合并，而是像普通序列 DP 一样不断添加物品。

添加物品需要按 dfs 序来 DP，设 dfs 了到点 u u u，用 g i g_i gi​ 表示 dfs 到点 u u u 时花费为 i i i 的最大收益（即到点 u u u 之前的 DP 状态）。

我们考虑点 u u u 的物品我们选不选。如果我们选了点 u u u（设 g 1 g_1 g1​ 表示选了点 u u u 的 DP 状态），显然先令 g 1 = g g_1=g g1​=g ，然后用点 u u u 的物品更新 g 1 g_1 g1​（注意这个点的物品至少得选一个），然后进这个点的子树 dfs 更新 g 1 g_1 g1​；如果我们不选点 u u u（设 g 2 g_2 g2​ 表示不选点 u u u 的 DP 状态），那么它的子树也不能选，所以直接令 g 2 = g g_2=g g2​=g。最后从 u u u 回溯时对 g 1 g_1 g1​ 和 g 2 g_2 g2​ 取个 max ⁡ \max max 来更新 g g g 即可。

如果我们使用二进制分组优化多重背包，一次加入物品时间就能降到 O ( m log ⁡ D ) O(m\log D) O(mlogD)。（当然也可以不用二进制分组而是用单调队列优化来把 log ⁡ D \log D logD 去掉）

注意如果连通块的根不同，那么进入一个点 u u u 时的 g g g 就不同，出来的值也不同，所以需要枚举连通块的根。

那么如果暴力地枚举每个点作为连通块的根并在其子树内 dfs 求出 f u f_{u} fu​，总时间复杂度就为 O ( n 2 m log ⁡ D ) O(n^2m\log D) O(n2mlogD)。

接下来有两种优化方式：

  • 树剖。我们不能暴力合并子树的 f f f，但我们可以选择一棵子树继承它的 f f f。所以我们求 f u f_u fu​ 时先继承重儿子 s s s 的 f s f_s fs​，再往其他的轻儿子 dfs。每个点只会被 dfs 共 log ⁡ n \log n logn 次。总时间复杂度 O ( n m log ⁡ n log ⁡ D ) O(nm\log n\log D) O(nmlognlogD)。
  • 点分治。我们枚举每一个 r t rt rt，以点分树上以它为根的的子树为范围，在原树上 dfs。显然原树上的每一个连通块都可以被唯一一个 r t rt rt（这个连通块中在点分树上深度最小的那个点）DP 到。总时间复杂度 O ( n m log ⁡ n log ⁡ D ) O(nm\log n\log D) O(nmlognlogD)。

点分治做法代码：

#include<bits/stdc++.h>
 
#define N 510
#define M 4010
#define INF 0x7fffffff
 
using namespace std;
 
inline int read()
{
    int x=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9')
    {
        if(ch=='-') f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9')
    {
        x=(x<<1)+(x<<3)+(ch^'0');
        ch=getchar();
    }
    return x*f;
}
 
int T,n,m,w[N],c[N],d[N];
int cnt,head[N],to[N<<1],nxt[N<<1];
int nn,maxn,rt,size[N];
int ans;
bool vis[N];
 
void adde(int u,int v)
{
    to[++cnt]=v;
    nxt[cnt]=head[u];
    head[u]=cnt;
}
 
void getsize(int u,int fa)
{
    size[u]=1;
    for(int i=head[u];i;i=nxt[i])
    {
        int v=to[i];
        if(v==fa||vis[v]) continue;
        getsize(v,u);
        size[u]+=size[v];
    }
}
 
void getroot(int u,int fa)
{
    int maxs=0;
    for(int i=head[u];i;i=nxt[i])
    {
        int v=to[i];
        if(v==fa||vis[v]) continue;
        getroot(v,u);
        maxs=max(maxs,size[v]);
    }
    maxs=max(maxs,nn-1-size[u]);
    if(maxs<maxn) rt=u,maxn=maxs;
}
 
int f[M],g[N][M];
int tot,ww[35],cc[35];
 
void divide(int u)//二进制分组
{
    tot=0;
    int x=d[u]-1;
    for(int j=1;j<=x;j<<=1)
    {
        x-=j;
        ww[++tot]=j*w[u];
        cc[tot]=j*c[u];
    }
    if(x)
    {
        ww[++tot]=x*w[u];
        cc[tot]=x*c[u];
    }
}
 
void insert(int u)
{
    if(d[u]==1) return;
    divide(u);
    for(int i=1;i<=tot;i++)
        for(int j=m;j>=0;j--)
            if(j-cc[i]>=0&&f[j-cc[i]]!=-1)
                f[j]=max(f[j],f[j-cc[i]]+ww[i]);
}
 
void dfs(int u,int fa)
{
    memcpy(g[u],f,sizeof(g[u]));
    memset(f,-1,sizeof(f));
    for(int j=m;j>=0;j--)//在当前点强制先选一个
        if(j-c[u]>=0&&g[u][j-c[u]]!=-1)
            f[j]=g[u][j-c[u]]+w[u];
    insert(u);
    for(int i=head[u];i;i=nxt[i])
    {
        int v=to[i];
        if(v==fa||vis[v]) continue;
        dfs(v,u);
    }
    for(int i=0;i<=m;i++) f[i]=max(f[i],g[u][i]);
}
 
void work(int u)
{
    memset(f,-1,sizeof(f));
    f[0]=0;
    dfs(u,0);
    for(int i=0;i<=m;i++)
        ans=max(ans,f[i]);
}
 
void solve(int u)
{
    vis[u]=1;
    work(u);
    for(int i=head[u];i;i=nxt[i])
    {
        int v=to[i];
        if(vis[v]) continue;
        getsize(v,0);
        nn=size[v],maxn=INF,getroot(v,0);
        solve(rt);
    }
}
 
int main()
{
    T=read();
    while(T--)
    {
        ans=cnt=0;
        memset(head,0,sizeof(head));
        memset(vis,0,sizeof(vis));
        n=read(),m=read();
        for(int i=1;i<=n;i++) w[i]=read();
        for(int i=1;i<=n;i++) c[i]=read();
        for(int i=1;i<=n;i++) d[i]=read();
        for(int i=1;i<n;i++)
        {
            int u=read(),v=read();
            adde(u,v),adde(v,u);
        }
        getsize(1,0);
        nn=size[1],maxn=INF,getroot(1,0);
        solve(rt);  
        printf("%d\n",ans);
    }
    return 0;
}

【HDU6566】The Hanged Man

题意：树上 01 背包，要求选的点是一个独立集，除了输出最大收益还要输出最大收益的方案数。

暴力想法设 f u , 0 / 1 , i f_{u,0/1,i} fu,0/1,i​ 表示考虑完以 u u u 为根的子树， u u u 选没选，代价为 i i i 的最大收益。

暴力合并子树是 O ( n m 2 ) O(nm^2) O(nm2) 的，而且也没有什么可优化的地方。

变换思路，我们不考虑合并，而是像普通序列 DP 一样不断添加物品。

按 dfs 序 DP，注意祖先点的选择状态对于后续点的选择有影响，所以需要记录一下祖先的选择状态。

暴力想法设 g s t a , i g_{sta,i} gsta,i​ 表示当前祖先选择状态为 s t a sta sta，代价为 i i i 的最大收益。然后直接 dfs 并更新 g g g 即可。时间复杂度 O ( n 2 n m ) O(n2^nm) O(n2nm)。

接下来有两种优化方法：

  • 树剖。我们优先 dfs 轻儿子，那么 dfs 完一个点后会一直回溯到重链顶端，所以重链上的点的选择状态对后续点的选择是没有影响的，于是 DP 时只需记录每个轻边父亲的选择状态，时间复杂度 O ( n 2 log ⁡ n m ) = O ( n 2 m ) O(n2^{\log n}m)=O(n^2m) O(n2lognm)=O(n2m)。
  • 点分治。显然对于一个点 u u u，在原树中和它相邻的点只可能是点分树中 u u u 的祖先或者是点分树中 u u u 的子树，于是 DP 时只需记录点分树上祖先的选择状态，时间复杂度 O ( n 2 log ⁡ n m ) = O ( n 2 m ) O(n2^{\log n}m)=O(n^2m) O(n2lognm)=O(n2m)。

点分治做法代码：

#include<cstring>
#include<iostream>
#include<assert.h>

#define N 55
#define M 5010
#define ll long long
#define INF 0x7fffffff

using namespace std;

inline int read()
{
    int x=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9')
    {
        if(ch=='-') f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9')
    {
        x=(x<<1)+(x<<3)+(ch^'0');
        ch=getchar();
    }
    return x*f;
}

int T,n,m,a[N],b[N],fa[N];
int cnt,head[N],nxt[N<<1],to[N<<1];
int nn,rt,maxn,size[N];
int f[N<<2][M];
ll g[N<<2][M];
bool vis[N];

void adde(int u,int v)
{
    to[++cnt]=v;
    nxt[cnt]=head[u];
    head[u]=cnt;
}

void dfs(int u)
{
    for(int i=head[u];i;i=nxt[i])
    {
        int v=to[i];
        if(v==fa[u]) continue;
        fa[v]=u;
        dfs(v);
    }
}

void getsize(int u,int fa)
{
    size[u]=1;
    for(int i=head[u];i;i=nxt[i])
    {
        int v=to[i];
        if(v==fa||vis[v]) continue;
        getsize(v,u);
        size[u]+=size[v];
    }
}

void getroot(int u,int fa)
{
    int nmax=0;
    for(int i=head[u];i;i=nxt[i])
    {
        int v=to[i];
        if(v==fa||vis[v]) continue;
        getroot(v,u);
        nmax=max(nmax,size[v]);
    }
    nmax=max(nmax,nn-size[u]);
    if(nmax<maxn) rt=u,maxn=nmax;
}

int top,sta[7];

bool beside(int u,int v)
{
    return fa[u]==v||fa[v]==u;
}

void solve(int u,int dep)
{
    vis[u]=1;
    int fms=(1<<(dep-1))-1;
    for(int fs=0;fs<=fms;fs++)
    {
        bool choose=1;
        for(int i=1;i<=top;i++)
        {
            if(((fs>>(i-1))&1)&&beside(u,sta[i]))
            {
                choose=0;
                break;
            }
        }
        if(choose)
        {
            int us=fs|(1<<(dep-1));
            for(int i=0;i<=m;i++)
            {
                if(i-a[u]>=0&&f[fs][i-a[u]]!=-1)
                {
                    f[us][i]=f[fs][i-a[u]]+b[u];
                    g[us][i]=g[fs][i-a[u]];
                }
            }
        }
    }
    sta[++top]=u;
    for(int i=head[u];i;i=nxt[i])
    {
        int v=to[i];
        if(vis[v]) continue;
        getsize(v,0);
        nn=size[v],maxn=INF,getroot(v,0);
        solve(rt,dep+1);
    }
    top--;
    int tmp=(1<<(dep-1));
    for(int fs=0;fs<=fms;fs++)
    {
        for(int i=0;i<=m;i++)
        {
            if(f[fs][i]<f[fs|tmp][i])
            {
                f[fs][i]=f[fs|tmp][i];
                g[fs][i]=g[fs|tmp][i];
            }
            else if(f[fs][i]==f[fs|tmp][i])
                g[fs][i]+=g[fs|tmp][i];
            f[fs|tmp][i]=-1,g[fs|tmp][i]=0;
        }
    }
}

int main()
{
    T=read();
    for(int Case=1;Case<=T;Case++)
    {
        cnt=0;
        memset(head,0,sizeof(head));
        memset(f,-1,sizeof(f));
        memset(g,0,sizeof(g));
        memset(vis,0,sizeof(vis));
        n=read(),m=read();
        for(int i=1;i<=n;i++)
            a[i]=read(),b[i]=read();
        for(int i=1;i<n;i++)
        {
            int u=read(),v=read();
            adde(u,v),adde(v,u);
        }
        dfs(1);
        getsize(1,0);
        nn=size[1],maxn=INF,getroot(1,0);
        f[0][0]=0,g[0][0]=1;
        solve(rt,1);
        printf("Case %d:\n",Case);
        for(int i=1;i<m;i++)
            printf("%lld ",g[0][i]);
        printf("%lld\n",g[0][m]);
    }
    return 0;
}
ez_lcw
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
[hdu6566]The Hanged Man
StaroForgin的博客
03-12 249
tree 题解 树dp板子题。 首先O(nm2)O\left(nm^2\right)O(nm2)的朴素dp做法应该是十分容易想到的，直接合并即可。 由于MAX卷积什么的太，太神仙了，我都没听说过，所以显然不能用来优化转移过程降低时间复杂度，我们就考虑改变一下dp状态。 首先，我们知道如果每次只合并一个数的话每次转移明显就是O(m)O(m)O(m)的了，而对于这个数我们又只需要考虑它的父亲在不在，所以很快就可以想到状压，合并时看它父亲在不在。 但很明显，直接状压是不现实的，n⩽50n\leqslant 50n
[HDU6566]The Hanged Man
七代目鸽影
02-23 646
都 1202 年了，不会还有人用树形 dp 解决树上问题吧？不会吧？
bzoj4987 Tree 树上背包
weixin_30455023的博客
09-24 115
题目传送门 https://lydsy.com/JudgeOnline/problem.php?id=4987 题解 一道还不错的题咯。 很容易发现一个结论：这 \(k\) 个点构成的一定是一个连通块，并且走的时候应该是按照某种类似于 dfs 的遍历方式连续走的。 可以发现，最终答案应该有：从根的某个子树走出来，到某个子树中去的这样的情况，也有可能是从根到某个子树中去的情况；同时，过程中...
bzoj4182 Shopping 购物 点分治+树形多重背包+dfs序+单调队列优化
The_OIer的博客
08-23 461
题目链接：传送门（权限题） 大毒瘤QAQ 发现买过物品的商店构成一个联通块，所以钦定一个根，让所有买过物品的商店到根的路径上的商店都是买过物品的商店。 然后在上面跑树形背包，子状态设计： dp[i][j]dp[i][j]dp[i][j]表示选到iii号节点，已经花了jjj块钱，所能达到的最大喜爱度。 用dfs实现的树形dp会TLE，考虑用dfs序来优化： 按照dfs序优化的套路，分不选当前节点和选...
洛谷P2014 选课 - 树上背包
Zolrk的博客
08-13 235
注意在dp中x！=0那一段 其实是对状态的修正 #include &amp;lt;algorithm&amp;gt; #include &amp;lt;iostream&amp;gt; #include &amp;lt;cstdio&amp;gt; using namespace std; const int MAXN = 300 + 10; int n,m,tot,head[MAXN],k[MAXN],son[MAXN],f[MAXN][M...
BZOJ_problem_rank:BZOJ问题等级按交流比排序
05-25
#BZOJ Problem Rankrank.cpp 程序文件data.dat bzoj题库数据done.dat AC过的题，初始可以把所有A过的题粘进去，正常退出的话自动维护。black.dat 黑名单。选题时会跳过。错题、神题、没题面、不想做等等。//Thank ...
contests-all-in-one:BZOJ，POJ，LeetCode，USACO，HDUOJ，LA的比赛解决方案
03-15
BZOJ，POJ，LeetCode，USACO，HDUOJ，LA的比赛解决方案 有话要说 嗨，我是Ex10si0n。 该存储库用于记录我的OJ AC代码。 关于我 OIer，Develpoer。 希望这个仓库可以帮助那些通过Probelm ID找到LeetCode或其他OJ解决...
数论题解：「BZOJ1053」反素数/「Violet5」樱花
01-22
「BZOJ1053」反素数详解 「BZOJ1053」反素数问题是数论领域中的一个经典问题，该问题要求我们计算不超过N的最大反质数。所谓反质数，即满足对所有0，g(x)&gt;g(i)的自然数x，其中g(x)表示x的约数个数。 首先，我们...
wangjunrui666#bzoj-problem##5165. 树上倍增1
07-25
您需要写一个树上倍增算法，以实现如下操作：A x 新建一个节点，将它作为x节点的儿子，编号为当前节点总数+1。保证询问不超过1000次输出格式对于每一个Q操作，
bzoj 3730. 震波（动态点分治 + vector树状数组）
01-06
考虑点分树的做法，在点分树上每个点以距离为下标建一棵线段树，每次询问查询子树的贡献，再暴力向上跳合并父节点来自其它节点的贡献。 因为子树树形被破坏，在做减法时，子节点子树对父节点的贡献不能用子树维护的...
bzoj5250 九省联考 秘密袭击【树上背包+拉格朗日插值+线段树合并】
cdsszjj的博客
04-18 777
解题思路： 第一个想法是枚举第kkk大的值，把大于的记为1，小于的记为0，问题就转化为树上联通块大小等于kkk的个数。 稍微转化一下，我们统计树上联通块第kkk大大等于iii的个数，不妨记为aiaia_i，那么 ans=∑i=1Wi(ai−ai+1)ans=∑i=1Wi(ai−ai+1)ans=\sum\limits_{i=1}^Wi(a_i-a_{i+1}) 而因为这样计算每个大等于ii...
2018CCPC吉林赛区 hdu6555~hdu6566
weixin_30293135的博客
09-17 506
2018CCPC吉林赛区（重现赛）- 感谢北华大学 A 基础数论。 #include&lt;bits/stdc++.h&gt; using namespace std; typedef long long LL; int main() { int T,cc = 0; scanf("%d",&amp;T); while(T --) { int n...
HDU - 6556
gaoshuzhendanten的博客
11-30 283
The World 前段时间，tyd和zx环游了世界，他们玩的非常开心，并且发现了很多好玩的事情。 世界各地都有不同的时区，导致时差。 在这里，你可以了解几个著名的首都及其相应的时区。 北京Beijing - 中国 - UTC + 8（中国标准时间） 华盛顿Washington - 美国 - UTC - 5（东部标准时间） 伦敦London - 英国 - UTC（格林威治标准时间） 莫斯科Moscow - 俄罗斯 - UTC + 3（莫斯科时间） 根据城市的当地时间，您需要计算上述首都中另一个特定城市的日期
BZOJ 2133 切割（树形DP，树上背包）大概是本题全网第一篇题解 ＞_＜【BZOJ 修复工程】
繁凡さん的博客
09-04 461
【BZOJ修复计划 #3】BZOJ 2133 切割 【国家集训队作业】
【XJOI tree】树上背包+奇怪优化
Qantun_Mechanics的博客
10-31 979
题解： 考这场考试的前一天晚上逛大神博客，看见别人有写树上背包，嗯，一笑而过了。。。。结果第二天XJOI的提高组模拟赛就考了。于是不会，然后今天在上课的时候发呆的时候，自己脑补出来树上背包的做法。嗯，看了一下大神的博客，我发现大神的树上背包是用的记忆化搜索，我最开始的想法是基于拓扑排序从下往上dp，嗯，复杂了，改进了一下我的方法。一般的树上背包：（60分解法） 定义：dp[i][j]为到点i已经
[bzoj5072] [十月月赛] 小A的树 树上背包
myjs999的博客
06-27 267
题意 给定一棵nnn个点的树，树上某些点是黑点。每次询问是否能选出一个xxx个点的联通块，使其中有yyy个黑点。 询问数≤105,n≤5000≤105,n≤5000\le10^5,n\le 5000。数据组数≤5≤5\le5。 分析 一棵树上的联通块是一棵树，因此考虑从儿子向父亲合并信息。那我们可以维护每个点选含自己的字数内iii个点的联通块，其中有jjj个黑点的可行性，转移枚举儿子，枚举...
BZOJ4182: Shopping(点分治，树上背包)
weixin_30538029的博客
12-21 145
Description 马上就是小苗的生日了，为了给小苗准备礼物，小葱兴冲冲地来到了商店街。商店街有n个商店，并且它们之间的道路构成了一颗树的形状。 第i个商店只卖第i种物品，小苗对于这种物品的喜爱度是wi，物品的价格为ci，物品的库存是di。但是商店街有一项奇怪的规定：如果在商店u,v买了东西，并且有一个商店w在u到v的路径上，那么必须要在商店w买东西。小葱身上有m元钱，他想要尽量让小苗...
HDU - 6555 The Fool（思维）
smilng的博客
09-22 679
原题链接 题意：给一个整数n，判断n/1 + n/2 + n/3 … + n/n 的值是奇数还是偶数。其中的除法为下取整。 思路：通过打表发现，每个数求出的ans值，比它的上一个数增加的数字是当前数的约数个数，（自己推几个数也推得出来），除了完全平方数，其他数的约数个数都是偶数，那么其实只需要求n以内有多少完全平方数就可以了，暴力求就ok，时间复杂度为根号n。 好像不难的一个题我想了一个多小时...
2020杭电多校第六场 A Very Easy Graph Problem 点分治 (HDU 6832)
流水
08-06 452
A Very Easy Graph Problem 不知道有没有人跟我一样点分治写的… 题解 根据题意，第iii条边长度为2i2^i2i，且21+22+⋅⋅⋅+2i−1=2i−1&lt;2i2^1+2^2+···+2^{i - 1} =2^i-1&lt;2^i21+22+⋅⋅⋅+2i−1=2i−1&lt;2i，即后面加进去的边要大于前面所有边之和 那么显然，如果在加入当前边(u,v,2i)(u,v,2^i)(u,v,2i)之前，uuu和vvv已经连通了，我们就不用再加这条边了(加之前能连通，而且根据上面说的
bzoj 1040 zjoi2008 骑士 树形dp
最新发布
08-08
有一个 $n$ 个点的棋盘，每个点上有一个数字 $a_i$，你需要从 $(1,1)$ 走到 $(n,n)$，每次只能往右或往下走，每个格子只能经过一次，路径上的数字和为 $S$。定义一个点 $(x,y)$ 的权值为 $a_x+a_y$，求所有满足条件...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值