疯狂的采药（C++，完全背包）
题目背景
此题为纪念 LiYuxiang 而生。
题目描述
LiYuxiang 是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。为此，他想拜附近最有威望的医师为师。医师为了判断他的资质，给他出了一个难题。医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同种类的草药，采每一种都需要一些时间，每一种也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。”
如果你是 LiYuxiang，你能完成这个任务吗？
此题和原题的不同点：
1
1
1. 每种草药可以无限制地疯狂采摘。
2
2
2. 药的种类眼花缭乱，采药时间好长好长啊！师傅等得菊花都谢了！
输入格式
输入第一行有两个整数，分别代表总共能够用来采药的时间
t
t
t 和代表山洞里的草药的数目
m
m
m。
第
2
2
2 到第
(
m
+
1
)
(m + 1)
(m+1) 行，每行两个整数，第
(
i
+
1
)
(i + 1)
(i+1) 行的整数
a
i
,
b
i
a_i, b_i
ai?,bi? 分别表示采摘第
i
i
i 种草药的时间和该草药的价值。
输出格式
输出一行，这一行只包含一个整数，表示在规定的时间内，可以采到的草药的最大总价值。
样例 #1
样例输入 #1
70 3
71 100
69 1
1 2
样例输出 #1
140
提示
数据规模与约定
- 对于
30
%
30\%
30% 的数据，保证
m
≤
1
0
3
m \le 10^3
m≤103 。
- 对于
100
%
100\%
100% 的数据，保证
1
≤
m
≤
1
0
4
1 \leq m \le 10^4
1≤m≤104，
1
≤
t
≤
1
0
7
1 \leq t \leq 10^7
1≤t≤107，且
1
≤
m
×
t
≤
1
0
7
1 \leq m \times t \leq 10^7
1≤m×t≤107，
1
≤
a
i
,
b
i
≤
1
0
4
1 \leq a_i, b_i \leq 10^4
1≤ai?,bi?≤104。
解题思路：
在理解本题解题思路之前，建议先了解一下01背包问题
01背包问题的状态转移方程如下
values[i][j] = max(values[i - 1][j], values[i - 1][j - w[i]] + v[i])
行标代表是第几个物品，列标代表剩余的背包空间，w[i]为第i个物品的质量，v[i]为第i个物品的价值
完全背包问题与01背包问题的不同点在于处理每个物品时，不再是只有选与不选两种情况，而是有选1个、2个…多种情况
于是我们尝试得到完全背包问题的状态转移方程
values[i][j] = max(values[i - 1][j], values[i - 1][j - k*w[i]] + k*v[i])
但如果只是简单尝试枚举k的所有可能，仍然会TLE，那就需要再次动态规划了
思考一下会发现，选择k个物品时的最大值可以由选择k-1个物品时的最大值得到，以此进行优化，可以得到状态转移方程
values[i][j] = max(values[i - 1][j], values[i][j - w[i]] + v[i])
要注意到，优化前后，对于i号物品，不选时的转移表达式没有变化，选择时的转移表达式变成了同一行中的另一个状态，仅此而已
时间优化完成了，但空间同样需要优化，所以考虑滚动数组
对于i号物品，我们需要的只是第i行和i-1行，其他可以略去，利用i%2带来的性质即可
AC代码如下
#include <iostream>
using namespace std;
const int max_n = 1e7;
struct herb {
int time;
int value;
};
herb herbs[max_n];
int max_values[2][max_n] = { 0 };
int ans = 0, t, n;
int main() {
cin >> t >> n;
for (int i = 0; i < n; i++) cin >> herbs[i].time >> herbs[i].value;
for (int i = 0; i < n; i++)
for (int j = 0; j <= t; j++) {
if (j - herbs[i].time < 0) {
if (i == 0) max_values[i % 2][j] = 0;
else max_values[i % 2][j] = max_values[(i - 1) % 2][j];
continue;
}
max_values[i % 2][j] = max(max_values[(i - 1) % 2][j], max_values[i % 2][j - herbs[i].time] + herbs[i].value);
ans = max_values[i % 2][j] > ans ? max_values[i % 2][j] : ans;
}
cout << ans;
return 0;
}
骗你的，这段代码还不能AC，因为…没错就是没开long long
/* 十年 OI 一场空，不开 long long 见祖宗。 */
上面的代码已经可以AC了，但其实这段代码还可以优化，接下来展示一次性优化时间和空间
对于第
i
i
i个物品，当
j
∈
[
0
,
h
e
r
b
s
[
i
]
)
j \in [0, herbs[i])
j∈[0,herbs[i])时，有max_values[i][j] == max_values[i][j - 1]
所以可以合并
对于
j
∈
[
h
e
r
b
[
i
]
,
t
]
j \in [herb[i], t]
j∈[herb[i],t]，转移表达式的本质就是比较max_values[i - 1][j]和max_values[i][j - herbs[i].time] + herbs[i].value的大小，后者大则赋值，否则不变
所以可以合并
综上，二维数组合并为一维，j从herbs[i].time开始遍历即可
优化后代码如下
#include <iostream>
using namespace std;
const int max_n = 1e7;
struct herb {
int time;
int value;
};
herb herbs[max_n];
long long max_values[max_n] = { 0 };
int main() {
int t, n;
cin >> t >> n;
for (int i = 0; i < n; i++) cin >> herbs[i].time >> herbs[i].value;
for (int i = 0; i < n; i++)
for (int j = herbs[i].time; j <= t; j++)
max_values[j] = max(max_values[j], max_values[j - herbs[i].time] + herbs[i].value);
cout << max_values[t];
return 0;
}
樱花（C++，混合背包）
题目背景
《爱与愁的故事第四弹·plant》第一章。
题目描述
爱与愁大神后院里种了
n
n
n 棵樱花树，每棵都有美学值
C
i
(
0
≤
C
i
≤
200
)
C_i(0 \le C_i \le 200)
Ci?(0≤Ci?≤200)。爱与愁大神在每天上学前都会来赏花。爱与愁大神可是生物学霸，他懂得如何欣赏樱花：一种樱花树看一遍过，一种樱花树最多看
A
i
(
0
≤
A
i
≤
100
)
A_i(0 \le A_i \le 100)
Ai?(0≤Ai?≤100) 遍，一种樱花树可以看无数遍。但是看每棵樱花树都有一定的时间
T
i
(
0
≤
T
i
≤
100
)
T_i(0 \le T_i \le 100)
Ti?(0≤Ti?≤100)。爱与愁大神离去上学的时间只剩下一小会儿了。求解看哪几棵樱花树能使美学值最高且爱与愁大神能准时（或提早）去上学。
输入格式
共
n
+
1
n+1
n+1行：
第
1
1
1 行：现在时间
T
s
T_s
Ts?（几时：几分），去上学的时间
T
e
T_e
Te?（几时：几分），爱与愁大神院子里有几棵樱花树
n
n
n。这里的
T
s
T_s
Ts?，
T
e
T_e
Te? 格式为：hh:mm，其中
0
≤
h
h
≤
23
0 \leq hh \leq 23
0≤hh≤23，
0
≤
m
m
≤
59
0 \leq mm \leq 59
0≤mm≤59，且
h
h
,
m
m
,
n
hh,mm,n
hh,mm,n 均为正整数。
第
2
2
2 行到第
n
+
1
n+1
n+1 行，每行三个正整数：看完第
i
i
i 棵树的耗费时间
T
i
T_i
Ti?，第
i
i
i 棵树的美学值
C
i
C_i
Ci?，看第
i
i
i 棵树的次数
P
i
P_i
Pi?（
P
i
=
0
P_i=0
Pi?=0 表示无数次，
P
i
P_i
Pi? 是其他数字表示最多可看的次数
P
i
P_i
Pi?）。
输出格式
只有一个整数，表示最大美学值。
样例 #1
样例输入 #1
6:50 7:00 3
2 1 0
3 3 1
4 5 4
样例输出 #1
11
提示
100
%
100\%
100% 数据：
T
e
?
T
s
≤
1000
T_e-T_s \leq 1000
Te??Ts?≤1000（即开始时间距离结束时间不超过
1000
1000
1000 分钟），
n
≤
10000
n \leq 10000
n≤10000。保证
T
e
,
T
s
T_e,T_s
Te?,Ts? 为同一天内的时间。
样例解释：赏第一棵樱花树一次，赏第三棵樱花树
2
2
2 次。
解题思路：
本题是一道混合背包问题，如果没了解过01背包问题和完全背包问题可以先去了解一下再回来看这道题
01背包状态转移方程（空间优化后）：
for (int i = 0; i < n; i++)
for (int j = m; j >= w[i]; j--)
max_v[j] = max(max_v[j] : max_v[j - w[i]] + v[i]);
完全背包状态转移方程（空间优化后）：
for (int i = 0; i < n; i++)
for (int j = w[i]; j<= m; j++)
max_v[j] = max(max_v[j] : max_v[j - w[i]] + v[i]);
然后把a == 0看作完全背包，把a != 0看作a个相同物品的01背包，就可以AC了
AC代码如下（注：可以只看main()里面的代码）
#include <iostream>
using namespace std;
const int max_n = 1e4;
const int max_t = 1e3;
class Sakura {
public:
int t;
int c;
int a;
friend istream& operator>>(istream& in_put, Sakura& sak);
};
class Time {
private:
int hour;
int minute;
public:
friend istream& operator>>(istream& in_put, Time& t);
int calculate_minute();
};
Sakura sakura_arr[max_n];
long long max_values[max_t] = { 0 };
int main() {
int n, sum_t;
Time ini_t, end_t;
cin >> ini_t >> end_t >> n;
sum_t = end_t.calculate_minute() - ini_t.calculate_minute();
for (int i = 0; i < n; i++) cin >> sakura_arr[i];
for (int i = 0; i < n; i++)
if (sakura_arr[i].a == 0)
for (int j = sakura_arr[i].t; j <= sum_t; j++)
max_values[j] = max(max_values[j], max_values[j - sakura_arr[i].t] + sakura_arr[i].c);
else
for (int j = 1; j <= sakura_arr[i].a; j++)
for (int z = sum_t; z >= sakura_arr[i].t; z--)
max_values[z] = max(max_values[z], max_values[z - sakura_arr[i].t] + sakura_arr[i].c);
cout << max_values[sum_t];
return 0;
}
istream& operator>>(istream& in_put, Sakura& sak) {
in_put >> sak.t >> sak.c >> sak.a;
return in_put;
}
int Time::calculate_minute() {
return this->hour * 60 + this->minute;
}
istream& operator>>(istream& in_put, Time& t) {
char c = '\0';
in_put >> t.hour >> c >> t.minute;
return in_put;
}
代码还可以通过二进制拆分进一步优化
通过举例说明二进制拆分的思路
10 1 10\\樱花的数据
10二进制拆分后111 + 3，所以拆成了四个物品：
10 1，20 2，40 4，30 3
这样就只需要搜索4个物品而不是10个物品，完成了时间优化
至于为什么二进制拆分不是1010以及为什么这样拆分保证能表达任意数量的物品，可以根据这个例子简单思考一下
优化后的代码如下
#include <iostream>
using namespace std;
const int max_n = 1e4;
const int max_t = 1e3;
const int max_n_2 = 1e6;
class Sakura {
public:
int t;
int c;
int a;
friend istream& operator>>(istream& in_put, Sakura& sak);
};
class Time {
private:
int hour;
int minute;
public:
friend istream& operator>>(istream& in_put, Time& t);
int calculate_minute();
};
Sakura sakura_arr[max_n];
long long max_values[max_t] = { 0 };
Sakura sakura_arr_2[max_n_2];
int binary_disassembly(int n) {
int n_2 = 0;
for (int i = 0; i < n; i++) {
if (sakura_arr[i].a == 0) {
sakura_arr_2[n_2++] = sakura_arr[i];
continue;
}
int power = 1;
while (sakura_arr[i].a) {
sakura_arr_2[n_2].a = 1;
sakura_arr_2[n_2].c = sakura_arr[i].c * power;
sakura_arr_2[n_2].t = sakura_arr[i].t * power;
sakura_arr[i].a -= power;
power *= 2, n_2++;
if (sakura_arr[i].a < power) {
sakura_arr_2[n_2].a = 1;
sakura_arr_2[n_2].c = sakura_arr[i].c * sakura_arr[i].a;
sakura_arr_2[n_2].t = sakura_arr[i].t * sakura_arr[i].a;
n_2++;
break;
}
}
}
return n_2;
}
int main() {
int n, sum_t, n_2;
Time ini_t, end_t;
cin >> ini_t >> end_t >> n;
sum_t = end_t.calculate_minute() - ini_t.calculate_minute();
for (int i = 0; i < n; i++) cin >> sakura_arr[i];
n_2 = binary_disassembly(n);
for (int i = 0; i < n_2; i++)
if (sakura_arr_2[i].a == 0)
for (int j = sakura_arr_2[i].t; j <= sum_t; j++)
max_values[j] = max(max_values[j], max_values[j - sakura_arr_2[i].t] + sakura_arr_2[i].c);
else
for (int z = sum_t; z >= sakura_arr_2[i].t; z--)
max_values[z] = max(max_values[z], max_values[z - sakura_arr_2[i].t] + sakura_arr_2[i].c);
cout << max_values[sum_t];
return 0;
}
istream& operator>>(istream& in_put, Sakura& sak) {
in_put >> sak.t >> sak.c >> sak.a;
return in_put;
}
int Time::calculate_minute() {
return this->hour * 60 + this->minute;
}
istream& operator>>(istream& in_put, Time& t) {
char c = '\0';
in_put >> t.hour >> c >> t.minute;
return in_put;
}
[NOIP2012 普及组] 摆花（C++，动态规划）
题目描述
小明的花店新开张，为了吸引顾客，他想在花店的门口摆上一排花，共
m
m
m 盆。通过调查顾客的喜好，小明列出了顾客最喜欢的
n
n
n 种花，从
1
1
1 到
n
n
n 标号。为了在门口展出更多种花，规定第
i
i
i 种花不能超过
a
i
a_i
ai? 盆，摆花时同一种花放在一起，且不同种类的花需按标号的从小到大的顺序依次摆列。
试编程计算，一共有多少种不同的摆花方案。
输入格式
第一行包含两个正整数
n
n
n 和
m
m
m，中间用一个空格隔开。
第二行有
n
n
n 个整数，每两个整数之间用一个空格隔开，依次表示
a
1
,
a
2
,
?
?
,
a
n
a_1,a_2, \cdots ,a_n
a1?,a2?,?,an?。
输出格式
一个整数，表示有多少种方案。注意：因为方案数可能很多，请输出方案数对
1
0
6
+
7
10^6+7
106+7 取模的结果。
样例 #1
样例输入 #1
2 4
3 2
样例输出 #1
2
提示
【数据范围】
对于
20
%
20\%
20% 数据，有
0
<
n
≤
8
,
0
<
m
≤
8
,
0
≤
a
i
≤
8
0<n \le 8,0<m \le 8,0 \le a_i \le 8
0<n≤8,0<m≤8,0≤ai?≤8。
对于
50
%
50\%
50% 数据，有
0
<
n
≤
20
,
0
<
m
≤
20
,
0
≤
a
i
≤
20
0<n \le 20,0<m \le 20,0 \le a_i \le 20
0<n≤20,0<m≤20,0≤ai?≤20。
对于
100
%
100\%
100% 数据，有
0
<
n
≤
100
,
0
<
m
≤
100
,
0
≤
a
i
≤
100
0<n \le 100,0<m \le 100,0 \le a_i \le 100
0<n≤100,0<m≤100,0≤ai?≤100。
NOIP 2012 普及组 第三题
解题思路：
首先最容易想到的就是暴力搜索
void dfs(int n, int m) {
if (n == -1 && m != 0 || m < 0) return;
if (m == 0) {
sum += 1; return;
}
for (int i = flowers[n]; i >= 0; i--)
dfs(n - 1, m - i);
}
/* 代码五分钟，运行两小时 */
所以我们需要动态规划，记忆是最容易想到的方法
记忆策略：n和m均相同时，ans相同
AC代码如下
#include <iostream>
using namespace std;
const int max_n = 100;
const int max_m = 100;
const int mod_num = 1e6 + 7;
int flowers[max_n] = { 0 };
int ans[max_n][max_m + 1] = { 0 };
int dfs(int n, int m) {
if (n == -1 && m != 0 || m < 0) return 0;
if (m == 0) return 1;
if (ans[n][m]) return ans[n][m];
for (int i = flowers[n]; i >= 0; i--)
ans[n][m] = (ans[n][m] + dfs(n - 1, m - i)) % mod_num;
return ans[n][m];
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> flowers[i];
cout << dfs(n - 1, m);
return 0;
}
当然，还可以进一步优化，采用动态优化，将递归变为for循环
状态转移方程：
a
n
s
[
n
]
[
m
]
=
∑
i
=
0
a
[
i
]
a
n
s
[
n
?
1
]
[
m
?
i
]
ans[n][m] = \sum_{i = 0}^{a[i]} ans[n - 1][m - i]
ans[n][m]=∑i=0a[i]?ans[n?1][m?i]
#include <iostream>
using namespace std;
const int max_n = 100;
const int max_m = 100;
const int mod_num = 1e6 + 7;
int flowers[max_n + 1] = { 0 };
int ans[max_n + 1][max_m + 1] = { 0 };
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> flowers[i];
ans[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= m; j++)
for (int z = j - flowers[i] > 0 ? j - flowers[i] : 0; z <= j; z++)
ans[i][j] = (ans[i][j] + ans[i - 1][z]) % mod_num;
cout << ans[n][m];
return 0;
}
然后可以用滚动数组对空间进行优化，利用%2的性质
#include <iostream>
using namespace std;
const int max_n = 100;
const int max_m = 100;
const int mod_num = 1e6 + 7;
int flowers[max_n + 1] = { 0 };
int ans[2][max_m + 1] = { 0 };
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> flowers[i];
ans[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= m; j++)
for (int z = j - flowers[i] > 0 ? j - flowers[i] : 0; z <= j; z++) {
if (z == j - flowers[i] || z == 0) {
ans[i % 2][j] = ans[(i - 1) % 2][z] % mod_num;
continue;
}
ans[i % 2][j] = (ans[i % 2][j] + ans[(i - 1) % 2][z]) % mod_num;
}
cout << ans[n % 2][m];
return 0;
}
逐渐发现这道题其实是背包emm
代码还可以继续优化，但是因为懒就不继续写了，感兴趣的可以去查一下
[NOIP2006 提高组] 金明的预算方案（C++，01背包）
题目描述
金明今天很开心，家里购置的新房就要领钥匙了，新房里有一间金明自己专用的很宽敞的房间。更让他高兴的是，妈妈昨天对他说：“你的房间需要购买哪些物品，怎么布置，你说了算，只要不超过
n
n
n 元钱就行”。今天一早，金明就开始做预算了，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：
| 主件 | 附件 |
|---|
| 电脑 | 打印机，扫描仪 | | 书柜 | 图书 | | 书桌 | 台灯，文具 | | 工作椅 | 无 |
如果要买归类为附件的物品，必须先买该附件所属的主件。每个主件可以有
0
0
0 个、
1
1
1 个或
2
2
2 个附件。每个附件对应一个主件，附件不再有从属于自己的附件。金明想买的东西很多，肯定会超过妈妈限定的
n
n
n 元。于是，他把每件物品规定了一个重要度，分为
5
5
5 等：用整数
1
～
5
1 \sim 5
1～5 表示，第
5
5
5 等最重要。他还从因特网上查到了每件物品的价格（都是
10
10
10 元的整数倍）。他希望在不超过
n
n
n 元的前提下，使每件物品的价格与重要度的乘积的总和最大。
设第
j
j
j 件物品的价格为
v
j
v_j
vj?，重要度为
w
j
w_j
wj?，共选中了
k
k
k 件物品，编号依次为
j
1
,
j
2
,
…
,
j
k
j_1,j_2,\dots,j_k
j1?,j2?,…,jk?，则所求的总和为：
v
j
1
×
w
j
1
+
v
j
2
×
w
j
2
+
?
+
v
j
k
×
w
j
k
v_{j_1} \times w_{j_1}+v_{j_2} \times w_{j_2}+ \dots +v_{j_k} \times w_{j_k}
vj1??×wj1??+vj2??×wj2??+?+vjk??×wjk??。
请你帮助金明设计一个满足要求的购物单。
输入格式
第一行有两个整数，分别表示总钱数
n
n
n 和希望购买的物品个数
m
m
m。
第
2
2
2 到第
(
m
+
1
)
(m + 1)
(m+1) 行，每行三个整数，第
(
i
+
1
)
(i + 1)
(i+1) 行的整数
v
i
v_i
vi?，
p
i
p_i
pi?，
q
i
q_i
qi? 分别表示第
i
i
i 件物品的价格、重要度以及它对应的的主件。如果
q
i
=
0
q_i=0
qi?=0，表示该物品本身是主件。
输出格式
输出一行一个整数表示答案。
样例 #1
样例输入 #1
1000 5
800 2 0
400 5 1
300 5 1
400 3 0
500 2 0
样例输出 #1
2200
提示
数据规模与约定
对于全部的测试点，保证
1
≤
n
≤
3.2
×
1
0
4
1 \leq n \leq 3.2 \times 10^4
1≤n≤3.2×104，
1
≤
m
≤
60
1 \leq m \leq 60
1≤m≤60，
0
≤
v
i
≤
1
0
4
0 \leq v_i \leq 10^4
0≤vi?≤104，
1
≤
p
i
≤
5
1 \leq p_i \leq 5
1≤pi?≤5，
0
≤
q
i
≤
m
0 \leq q_i \leq m
0≤qi?≤m，答案不超过
2
×
1
0
5
2 \times 10^5
2×105。
解题思路：
读完题后，第一印象认为这是一道01背包问题，不过多了一个标记数组来判断附件是否能够购买
#include <iostream>
using namespace std;
const int max_m = 60;
class item {
public:
int v;
int p;
int q;
friend istream& operator>>(istream& in_put, item& it);
};
item items[max_m + 1];
bool book[max_m + 1] = { false };
int dfs(int n, int m) {
if (n == 0 || m == 0) return 0;
if ((items[m].q == 0 || book[items[m].q]) && n >= items[m].v) {
int temp_1 = dfs(n, m - 1);
book[m] = true;
int temp_2 = dfs(n - items[m].v, m - 1) + items[m].p * items[m].v;
book[m] = false;
return temp_1 > temp_2 ? temp_1 : temp_2;
}
else
return dfs(n, m - 1);
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) cin >> items[i];
cout << dfs(n, m);
return 0;
}
istream& operator>>(istream& in_put, item& it) {
in_put >> it.v >> it.p >> it.q;
return in_put;
}
但是这个思路是有问题的，先不提是否超时，题中并没有说附件一定出现在主件后面
所以尝试换一种思路，前m件物品的最大值为（1~5）种情况中的最大值，五种情况如下
（1）只选择第m件
（2）选择第m件和m的第一个附件
（3）选择第m件和m的第二个附件
（4）选择第m件和m的两个附件
（5）不选择第m件
改进后的实现代码：
#include <iostream>
using namespace std;
const int max_m = 60;
class item {
public:
int v;
int p;
int q;
int q_1;
int q_2;
friend istream& operator>>(istream& in_put, item& it);
item() : q_1(0), q_2(0) { ; }
};
item items[max_m + 1];
int max_num(int num_1, int num_2, int num_3, int num_4, int num_5) {
int temp = num_1;
temp = num_2 > temp ? num_2 : temp;
temp = num_3 > temp ? num_3 : temp;
temp = num_4 > temp ? num_4 : temp;
temp = num_5 > temp ? num_5 : temp;
return temp;
}
int dfs(int n, int m) {
if (n == 0 || m == 0) return 0;
int temp_1 = 0, temp_2 = 0, temp_3 = 0, temp_4 = 0, temp_5 = 0;
if (items[m].q == 0 && items[m].v <= n) {
temp_1 = dfs(n - items[m].v, m - 1) + items[m].v * items[m].p;
if (items[items[m].q_1].v + items[m].v <= n)
temp_2 = dfs(n - items[items[m].q_1].v - items[m].v, m - 1) + items[m].v * items[m].p + items[items[m].q_1].v * items[items[m].q_1].p;
if (items[items[m].q_2].v + items[m].v <= n)
temp_3 = dfs(n - items[items[m].q_2].v - items[m].v, m - 1) + items[m].v * items[m].p + items[items[m].q_2].v * items[items[m].q_2].p;
if (items[items[m].q_1].v + items[items[m].q_2].v + items[m].v <= n)
temp_4 = dfs(n - items[items[m].q_1].v - items[items[m].q_2].v - items[m].v, m - 1) + items[m].v * items[m].p + items[items[m].q_1].v * items[items[m].q_1].p + items[items[m].q_2].v * items[items[m].q_2].p;
}
temp_5 = dfs(n, m - 1);
return max_num(temp_1, temp_2, temp_3, temp_4, temp_5);
}
int i;
int main() {
int n, m;
cin >> n >> m;
for (i = 1; i <= m; i++) cin >> items[i];
cout << dfs(n, m);
return 0;
}
istream& operator>>(istream& in_put, item& it) {
in_put >> it.v >> it.p >> it.q;
if (it.q != 0 && items[it.q].q_1 == 0)
items[it.q].q_1 = i;
else if (it.q != 0 && items[it.q].q_2 == 0)
items[it.q].q_2 = i;
return in_put;
}
以上代码虽然思路没错，但是会TLE，所以进行记忆
记忆策略：n和m相同时，ans相同
AC代码如下
#include <iostream>
using namespace std;
const int max_n = 3.2 * 1e4;
const int max_m = 60;
class item {
public:
int v;
int p;
int q;
int q_1;
int q_2;
friend istream& operator>>(istream& in_put, item& it);
item() : q_1(0), q_2(0) { ; }
};
item items[max_m + 1];
int ans[max_n + 1][max_m + 1] = { 0 };
int max_num(int num_1, int num_2, int num_3, int num_4, int num_5) {
int temp = num_1;
temp = num_2 > temp ? num_2 : temp;
temp = num_3 > temp ? num_3 : temp;
temp = num_4 > temp ? num_4 : temp;
temp = num_5 > temp ? num_5 : temp;
return temp;
}
int dfs(int n, int m) {
if (n == 0 || m == 0) return 0;
if (ans[n][m]) return ans[n][m];
int temp_1 = 0, temp_2 = 0, temp_3 = 0, temp_4 = 0, temp_5 = 0;
if (items[m].q == 0 && items[m].v <= n) {
temp_1 = dfs(n - items[m].v, m - 1) + items[m].v * items[m].p;
if (items[items[m].q_1].v + items[m].v <= n)
temp_2 = dfs(n - items[items[m].q_1].v - items[m].v, m - 1) + items[m].v * items[m].p + items[items[m].q_1].v * items[items[m].q_1].p;
if (items[items[m].q_2].v + items[m].v <= n)
temp_3 = dfs(n - items[items[m].q_2].v - items[m].v, m - 1) + items[m].v * items[m].p + items[items[m].q_2].v * items[items[m].q_2].p;
if (items[items[m].q_1].v + items[items[m].q_2].v + items[m].v <= n)
temp_4 = dfs(n - items[items[m].q_1].v - items[items[m].q_2].v - items[m].v, m - 1) + items[m].v * items[m].p + items[items[m].q_1].v * items[items[m].q_1].p + items[items[m].q_2].v * items[items[m].q_2].p;
}
temp_5 = dfs(n, m - 1);
ans[n][m] = max_num(temp_1, temp_2, temp_3, temp_4, temp_5);
return ans[n][m];
}
int i;
int main() {
int n, m;
cin >> n >> m;
for (i = 1; i <= m; i++) cin >> items[i];
cout << dfs(n, m);
return 0;
}
istream& operator>>(istream& in_put, item& it) {
in_put >> it.v >> it.p >> it.q;
if (it.q != 0 && items[it.q].q_1 == 0)
items[it.q].q_1 = i;
else if (it.q != 0 && items[it.q].q_2 == 0)
items[it.q].q_2 = i;
return in_put;
}
本题实际上是01背包的变形，所以当然还可以进一步将递归优化为双重for循环，这里不给出代码实现，可以自行尝试
|