【DP】计划11.8——（树形依赖背包总结）&&分数规划思想

最新推荐文章于 2024-02-13 15:33:30 发布

stevensonson

最新推荐文章于 2024-02-13 15:33:30 发布

阅读量922

点赞数

分类专栏： DP计划 BZOJ

本文链接：https://blog.csdn.net/stevensonson/article/details/83861883

版权

BZOJ 同时被 2 个专栏收录

94 篇文章 1 订阅

订阅专栏

DP计划

15 篇文章 0 订阅

订阅专栏

树形依赖背包指的就是一类具有树形依赖关系的背包问题。当选一个物品的前提是选另一件物品，而这些依赖关系构成了一个树形关系。在容量有限的情况下，然后求最大的价值，这类问题我们就称之为树形依赖背包。

树形依赖背包问题实际上是一类分组背包问题，我们可以将每个点的子树看成一个组，因为子树内会选择一定的点，但是选择的点数只有一种情况，所以我们可以将子树选择 $i$ （ $i∈[0,siz_{sonx}]$ ）的情况看成一类物品，然后就做分组背包即可。

我们设 $f [i] [j]$ 表示点 $i$ ，字数里选了 $j$ 容量的最大价值，那么则有DP方程：

for(int i=k;i>=w[x];i--)
    for(int j=0;j<=k;j++){
         if(i+j>k) break;
         f[x][i+j]=max(f[x][i+j],f[x][i]+f[son][j])
}

一般的依赖关系会要求选择当前子树的树根,因此初始状态是`f[x][w[x]]=v[x]`，并且在第一维枚举容量时只枚举到`w[x]`。

还有一类DP方程， $f [i] [j]$ 表示点 $i$ 字数内选择了 $j$ 个点所获得的最大的收益，那么方程式也稍微变一下即可:

for(int i=siz[x];i>=1;i--)
    for(int j=0;j<=siz[son];j++){
         if(i+j>k) break;
         f[x][i+j]=max(f[x][i+j],f[x][i]+f[son][j])
}

这类方程有一个很实用的优化，就是我们刚开始初始化`siz[x]=1`，然后每次枚举完一个儿子的时候，就执行语句`siz[x]+=siz[son]`。这样可以大大降低复杂度，有巨佬指出，原来不进行优化的时间复杂度为 $O(n^3)$ ，但是进行了这个 $s i z$ 数组的优化后，可以接近于 $O(n^2)$ 这也就是为什么许多 $n$ 为 $2500$ 的题目，也可以用树形依赖背包来做。

例题：

洛谷：P2014选课

题目描述

在大学里每个学生，为了达到一定的学分，必须从很多课程里选择一些课程来学习，在课程里有些课程必须在某些课程之前学习，如高等数学总是在其它课程之前学习。现在有N门功课，每门课有个学分，每门课有一门或没有直接先修课（若课程a是课程b的先修课即只有学完了课程a，才能学习课程b）。一个学生要从这些课程里选择M门课程学习，问他能获得的最大学分是多少？
输入输出格式
输入格式：

第一行有两个整数N,M用空格隔开。(1<=N<=300,1<=M<=300)

接下来的N行,第I+1行包含两个整数ki和si, ki表示第I门课的直接先修课，si表示第I门课的学分。若ki=0表示没有直接先修课（1<=ki<=N, 1<=si<=20）。

输出格式：

只有一行，选M门课程的最大得分。

输入输出样例
输入样例#1：

7 4
2 2
0 1
0 4
2 1
7 1
7 6
2 2

输出样例#1：

这道题就是最基本的树形依赖背包模板，就是上面说的第二类DP方程，甚至由于N的范围很小，直接 $O(n^3)$ 的DP也不会超时

代码中的方程式与上文所述的方程式效果相同，但是一般会选用上文的那种，因为那种方程式配合 $s i z$ 优化的时候复杂度更优

#include<bits/stdc++.h>
#define MAXN 205
using namespace std;
int read(){
	char c;int x;while(c=getchar(),c<'0'||c>'9');x=c-'0';
	while(c=getchar(),c>='0'&&c<='9') x=x*10+c-'0';return x;
}
int n,m,cnt,siz[MAXN],head[MAXN],nxt[MAXN],f[MAXN][105];
struct node{
	int to,val;
}L[MAXN];
void add(int x,int y,int c){
	L[cnt]=(node){y,c};
	nxt[cnt]=head[x];head[x]=cnt;cnt++;
}
void get(int x){
	siz[x]=1;
	for(int i=head[x];i!=-1;i=nxt[i]){
		int to=L[i].to;
		get(to);siz[x]+=siz[to];
	}
}
int dfs(int x){
	for(int i=head[x];i!=-1;i=nxt[i]){
		int to=L[i].to;dfs(to);
		for(int j=siz[x]-1;j>=0;j--)
		 for(int k=0;k<=siz[to]-1;k++)
		  if(j>k) f[x][j]=max(f[x][j],f[x][j-k-1]+L[i].val+f[to][k]);
	}
}
int main()
{
	n=read();m=read();
	memset(head,-1,sizeof(head));
	memset(f,~0x3f,sizeof(f));
	for(int i=1;i<=n;i++){
		int x=read()+1,c=read();
		add(x,i+1,c);
	}
	for(int i=1;i<=n+1;i++) f[i][0]=0;
	get(1);dfs(1);
	printf("%d",f[1][m]);
	return 0;
}

洛谷：P1273有线电视网

题解链接，这道题我专门写过详尽的题解，严格意义上来说，这道题是我接触的第一道树形依赖背包，但是它的难度稍大于选课那题，所以放作第二题

题目要求不亏本的情况下最多的使用人数，我们采用第二种DP方式。最后 $c h e c k$ 的时候只要 $i$ 从大到小枚举 $f [1] [i]$ ，如果当前的 $f [1] [i]$ 大于等于0，那么 $i$ 就是最多的使用人数。

#include<bits/stdc++.h>
#define MAXN 3005
using namespace std;
int read(){
    char c;int x;while(c=getchar(),c<'0'||c>'9');x=c-'0';
    while(c=getchar(),c>='0'&&c<='9') x=x*10+c-'0';return x;
}
int n,m,cnt,ans,head[MAXN],nxt[MAXN],go[MAXN],dp[MAXN][MAXN],w[MAXN],son[MAXN],siz[MAXN];
struct node{
    int to,val;
}L[MAXN];
void add(int x,int y,int c){
    L[cnt]=(node){y,c};
    nxt[cnt]=head[x];head[x]=cnt;cnt++;
}
int dfs(int x){    //这个操作很silly，大家千万不要学，又慢又长。直接在转移时更新既短又快
    siz[x]=1;
    for(int i=head[x];i!=-1;i=nxt[i]){
        int to=L[i].to;
        siz[x]+=dfs(to);
    }
    return siz[x];
}
void calc(int x){
    if(x>n-m){dp[x][1]=w[x];return;}
    for(int i=head[x];i!=-1;i=nxt[i]){
        int to=L[i].to;calc(to);
        for(int j=siz[x];j>=0;j--)
          for(int k=1;k<=siz[to];k++)
           if(j>=k) dp[x][j]=max(dp[x][j],dp[x][j-k]+dp[to][k]-L[i].val);
    }
}
int main()
{
    n=read();m=read();
    memset(head,-1,sizeof(head));
    memset(dp,~0x3f,sizeof(dp));
    for(int i=1;i<=n;i++) dp[i][0]=0;
    for(int i=1;i<=n-m;i++){
        son[i]=read();
        for(int j=1;j<=son[i];j++){
            int x=read(),y=read();add(i,x,y);
        }
    }
    for(int i=1;i<=m;i++) w[n-m+i]=read();
    dfs(1);calc(1);
    for(int i=0;i<=n;i++) if(dp[1][i]>=0) ans=i;
    printf("%d",ans);
    return 0;
}

Codeforces：815C

依旧有一篇详尽的博客

这道题用的是第二种方程,不同的是依赖关系只适用于优惠，因此即使我们要开两个数组， $f$ 数组记录的是满足依赖的能够享受优惠的情况， $g$ 数组是不满足依赖的情况， $g$ 的转移其实类似于 $f$ ，只是外层枚举容量那一维要倒着一直枚举到 $0$

#include<bits/stdc++.h>
#define MAXN 5005
#define ll long long
using namespace std;
ll read(){
	char c;ll x;while(c=getchar(),c<'0'||c>'9');x=c-'0';
	while(c=getchar(),c>='0'&&c<='9') x=x*10+c-'0';return x;
}
ll n,m,ans,flag,v[MAXN],dc[MAXN],f[MAXN][MAXN],g[MAXN][MAXN];
ll cnt,head[MAXN<<1],nxt[MAXN<<1],go[MAXN<<1],siz[MAXN];
void add(ll x,ll y){
	go[cnt]=y;nxt[cnt]=head[x];head[x]=cnt;cnt++;
}
void dfs(ll x){
	register int i,j,k;
	g[x][0]=0;f[x][1]=v[x]-dc[x];g[x][1]=v[x];siz[x]=1;
	for(k=head[x];k!=-1;k=nxt[k]){
		ll to=go[k];dfs(to);
		for(i=siz[x];i>=0;i--)
		 for(j=1;j<=siz[to];j++)
		  g[x][i+j]=min(g[x][i+j],g[x][i]+g[to][j]);
		for(i=siz[x];i>=1;i--)
		 for(j=1;j<=siz[to];j++)
		  f[x][i+j]=min(f[x][i+j],f[x][i]+min(f[to][j],g[to][j])); 
		siz[x]+=siz[to];
	}
}
int main()
{
	n=read();m=read();register int i;
	memset(head,-1,sizeof(head));
	memset(f,127,sizeof(f));
	memset(g,127,sizeof(g));
	for(i=1;i<=n;i++){
		v[i]=read();dc[i]=read();
		if(i>1){ll x=read();add(x,i);}
	}
	dfs(1);
	for(i=n;i;i--)
	 if(f[1][i]<=m||g[1][i]<=m){flag=1;printf("%d",i);break;}
	if(!flag) puts("0");
	return 0;
}

BZOJ：2427软件安装

Description

现在我们的手头有N个软件，对于一个软件i，它要占用Wi的磁盘空间，它的价值为Vi。我们希望从中选择一些软件安装到一台磁盘容量为M计算机上，使得这些软件的价值尽可能大（即Vi的和最大）。

但是现在有个问题：软件之间存在依赖关系，即软件i只有在安装了软件j（包括软件j的直接或间接依赖）的情况下才能正确工作（软件i依赖软件j)。幸运的是，一个软件最多依赖另外一个软件。如果一个软件不能正常工作，那么它能够发挥的作用为0。

我们现在知道了软件之间的依赖关系：软件i依赖软件Di。现在请你设计出一种方案，安装价值尽量大的软件。一个软件只能被安装一次，如果一个软件没有依赖则Di=0，这时只要这个软件安装了，它就能正常工作。

Input

第1行：N, M （0<=N<=100, 0<=M<=500）
第2行：W1, W2, … Wi, …, Wn （0<=Wi<=M ）
第3行：V1, V2, …, Vi, …, Vn （0<=Vi<=1000 ）
第4行：D1, D2, …, Di, …, Dn （0<=Di<=N, Di≠i ）

Output

一个整数，代表最大价值。

Sample Input
3 10

5 5 6

2 3 4

0 1 1
Sample Output
5

这道题恶心的地方就在于整张图可能是一个环，也可能是一个森林。

因此我们要先用 $T a r j a n$ 缩点，将所有的环缩成一个点，这个点的 $v=\sum v_x \ \ \ w=\sum w_x$ ，x是这个环中的点。这个也很好证明，因为形成了一个环形依赖，所以环中每个点都得同时选才行。

由于缩完点可能是森林，所以我们建一个虚点 $0$ ，并且 $v [0] = w [0] = 0$ ，然后从 $0$ 开始转移即可。

这道题运用的是上文的第一种DP方式，所以不存在 $s i z$ 优化，复杂度是跑不到上界的 $O(n^3)$

#include<bits/stdc++.h>
#define MAXN 505
using namespace std;
int read(){
    char c;int x=0,y=1;while(c=getchar(),(c<'0'||c>'9')&&c!='-');
    if(c=='-') y=-1;else x=c-'0';while(c=getchar(),c>='0'&&c<='9')
    x=x*10+c-'0';return x*y;
}
int n,m,cnt,top,ans,w[MAXN],v[MAXN],head[MAXN<<1],nxt[MAXN<<1],go[MAXN<<1],in[MAXN];
int ta,co,dfn[MAXN],low[MAXN],vis[MAXN],sta[MAXN],col[MAXN],fa[MAXN],f[MAXN][505];
vector<int> g[MAXN];
struct node{
    int w,v;
}F[MAXN];
void add(int x,int y){
    go[cnt]=y;nxt[cnt]=head[x];head[x]=cnt;cnt++;
}
void tarjan(int x){
    dfn[x]=low[x]=++ta;
    vis[x]=1;sta[++top]=x;
    for(int i=head[x];i!=-1;i=nxt[i]){
        int to=go[i];
        if(!dfn[to]) tarjan(to),low[x]=min(low[x],low[to]);
        else if(vis[to]) low[x]=min(low[x],dfn[to]);
    }
    if(dfn[x]==low[x]){
        co++;int now=0;
        while(now!=x){
            now=sta[top--];
            vis[now]=0;col[now]=co;
            F[co].w+=w[now];
            F[co].v+=v[now];
        }
    }
}
int find(int x){
    if(fa[x]!=x) fa[x]=find(fa[x]);
    return fa[x];
}
void unionn(int x,int y){
    x=find(x);y=find(y);
    fa[y]=x;
}
void dfs(int x){
    if(F[x].w>m) return;
    f[x][F[x].w]=F[x].v;
    for(int i=0;i<g[x].size();i++){
        int to=g[x][i];
        dfs(to);
        for(int j=m;j>=F[x].w;j--)
         for(int k=0;k<=m;k++){
            if(j+k>m) break;
            f[x][j+k]=max(f[x][j+k],f[x][j]+f[to][k]);
         }
    }
}
int main()
{
    n=read();m=read();
    memset(head,-1,sizeof(head));
    for(int i=1;i<=n;i++) w[i]=read();
    for(int i=1;i<=n;i++) v[i]=read();
    for(int i=1;i<=n;i++){
        int x=read();
        if (x)add(x,i);
    }
    for(int i=1;i<=n;i++)
      if(!dfn[i]) tarjan(i);
    for(int i=1;i<=co;i++) fa[i]=i;
    for(int x=1;x<=n;x++)
     for(int i=head[x];i!=-1;i=nxt[i]){
        int to=go[i];
        if(find(col[x])!=find(col[to])){
            unionn(col[x],col[to]);in[col[to]]++;
            g[col[x]].push_back(col[to]);
         }
     }
    for(int i=1;i<=co;i++)
     if(!in[i]) g[0].push_back(i);
    F[0]=(node){0,0};
    dfs(0);
    for(int i=0;i<=m;i++) ans=max(ans,f[0][i]);
    printf("%d",ans);
    return 0;
}

BZOJ：4753最佳团体

Description
JSOI信息学代表队一共有N名候选人，这些候选人从1到N编号。方便起见，JYY的编号是0号。每个候选人都由一位
编号比他小的候选人Ri推荐。如果Ri=0则说明这个候选人是JYY自己看上的。为了保证团队的和谐，JYY需要保证，
如果招募了候选人i，那么候选人Ri"也一定需要在团队中。当然了，JYY自己总是在团队里的。每一个候选人都有
一个战斗值Pi"，也有一个招募费用Si"。JYY希望招募K个候选人（JYY自己不算），组成一个性价比最高的团队。
也就是，这K个被JYY选择的候选人的总战斗值与总招募总费用的比值最大。

Input
输入一行包含两个正整数K和N。
接下来N行，其中第i行包含3个整数Si,Pi,Ri表示候选人i的招募费用，战斗值和推荐人编号。
对于100%的数据满足1≤K≤N≤2500,0<"Si,Pi"≤10^4,0≤Ri<i

Output
输出一行一个实数，表示最佳比值。答案保留三位小数。

Sample Input
1 2

1000 1 0

1 1000 1
Sample Output
0.001

这道题需要结合分数规划的知识，分数规划指的是一类求 $\frac{\sum a_i}{\sum b_i}$ 最大值得问题，我们设 $\frac{\sum a_i}{\sum b_i}>x$ ，那么 $\sum a_i>x\sum b_i$ ，移项得 $\sum a_i-x\sum b_i>0$ ，所以我们可以去二分枚举 $x$ ，然后依据这个大于 $0$ 的等式进行 $c h e c k$

对于这道题，我们去二分枚举最优值，将每个点的价值赋值为`a[i]-x*b[i]`，然后进行树形依赖背包，求出选中 $k$ 个人之后的最大价值，如果最大价值大于 $0$ ，那么也就是 $c h e c k$ 满足条件。

#include<bits/stdc++.h>
#define MAXN 2550
#define db double
#define eps 1e-6
using namespace std;
int read(){
    char c;int x;while(c=getchar(),c<'0'||c>'9');x=c-'0';
    while(c=getchar(),c>='0'&&c<='9') x=x*10+c-'0';return x;
}
int n,k,cnt,a[MAXN],b[MAXN],siz[MAXN];
int head[MAXN<<1],nxt[MAXN<<1],go[MAXN<<1];
db l,r,mid,ans,v[MAXN],f[MAXN][MAXN];
void add(int x,int y){
    go[cnt]=y;nxt[cnt]=head[x];head[x]=cnt;cnt++;
}
void dfs(int x){
    f[x][1]=v[x];siz[x]=1;
    for(int i=2;i<=k;i++) f[x][i]=-2147483647;
    for(int i=head[x];i!=-1;i=nxt[i]){
        int to=go[i];dfs(to);
        for(int j=siz[x];j>=1;j--)
         for(int p=0;p<=siz[to];p++){
            if(j+p>k) break;
            f[x][j+p]=max(f[x][j+p],f[x][j]+f[to][p]);
         }
        siz[x]+=siz[to];
    }
}
int main()
{
    k=read();n=read();k++;
    memset(head,-1,sizeof(head));
    for(int i=1;i<=n;i++){
        b[i]=read();a[i]=read();
        int x=read();add(x,i);
    }
    l=0;r=1000000;
    while(l<=r){
        mid=(l+r)/2;
        for(int i=1;i<=n;i++) v[i]=1.0*a[i]-mid*b[i]; 
        dfs(0);
        if(f[0][k]>=0) ans=mid,l=mid+eps;
        else r=mid-eps;
    }
    printf("%.3f",ans);
    return 0;
}

BZOJ：4033树上染色

Description
有一棵点数为N的树，树边有边权。给你一个在0~N之内的正整数K，你要在这棵树中选择K个点，将其染成黑色，并将其他的N-K个点染成白色。将所有点染色后，你会获得黑点两两之间的距离加上白点两两之间距离的和的收益。
问收益最大值是多少。
Input
第一行两个整数N,K。
接下来N-1行每行三个正整数fr,to,dis，表示该树中存在一条长度为dis的边(fr,to)。
输入保证所有点之间是联通的。
N<=2000,0<=K<=N
Output
输出一个正整数，表示收益的最大值。
Sample Input
5 2

1 2 3

1 5 1

2 3 1

2 4 2

Sample Output
17

【样例解释】

将点1,2染黑就能获得最大收益。

这道题也算在树形背包的范畴里，但是没有依赖关系。我们设 $f [i] [j]$ 表示点 $i$ ，子树里染了了 $j$ 个黑点所能产生的贡献。

这个定义的关键在于贡献，因为子树里染了 $j$ 个黑点，产生的贡献是与子树外的点无关的（因为我们只靠虑当前的贡献，后面的贡献会在之后的计算中被统计）

我们思考如何统计这个贡献，假设当前点为 $x$ ，它的一个儿子为 $s o n$ ，并且 $s o n$ 的子树里染了 $j$ 个黑点，那么这 $j$ 个黑点在当前的贡献就是 $f [s o n] [j] + L [i] . v a l * k * (m - k) + L [i] . v a l * (s i z [s o n] - k) * (n - m - (s i z [s o n] - k))$

这个式子怎么理解呢？ $f [s o n] [j]$ 就是儿子子树中到儿子节点产生的贡献，那么加上从 $x$ 到 $s o n$ 的这条边所（ $L [i] . v a l$ ）产生的贡献，也就是到 $x$ 为止的贡献。

如果子树内有 $k$ 个黑点，那么这 $k$ 个点总共会与外面的黑点形成 $k * (m - k)$ 个点对，每个点对都经过这条边，所以是 $L [i] . v a l * k * (m - k)$ 。那么同理，白色的点会形成 $(s i z [s o n] - k) * (n - m - (s i z [s o n] - k))$ 个点对，也就产生了 $L [i] . v a l * (s i z [s o n] - k) * (n - m - (s i z [s o n] - k))$ 的贡献。

明白怎么统计贡献之后，就是简单的树形背包了。依旧要使用 $s i z$ 优化，否则复杂度过不去。

#include<bits/stdc++.h>
#define MAXN 2005
#define ll long long
using namespace std;
int read(){
    char c;int x;while(c=getchar(),c<'0'||c>'9');x=c-'0';
    while(c=getchar(),c>='0'&&c<='9') x=x*10+c-'0';return x;
}
int n,m,cnt,head[MAXN<<1],nxt[MAXN<<1];
int siz[MAXN],fa[MAXN];
ll f[MAXN][MAXN];
struct node{
    int to,val;
}L[MAXN<<1];
void add(int x,int y,int c){
    L[cnt]=(node){y,c};
    nxt[cnt]=head[x];head[x]=cnt;cnt++;
    L[cnt]=(node){x,c};
    nxt[cnt]=head[y];head[y]=cnt;cnt++;
}
void dp(int x,int fa){
    siz[x]=1;
    for(int i=head[x];i!=-1;i=nxt[i]){
        int to=L[i].to;
        if(to==fa) continue;dp(to,x);
        for(int j=min(siz[x],m);j>=0;j--)
         for(int k=min(siz[to],m);k>=0;k--){
            f[x][j+k]=max(f[x][j+k],f[x][j]+f[to][k]+L[i].val*1ll*k*(m-k)+L[i].val*1ll*(siz[to]-k)*(n-m-(siz[to]-k)));
         }
        siz[x]+=siz[to];
    }
}
int main()
{
    n=read();m=read();
    memset(head,-1,sizeof(head));
    memset(f,-0x3f,sizeof(f));
    for(int i=1;i<=n;i++) f[i][0]=f[i][1]=0;
    for(int i=1;i<n;i++){
        int x=read(),y=read(),c=read();
        add(x,y,c);
    }
    dp(1,0);
    printf("%lld",f[1][m]);
    return 0;
}

stevensonson

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
【DP】计划11.8——（树形依赖背包总结）&&分数规划思想

树形依赖背包指的就是一类具有树形依赖关系的背包问题。当选一个物品的前提是选另一件物品，而这些依赖关系构成了一个树形关系。在容量有限的情况下，然后求最大的价值，这类问题我们就称之为树形依赖背包。树形依赖背包问题实际上是一类分组背包问题，我们可以将每个点的子树看成一个组，因为子树内会选择一定的点，但是选择的点数只有一种情况，所以我们可以将子树选择iii（i∈[0,sizsonx]i∈[0,siz_{...
复制链接

扫一扫