金明的预算---RQNOJ_6------01背包和树形DP两种算法

题目地址：http://www.rqnoj.cn/Problem_6.html

题目描述

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

　　设第j件物品的价格为v[j]，重要度为w[j]，共选中了k件物品，编号依次为j1，j2，……，jk，则所求的总和为：v[j1]*w[j1]+v[j2]*w[j2]+ …+v[jk]*w[jk]。（其中*为乘号）请你帮助金明设计一个满足要求的购物单。

输入格式

　　输入文件的第1行，为两个正整数，用一个空格隔开：
N m 
其中N（<32000）表示总钱数，m（<60）为希望购买物品的个数。）
从第2行到第m+1行，第j行给出了编号为j-1的物品的基本数据，每行有3个非负整数
v p q
（其中v表示该物品的价格（v<10000），p表示该物品的重要度（1~5），q表示该物品是主件还是附件。如果q=0，表示该物品为主件，如果q>0，表示该物品为附件，q是所属主件的编号）

输出格式

　　 输出文件只有一个正整数，为不超过总钱数的物品的价格与重要度乘积的总和的最大值
（<200000）。

样例输入

1000 5
800 2 0
400 5 1
300 5 1
400 3 0
500 2 0

样例输出

2200

这个题的题意就是有一些物品，有的是主件，有的是附件，附件依附于主件，附件没有依附于它的附件，要买附件，就要买它所依附的主件。给你一定的金钱，以及一些物品，要求在所给的钱的范围内买一些物品，使得这些物品的费用乘以重要度之和最大。另外，所有的费用都是10的倍数，所以这个可以拿来优化，减少空间和时间消耗。

这个题有两种解法是比较同意理解的。

首先是01背包解法：

因为每一个主件最多只有2件附件，所以主件和已知的附件的组合方式是可以枚举出来的。那么我们将主件以及依附于主件的附件放在一个集合内，然后在求每组时，求出最大的那一种，即  max(主件、取主件＋附件1、取主件＋附件2、既主件＋附件1＋附件2 )，然后通过01背包的算法求出最大的那一个。

#include
using namespace std;

int dp[62][4000] ;  //dp[i][j] 表示在前i类物品中花j元所能获得的最大值
struct thing
{
	int v,p;
	int set; 
}; 
thing a[62][62]; //a[i][j] 表示第i类产品第j个物品的价值,重要度，和位置   其中0代表的是主件 

int main()
{
	int n,m; //has n moneys ,want to buy m kinds of things
	while(scanf("%d%d",&n,&m) != EOF)
	{
		n = n/10; 
		int i,j;
		int v,p,q;
		int s = 0;
		
		for(i=0;i<=m;i++)
			for(j=0;j<=m;j++)
			{ 
				a[i][j].v = 0;//as a sign
				a[i][j].p = 0;
			} 
		for(i=1;i<=m;i++)
		{
			scanf("%d%d%d",&v,&p,&q);
			v = v/10; //优化，因为价格必定是10的整数倍
			if(q == 0) //it is a main thing 
			{
				s++;
				a[s][0].v = v;
				a[s][0].p = v*p;
				a[s][0].set = i;
				  
			}
			else
			{
				int k = 1;
				while(k<=s && a[k][0].set != q)  //找到这个附件属于哪一类 
					k++;
				if(a[k][1].v == 0) //the first  
				{
					a[k][1].v = v;
					a[k][1].p = v*p;
				} 
				else				//the second 
				{
					a[k][2].v = v;
					a[k][2].p = v*p;
				} 
			} 
		}
		//下面开始用01背包的思想来解决问题
		memset(dp,0,sizeof(dp));
		for(i=1;i<=s;i++)
		{
			for(j=n;j>=0;j--)
			{
				dp[i][j] = dp[i-1][j];  //第i类物品直接不取
				if(j>=a[i][0].v && dp[i-1][j-a[i][0].v] + a[i][0].p > dp[i][j])//只取一个主件 ， 
					dp[i][j] =  dp[i-1][j-a[i][0].v] + a[i][0].p;
				if(j>=a[i][0].v+a[i][1].v && dp[i-1][j-a[i][0].v-a[i][1].v]+a[i][0].p+a[i][1].p > dp[i][j])
					dp[i][j] =  dp[i-1][j-a[i][0].v-a[i][1].v]+a[i][0].p+a[i][1].p;
				if(j>=a[i][0].v+a[i][2].v && dp[i-1][j-a[i][0].v-a[i][2].v]+a[i][0].p+a[i][2].p > dp[i][j])
					dp[i][j] =  dp[i-1][j-a[i][0].v-a[i][2].v]+a[i][0].p+a[i][2].p;
				if(j>=a[i][0].v+a[i][1].v+a[i][2].v && dp[i-1][j-(a[i][0].v+a[i][1].v+a[i][2].v)]+a[i][0].p+a[i][1].p+a[i][2].p>dp[i][j])
					dp[i][j] =  dp[i-1][j-(a[i][0].v+a[i][1].v+a[i][2].v)] + a[i][0].p+a[i][1].p+a[i][2].p; 
			} 
		}
		 
		printf("%d\n",dp[s][n]*10); 
	}
	return 0; 
} 

其次就是通过树形DP的算法：

因为有主件和附件之分，那么附件可以作为主件的儿子节点，因为一个主件可能有多个附件，所以为了方便算法实现，我们需把这个转换成二叉树，即左儿子是它的的附件，而右儿子这是兄弟，也就是在同一级别上的，所有的主件公用一个父亲节点，然后就是要在这个树上以父亲节点的第一个节点为根，求能达到的最大值。下面为大家上传代码。

//金明的预算，用树形DP去做，锻炼一哈自己
//但是真的是被恶心到了 
#include
using namespace std;

struct bit_tree
{
	int ld; //left child 
	int rd; //right child
	int v;
	int w; 
	int lastchild; 
}tree[62];

void fun(int x,int y);
int dp[62][4000];  //dp[i][j]表示以i为节点，花费j元所能得到的最大值 
int main()
{
	int n,m;
	while(scanf("%d%d",&n,&m) != EOF)
	{
		n=n/10; //优化 
		int i,j;
		int v,p,q;
		for(i=0;i<=m;i++)
		{
			tree[i].ld = -1;
			tree[i].rd = -1; 
		}
		
		for(i=0;i<=m;i++)
			for(j=0;j<=n;j++)
				dp[i][j] = -1;    //表示以i节点为根花费j元能取得的最大值
		tree[0].w = 0; 
		for(i=1;i<=m;i++)
		{
			scanf("%d%d%d",&v,&p,&q);
			v=v/10;  //优化 
			tree[i].v = v;
			tree[i].w = v*p;  
			if(tree[q].ld == -1)  //即父亲节点还没有左孩子
			{ 
				tree[q].ld = i;
				tree[q].lastchild = i;				
			}
			else
			{
				tree[tree[q].lastchild].rd = i;
				tree[q].lastchild = i;				 
			} 			 
		}
		
		for(i=0;i<=m;i++)  //初始化叶子节点
		{
			if(tree[i].ld == -1 && tree[i].rd == -1)
				for(j=n;j>=0;j--)
					if(j>=tree[i].v) 
						dp[i][j] = tree[i].w;
					else
						dp[i][j] = 0; 
		}
		fun(1,n); 
		printf("%d\n",dp[1][n]*10); //乘以 10是因为前面在优化的时候除以10了 
	}
	
	return 0; 
} 


void fun(int x,int y)
{
	if(dp[x][y] >= 0 || x==-1)
		 return;
	if(tree[x].ld == -1)  //这个if是优化代码部分，避免超时 ,就是该节点没有左孩子的情况下的做法 
	{
		if(y>=tree[x].v)
		{
			fun(tree[x].rd,y); 
			dp[x][y] = dp[tree[x].rd][y];
			fun(tree[x].rd,y-tree[x].v);
			if(dp[x][y] < tree[x].w + dp[tree[x].rd][y-tree[x].v])
				dp[x][y] = tree[x].w + dp[tree[x].rd][y-tree[x].v];
			return ;	 
		} 
	}
	fun(tree[x].rd,y);  //把y元全部分给右子树
	int max = dp[tree[x].rd][y]; //作为max的初值 
	int k;
	for(k=tree[x].v;k<=y;k++) //不是全部分给右子树的情况下，在给x节点留出费用后，
						 //其余的由左子树和右子树互相分掉，则要枚举出不同的情况 
	{
		fun(tree[x].ld,k-tree[x].v);
		fun(tree[x].rd,y-k);
		int temp = dp[tree[x].ld][k-tree[x].v] + dp[tree[x].rd][y-k] + tree[x].w;
		if(max < temp)
			max = temp; 
	} 
	dp[x][y] = max; 
}