洛谷P1064 金明的预算方案

题目描述

金明今天很开心，家里购置的新房就要领钥匙了，新房里有一间金明自己专用的很宽敞的房间。更让他高兴的是，妈妈昨天对他说：“你的房间需要购买哪些物品，怎么布置，你说了算，只要不超过

主件附件

电脑打印机，扫描仪

书柜图书

书桌台灯，文具

工作椅无

如果要买归类为附件的物品，必须先买该附件所属的主件。每个主件可以有

设第 $jj件物品的价格为v_[j]v[j]，重要度为w_[j]w[j]，共选中了kk件物品，编号依次为j_1,j_2,…,j_kj1,j2,…,jk，则所求的总和为：$

$v_[j_1] \times w_[j_1]+v_[j_2] \times w_[j_2]+ …+v_[j_k] \times w_[j_k]v[j1]×w[j1]+v[j2]×w[j2]+…+v[jk]×w[jk]。$

请你帮助金明设计一个满足要求的购物单。

输入输出格式

输入格式：

第

输出格式：

一个正整数，为不超过总钱数的物品的价格与重要度乘积的总和的最大值（

输入输出样例

输入样例#1：

输出样例#1：

2200


这道题乍看是树上依赖背包，直接在树上跑dp，仔细一看，每件物品最多有两件附件，且附件没有从属自己的附件，
也就是说对于每种主件来说选择是确定的：
1.不选主件和附件
2.只选主件
3.选主件+附件1
4.选主件+附件2
5.选主件+附件1+附件2
那么这道题就转化成01背包了，对于每一种状态有5种转移方式。
1.二维DP
由于题中求 不超过总钱数的物品的价格与重要度乘积的总和的最大值，我们令dp[i][j]表示在前i个主件中花费j元最多能够得到的价值*重要度的总和
dp方程可以很快得到：
///id1表示主件的第1个附件，id2表示主件的第2个附件
///lst表示上一个主件的位置，cost[i]表示第i个物品的花费，imp[i]表示第i个物品的重要度
///val[i]表示第i个物品的花费*重要度（这里已经预处理并存储了）

1    int id1 = attch[i][0],id2 = attch[i][1];
2    int tmp = cost[id1],mmp = cost[id2];
3    int a=dp[lst][j],b = (j-cost[i] >= 0 ? dp[lst][ j-cost[i] ] + val[i]:0);
4    int c=(j-cost[i]-tmp>=0?dp[lst][j-cost[i]-tmp]+val[i]+tmp*imp[id1]:0);
5    int d=(j-cost[i]-mmp>=0?dp[lst][j-cost[i]-mmp]+val[i]+mmp*imp[id2]:0);
6    int e=(j-cost[i]-tmp-mmp>=0?dp[lst][j-cost[i]-tmp-mmp]+val[i]+tmp*imp[id1]+mmp*imp[id2]:0);
7    dp[i][j]=max(max(max(max(a,b),c),d),e);

接下来就是经典的二重循环转移了，这里不再赘述

问题来了

看下面的代码：

1    for(int j=mon;j>=cost[u];j--)

mon表示预算(题中的N)，cost [ u ] 表示当前主件的花费

如果你是这么写的话，在洛谷上提交代码，你会发现WA了一个点

为什么呢?

因为我们第一种情况并没有全部从上一个主件转移到现在的主件

当 j < cost [ i ] 时，我们发现五个转移条件中有四个不满足，但是第一种情况是可以转移的！

所以当数据不是太水的时候，会存在一些测试点恰好用得上这第一种转移，

所以正确写法是这样的：

1    for(int j=mon;j>=1;j--)

2.一维DP（滚动数组）

我们可以发现我们每一次的转移都是建立在上一次的基础上，所以我们只要逆序dp，这样使得此次dp都是由上一次的状态转移而来

同理：

1     int id1=attch[i][0],id2=attch[i][1];
2     int tmp=cost[id1],mmp=cost[id2];
3     int a=dp[j],b=(j-cost[i]>=0?dp[j-cost[i]]+val[i]:0);
4     int c=(j-cost[i]-tmp>=0?dp[j-cost[i]-tmp]+val[i]+tmp*imp[id1]:0);
5     int d=(j-cost[i]-mmp>=0?dp[j-cost[i]-mmp]+val[i]+mmp*imp[id2]:0);
6     int e=(j-cost[i]-tmp-mmp>=0?dp[j-cost[i]-tmp-mmp]+val[i]+tmp*imp[id1]+mmp*imp[id2]:0);
7     dp[j]=max(max(max(max(a,b),c),d),e);

接下来就是经典的01背包循环了

那么一维dp是否存在上述二维数组的问题呢？？

我们发现一维dp是在覆盖上一次状态的基础上达到优化空间的目的的，所以未覆盖的位置（j < cost [ i ] 时）是依旧存在于数组中的，这样就不存在上述问题了

两个方案代码如下

 1 #include<cstring>
 2 #include<cstdio>
 3 #include<iostream>
 4 #include<cmath>
 5 #include<algorithm>
 6 #include<string>
 7 #include<cctype>
 8 #include<vector>
 9 using namespace std;
10 namespace zi_qilin
11 {
12     const int maxm=32000+100;
13     const int maxn=60+10;
14     int n,mon,lst;
15     int imp[maxn],val[maxn],cost[maxn],dp[maxn][maxm];
16     int attch[maxm][2];
17     vector<int> obj;
18     inline int read()
19     {
20         int x=0;bool w=0;char c=0;
21         while(!isdigit(c)) w|=c=='-',c=getchar();
22         while(isdigit(c)) x=(x<<1)+(x<<3)+(c^48),c=getchar();
23         return w?-x:x;
24     }
25     inline void fuzhi(int i,int j)
26     {
27         int id1=attch[i][0],id2=attch[i][1];
28         int tmp=cost[id1],mmp=cost[id2];
29         int a=dp[lst][j],b=(j-cost[i]>=0?dp[lst][j-cost[i]]+val[i]:0);
30         int c=(j-cost[i]-tmp>=0?dp[lst][j-cost[i]-tmp]+val[i]+tmp*imp[id1]:0);
31         int d=(j-cost[i]-mmp>=0?dp[lst][j-cost[i]-mmp]+val[i]+mmp*imp[id2]:0);
32         int e=(j-cost[i]-tmp-mmp>=0?dp[lst][j-cost[i]-tmp-mmp]+val[i]+tmp*imp[id1]+mmp*imp[id2]:0);
33         dp[i][j]=max(max(max(max(a,b),c),d),e);
34         //printf("%d\n",dp[i][j]);
35         //if(i==4) printf("%d %d\n",j,dp[i][j]);
36     }
37     inline int work()
38     {
39         memset(attch,0,sizeof(attch));
40         mon=read()/10,n=read();
41         obj.push_back(0);
42         for(int i=1;i<=n;i++)
43         {
44             int a=read()/10,b=read(),q=read();
45             cost[i]=a,imp[i]=b;
46             val[i]=a*b;
47             if(q)
48             {
49                 if(attch[q][0]) attch[q][1]=i;
50                 else attch[q][0]=i;
51                 continue;
52             }
53             obj.push_back(i);
54         }
55         memset(dp,0,sizeof(dp));
56         lst=0;
57         for(int i=1;i<obj.size();i++)
58         {
59             int u=obj[i];
60             for(int j=mon;j>=1;j--)
61             {
62                 fuzhi(u,j);
63             }
64             lst=obj[i];
65             //printf("%d\n",dp[lst][mon]);
66         }
67         printf("%d",dp[lst][mon]*10);
68         return 0;
69     }
70 }
71 int main()
72 {
73     //system("mode con cols=100 lines=10000");
74     //freopen("testdata.in","r",stdin);
75     //freopen("ppp.out","w",stdout);
76     return zi_qilin::work();
77 }

 1 #include<cstring>
 2 #include<cstdio>
 3 #include<iostream>
 4 #include<cmath>
 5 #include<algorithm>
 6 #include<string>
 7 #include<cctype>
 8 #include<vector>
 9 using namespace std;
10 namespace zi_qilin
11 {
12     const long long maxm=32000+100;
13     const long long maxn=60+10;
14     long long n,mon,lst;
15     long long imp[maxn],val[maxn],cost[maxn],dp[maxm];
16     long long attch[maxm][2];
17     vector<long long> obj;
18     inline long long read()
19     {
20         long long x=0;bool w=0;char c=0;
21         while(!isdigit(c)) w|=c=='-',c=getchar();
22         while(isdigit(c)) x=(x<<1)+(x<<3)+(c^48),c=getchar();
23         return w?-x:x;
24     }
25     inline void fuzhi(long long i,long long j)
26     {
27         long long id1=attch[i][0],id2=attch[i][1];
28         long long tmp=cost[id1],mmp=cost[id2];
29         long long a=dp[j],b=(j-cost[i]>=0?dp[j-cost[i]]+val[i]:0);
30         long long c=(j-cost[i]-tmp>=0?dp[j-cost[i]-tmp]+val[i]+tmp*imp[id1]:0);
31         long long d=(j-cost[i]-mmp>=0?dp[j-cost[i]-mmp]+val[i]+mmp*imp[id2]:0);
32         long long e=(j-cost[i]-tmp-mmp>=0?dp[j-cost[i]-tmp-mmp]+val[i]+tmp*imp[id1]+mmp*imp[id2]:0);
33         dp[j]=max(max(max(max(a,b),c),d),e);
34         //printf("%d\n",dp[j]);
35     }
36     inline long long work()
37     {
38         memset(attch,0,sizeof(attch));
39         mon=read()/10,n=read();
40         obj.push_back(0);
41         for(long long i=1;i<=n;i++)
42         {
43             long long a=read()/10,b=read(),q=read();
44             cost[i]=a,imp[i]=b;
45             val[i]=a*b;
46             if(q)
47             {
48                 if(attch[q][0]) attch[q][1]=i;
49                 else attch[q][0]=i;
50                 continue;
51             }
52             obj.push_back(i);
53         }
54         memset(dp,0,sizeof(dp));
55         lst=0;
56         for(long long i=1;i<obj.size();i++)
57         {
58             long long u=obj[i];
59             for(long long j=mon;j>=cost[u];j--)
60             {
61                 fuzhi(u,j);
62             }
63             lst=u;
64         }
65         printf("%lld",dp[mon]*10);
66         return 0;
67     }
68 }
69 int main()
70 {
71     //freopen("testdata.in","r",stdin);
72     //freopen("mmp.out","w",stdout);
73     return zi_qilin::work();
74 }

ps：就这个问题我调了一个小时，果然还是一维数组省心啊~~