不止代码：洛谷P1064 金明的预算方案+P2014选课（依赖背包）

题目描述

金明的预算方案
选课
金明今天很开心，家里购置的新房就要领钥匙了，新房里有一间金明自己专用的很宽敞的房间。更让他高兴的是，妈妈昨天对他说：“你的房间需要购买哪些物品，怎么布置，你说了算，只要不超过 n元钱就行”。今天一早，金明就开始做预算了，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的。
如果要买归类为附件的物品，必须先买该附件所属的主件。每个主件可以有 0个、1 个或 2 个附件。每个附件对应一个主件，附件不再有从属于自己的附件。金明想买的东西很多，肯定会超过妈妈限定的 n 元。于是，他把每件物品规定了一个重要度，分为 5 等：用整数1∼5 表示，第 5 等最重要。他还从因特网上查到了每件物品的价格（都是 10 元的整数倍）。他希望在不超过 n 元的前提下，使每件物品的价格与重要度的乘积的总和最大。

总结

本题一般性题解是自己独立写的，而且思路很简洁，复杂度也很好

但是这题WA了好几次，每次都是写的时候信心满满，交完发现不对，用数据检测才发现漏洞（老毛病了。。。）
以后应该改改这个坏习惯，应该先把思路想明白了（至少先拿点好的数据测测再交啊！ ）

解析

解法1

由于本题的特殊限制，对于每个主件，最多可以分为五种情况:

1.都不买
2.只买主件
3.买主件与附件A
4.买主件与附件B
5.买主件与附件A、B

然后就可以转化为01背包了

但是我们岂可满足于此！

解法2

当附件很多且存在附件之后还有附件时应该怎么办呢？
深思熟虑后：啊哈！
我们把dp开成二维
dp[k][w]表示第k层依赖关系下，物品必须购买，w的钱获得的最大价值
对于处于第k层的物品A，枚举它的所有附件，将其作为第k+1层递归处理
然后尝试用第k层的dp值更新k-1层的dp值
最后，dp[0][n]就是答案
因为每个物品最多处理一次，单层递归复杂度是n
所以总时间复杂度为m*n（和01背包一样啊有木有！）
不难看出，空间复杂度也是n*m

代码

#include <bits/stdc++.h>
using namespace std;
const int N=1e6+100;
int n,m;
struct node{
	int w,v,belong;
	int nxt[500],nm;
}p[500];
int a,b,c;
int f[80][34050];
int jd[500];
void Try(int k,int id){
	for(int i=0;i<=n;i++){
		if(i<p[id].w) f[k][i]=-2e9;
		else f[k][i]=f[k-1][i-p[id].w]+p[id].v;
	}
	for(int i=1;i<=p[id].nm;i++){
		Try(k+1,p[id].nxt[i]);
	}
	for(int i=0;i<=n;i++) f[k-1][i]=max(f[k-1][i],f[k][i]);
}
void print(){
	for(int i=1;i<=n;i++) printf("%d ",f[0][i]);
	printf("\n");
	return;
}
int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++){
		scanf("%d%d%d",&p[i].w,&p[i].v,&p[i].belong);
		p[i].v*=p[i].w;
		if(p[i].belong) p[p[i].belong].nxt[++p[p[i].belong].nm]=i;
	}
	for(int i=1;i<=m;i++){
		if(p[i].belong) continue;
		Try(1,i);
//		print();
	}
	printf("%d",f[0][n]);
	return 0;
} 
/*
5 5
1 100 0
2 1 0
1 1000 2
2 2 2
6 10000 0
*/

解法3

树上dfs一边求出size和dfs序（注意是后序！）
因为后序dfs序，所以子节点的dfs序比父节点小
这样我们就可以从前往后dp
𝑑𝑝[𝑖][𝑗]​表示前i个点里选j个物品的最大价值
那么转移就是：

𝑑𝑝[𝑖][𝑗]=max⁡(𝑑𝑝[𝑖−1][𝑗−1]+𝑣𝑎𝑙[𝑝𝑜𝑠[𝑖]],𝑑𝑝[𝑖−𝑠𝑖𝑧[𝑝𝑜𝑠[𝑖]]][𝑗])

前一个转移是选当前课
后一个是不选当前课（那么之前就只能选到𝑖−𝑠𝑖𝑧[𝑝𝑜𝑠[𝑖]]）
最后答案就是dp[n][m]

代码

#include <bits/stdc++.h>
using namespace std;
const int N=1800;
int n,m;
/*
op=0 被自己覆盖
op=1 被儿子覆盖
op=2 被父亲覆盖  
*/
struct node{
	int to,nxt;
}p[N];
int fi[N],cnt=-1,ru[N];
int v[N],belong[N];
void addline(int x,int y){
	p[++cnt]=(node){y,fi[x]};
	fi[x]=cnt;
}
int a,b,c;
int pos[N],dfs[N],size[N],tot;
void build(int x,int fa){
	size[x]=1;
	for(int i=fi[x];~i;i=p[i].nxt){
		int to=p[i].to;
		build(to,x);
		size[x]+=size[to];
	}
	dfs[x]=++tot;
	pos[tot]=x;
}
int dp[N][N];
int main(){
	memset(fi,-1,sizeof(fi));
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++){
		scanf("%d%d",&belong[i],&v[i]);
		if(belong[i]) addline(belong[i],i);
		else addline(0,i);
	}
	build(0,-1);
	for(int i=1;i<=tot;i++){
		int id=pos[i];
		for(int j=m;j>=1;j--){
			dp[i][j]=max(dp[i-1][j-1]+v[id],dp[i-size[id]][j]);
		}
	}
	printf("%d",dp[n][m]);
	return 0;
} 
/*
6
1 30 3 2 3 4
2 16 2 5 6
3 5 0
4 4 0
5 11 0
6 5 0
*/