（Week 8）动态规划（C++，背包）

疯狂的采药（C++，完全背包）

题目背景

此题为纪念 LiYuxiang 而生。

题目描述

LiYuxiang 是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。为此，他想拜附近最有威望的医师为师。医师为了判断他的资质，给他出了一个难题。医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同种类的草药，采每一种都需要一些时间，每一种也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。”

如果你是 LiYuxiang，你能完成这个任务吗？

此题和原题的不同点：

$1$. 每种草药可以无限制地疯狂采摘。

$2$. 药的种类眼花缭乱，采药时间好长好长啊！师傅等得菊花都谢了！

输入格式

输入第一行有两个整数，分别代表总共能够用来采药的时间 $t$ 和代表山洞里的草药的数目 $m$。

第 $2$ 到第 $(m+1)$ 行，每行两个整数，第 $(i+1)$ 行的整数 $a_i,b_i$ 分别表示采摘第 $i$ 种草药的时间和该草药的价值。

输出格式

输出一行，这一行只包含一个整数，表示在规定的时间内，可以采到的草药的最大总价值。

样例 #1

样例输入 #1

70 3
71 100
69 1
1 2

样例输出 #1

140

提示

数据规模与约定

• 对于 $30\%$ 的数据，保证 $m\le 10^3$ 。
• 对于 $100\%$ 的数据，保证 $1\le m\le 10^4$，$1\le t\le 10^7$，且 $1\le m\times t\le 10^7$，$1\le a_i,b_i\le 10^4$。

解题思路：

在理解本题解题思路之前，建议先了解一下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$个物品，当$j\in [0,herbs[i])$时，有max_values[i][j] == max_values[i][j - 1]

所以可以合并

对于$j\in [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$ 棵樱花树，每棵都有美学值 $C_i(0\le C_i\le 200)$。爱与愁大神在每天上学前都会来赏花。爱与愁大神可是生物学霸，他懂得如何欣赏樱花：一种樱花树看一遍过，一种樱花树最多看 $A_i(0\le A_i\le 100)$ 遍，一种樱花树可以看无数遍。但是看每棵樱花树都有一定的时间 $T_i(0\le T_i\le 100)$。爱与愁大神离去上学的时间只剩下一小会儿了。求解看哪几棵樱花树能使美学值最高且爱与愁大神能准时（或提早）去上学。

输入格式

共 $n+1$行：

第 $1$ 行：现在时间 $T_s$（几时：几分），去上学的时间 $T_e$（几时：几分），爱与愁大神院子里有几棵樱花树 $n$。这里的 $T_s$，$T_e$ 格式为：hh:mm，其中 $0\le hh\le 23$，$0\le mm\le 59$，且 $hh,mm,n$ 均为正整数。

第 $2$ 行到第 $n+1$ 行，每行三个正整数：看完第 $i$ 棵树的耗费时间 $T_i$，第 $i$ 棵树的美学值 $C_i$，看第 $i$ 棵树的次数 $P_i$（$P_i=0$ 表示无数次，$P_i$ 是其他数字表示最多可看的次数 $P_i$）。

输出格式

只有一个整数，表示最大美学值。

样例 #1

样例输入 #1

6:50 7:00 3
2 1 0
3 3 1
4 5 4

样例输出 #1

11

提示

$100\%$ 数据：$T_e-T_s\le 1000$（即开始时间距离结束时间不超过 $1000$ 分钟），$n\le 10000$。保证 $T_e,T_s$ 为同一天内的时间。

样例解释：赏第一棵樱花树一次，赏第三棵樱花树 $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$ 盆。通过调查顾客的喜好，小明列出了顾客最喜欢的 $n$ 种花，从 $1$ 到 $n$ 标号。为了在门口展出更多种花，规定第 $i$ 种花不能超过 $a_i$ 盆，摆花时同一种花放在一起，且不同种类的花需按标号的从小到大的顺序依次摆列。

试编程计算，一共有多少种不同的摆花方案。

输入格式

第一行包含两个正整数 $n$ 和 $m$，中间用一个空格隔开。

第二行有 $n$ 个整数，每两个整数之间用一个空格隔开，依次表示 $a_1,a_2,\cdots ,a_n$。

输出格式

一个整数，表示有多少种方案。注意：因为方案数可能很多，请输出方案数对 $10^6+7$ 取模的结果。

样例 #1

样例输入 #1

2 4
3 2

样例输出 #1

2

提示

【数据范围】

对于 $20\%$ 数据，有 $0<n\le 8,0<m\le 8,0\le a_i\le 8$。

对于 $50\%$ 数据，有 $0<n\le 20,0<m\le 20,0\le a_i\le 20$。

对于 $100\%$ 数据，有 $0<n\le 100,0<m\le 100,0\le a_i\le 100$。

NOIP 2012 普及组 第三题

解题思路：

首先最容易想到的就是暴力搜索

void dfs(int n, int m) {//n为flowers的下标，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) {//n为flowers的下标，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;//n,m确定，ans唯一
	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循环

状态转移方程：

$ans[n][m]={\sum }_{i=0}^{a[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$ 元钱就行”。今天一早，金明就开始做预算了，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：

主件	附件
电脑	打印机，扫描仪
书柜	图书
书桌	台灯，文具
工作椅	无

如果要买归类为附件的物品，必须先买该附件所属的主件。每个主件可以有 $0$ 个、$1$ 个或 $2$ 个附件。每个附件对应一个主件，附件不再有从属于自己的附件。金明想买的东西很多，肯定会超过妈妈限定的 $n$ 元。于是，他把每件物品规定了一个重要度，分为 $5$ 等：用整数 $1\sim 5$ 表示，第 $5$ 等最重要。他还从因特网上查到了每件物品的价格（都是 $10$ 元的整数倍）。他希望在不超过 $n$ 元的前提下，使每件物品的价格与重要度的乘积的总和最大。

设第 $j$ 件物品的价格为 $v_j$，重要度为$w_j$，共选中了 $k$ 件物品，编号依次为 $j_1,j_2,\dots ,j_k$，则所求的总和为：

$v_{j_1}\times w_{j_1}+v_{j_2}\times w_{j_2}+\cdots +v_{j_k}\times w_{j_k}$。

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

输入格式

第一行有两个整数，分别表示总钱数 $n$ 和希望购买的物品个数 $m$。

第 $2$ 到第 $(m+1)$ 行，每行三个整数，第 $(i+1)$ 行的整数 $v_i$，$p_i$，$q_i$ 分别表示第 $i$ 件物品的价格、重要度以及它对应的的主件。如果 $q_i=0$，表示该物品本身是主件。

输出格式

输出一行一个整数表示答案。

样例 #1

样例输入 #1

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

样例输出 #1

2200

提示

数据规模与约定

对于全部的测试点，保证 $1\le n\le 3.2\times 10^4$，$1\le m\le 60$，$0\le v_i\le 10^4$，$1\le p_i\le 5$，$0\le q_i\le m$，答案不超过 $2\times 10^5$。

解题思路：

读完题后，第一印象认为这是一道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) {//n为当前剩余的钱，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>
//#include <fstream>//Debug
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) {//n为当前剩余的钱，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() {
	//ifstream ifs("C:\\Users\\dell\\Downloads\\P1064_4.in", ios::in);//Debug
	int n, m;
	cin >> n >> m;
	//ifs >> n >> m;//Debug
	for (i = 1; i <= m; i++) cin >> items[i];
	//ifs.close();//Debug

	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>
//#include <fstream>//Debug
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) {//n为当前剩余的钱，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() {
	//ifstream ifs("C:\\Users\\dell\\Downloads\\P1064_4.in", ios::in);//Debug
	int n, m;
	cin >> n >> m;
	//ifs >> n >> m;//Debug
	for (i = 1; i <= m; i++) cin >> items[i];
	//ifs.close();//Debug

	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循环，这里不给出代码实现，可以自行尝试