算法刷题day50：背包模型

lijiachang030718

已于 2024-05-30 11:55:54 修改

阅读量385

点赞数 5

分类专栏： # 算法刷题文章标签：算法动态规划背包问题学习笔记程序人生经验分享

于 2024-05-21 14:30:22 首次发布

本文链接：https://blog.csdn.net/weixin_60033897/article/details/139067713

版权

算法刷题专栏收录该内容

61 篇文章 4 订阅

订阅专栏

引言

在动态规划中这个背包问题还是比较重要的，用法很多变换也很多，因为本质上就是一个从 $n$ 件物品里选 $m$ 件使得收益最大的问题，这是一个决策性问题，动态规划相当于对原先暴力枚举的方案进行了一个加速，所以仔细一想这种问题还是非常之多的。然后根据选法制定了一些规则，使得背包问题分为很多种，然后今天打算全部复习一遍，也是一项很大的工程啊，那就开始吧，当然还是以题目的方式进行讲解。

一、01背包问题

标签：背包问题、DP、模板题

思路：首先这个状态被压缩了， $f [j]$ 代表体积只有 $j$ 的情况下所能获得的最大收益。然后就是枚举每一件物品，这个物品要么放要么不放，如果不放其实就是上一个状态，值得注意的是，在状态压缩的情况下，只有01背包和多重背包的单调队列优化版本枚举体积需要从大到小枚举，这主要是根据化简之后的方程是 $f [i] [j] + w [i]$ ，而不是 $f [i - 1] [j] + w [i]$ ，至于怎么推的这里就不详解了。然后就是选的话就是 $f [j - v] + w$ ，又因为这里枚举的每一个物品只需用到一次并且没有任何的依赖关系，所以不用存下来直接用一次就“丢掉”即可，然后最后根据概念，输出最终的结果 $f [m]$ 。

题目描述：

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。

第 i 件物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。

接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤1000，0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
8

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1010, M = N, INF = 0x3f3f3f3f;

int n, m;
int f[N];

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n >> m;
	for(int i = 0; i < n; ++i)
	{
		int v, w; cin >> v >> w;
		for(int j = m; j >= v; --j)
		{
			f[j] = max(f[j], f[j-v]+w);
		}
	}
	
	cout << f[m] << endl;
	
	return 0;
}

二、完全背包问题

标签：背包问题、DP、模板题

思路：完全背包区别于 $01$ 背包就是每件物品可以选无数次，然后代码的变化也只是从循环体积变为了从小到大进行枚举，我知道它这个推导过程大概是怎么来的，所以这种东西直接背即可，然后其他的题在这个背的基础上应用即可。

题目描述：

有 N 种物品和一个容量是 V 的背包，每种物品都有无限件可用。

第 i 种物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。

接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 种物品的体积和价值。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤1000，0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
10

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1010, M = N, INF = 0x3f3f3f3f;

int n, m;
int f[N];

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n >> m;
	for(int i = 0; i < n; ++i)
	{
		int v, w; cin >> v >> w;
		for(int j = v; j <= m; ++j)
		{
			f[j] = max(f[j], f[j-v]+w);
		}
	}
	
	cout << f[m] << endl;
	
	return 0;
}

三、多重背包问题 II

标签：背包问题、DP、模板题

思路：其实就是把每个物品用二进制的方式划分为二次幂，这样每二次幂个物品就跟单独的物品一样，只会选一次，就把问题转换为 $01$ 背包问题。比如某个物品可以选 $7$ 次，其二进制表示为 $111$ ，即可以把它变为三个体积和价值为原来的 $4$ 倍、 $2$ 倍、 $1$ 倍的单独的物品，这样可以枚举到任何一种选择方案，并且也优化了时间，是 $l o g N$ 级别的，然后对这三个物品进行一次 $01$ 背包算法，就可以找到其最优解。本质上是把多重背包问题划分为 $01$ 背包问题。

题目描述：

有 N 种物品和一个容量是 V 的背包。

第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。

接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N≤1000，0<V≤2000，0<vi,wi,si≤2000
提示：
本题考查多重背包的二进制优化方法。

输入样例
4 5
1 2 3
2 4 1
3 4 3
4 5 2
输出样例：
10

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1010, M = 2010, INF = 0x3f3f3f3f;

int n, m;
int f[M];

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n >> m;
	for(int i = 0; i < n; ++i)
	{
		int v, w, s; cin >> v >> w >> s;
		for(int k = 1; k <= s; k *= 2)
		{
			for(int j = m; j >= k * v; --j)
			{
				f[j] = max(f[j], f[j-v*k]+w*k);
			}
			s -= k;
		}
		if(s > 0)
		{
			for(int j = m; j >= s * v; --j)
			{
				f[j] = max(f[j], f[j-s*v]+s*w);
			}
		}
	}
	
	cout << f[m] << endl;
	
	return 0;
}

四、分组背包问题

标签：背包问题、DP、模板题

思路：其实感觉还是一个 $01$ 背包问题，就是枚举的时候需要再在背包里面做一次 $01$ 背包，决策到底在这个背包里面选哪一件物品，就是在 $01$ 背包的基础上加了一个决策循环而已，至于为什么体积最小要到 $0$ ，因为在每一个背包中，每件物品的体积不知道是多大，需要在之后的 $i f$ 中去判断。

题目描述：

有 N 组物品和一个容量是 V 的背包。

每组物品有若干个，同一组内的物品最多只能选一个。每件物品的体积是 vij，价值是 wij，其中 i 是组号，j 是组内编号。

求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。

输出最大价值。

输入格式
第一行有两个整数 N，V，用空格隔开，分别表示物品组数和背包容量。

接下来有 N 组数据：

每组数据第一行有一个整数 Si，表示第 i 个物品组的物品数量；每组数据接下来有 Si 行，每行有两个整数 vij,wij，用空格隔开，分
别表示第 i 个物品组的第 j 个物品的体积和价值；

输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤100,0<Si≤100,0<vij,wij≤100
输入样例
3 5
2
1 2
2 4
1
3 4
1
4 5
输出样例：
8

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 110, M = N, INF = 0x3f3f3f3f;

int n, m;
int v[N][N], w[N][N], s[N];
int f[N];

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n >> m;
	for(int i = 0; i < n; ++i)
	{
		cin >> s[i];
		for(int j = 0; j < s[i]; ++j) cin >> v[i][j] >> w[i][j];
	}
	
	for(int i = 0; i < n; ++i)
	{
		for(int j = m; j >= 0; --j)
		{
			for(int k = 0; k < s[i]; ++k)
			{
				if(j >= v[i][k]) f[j] = max(f[j], f[j-v[i][k]]+w[i][k]);
			}
		}
	}
	
	cout << f[m] << endl;
	
	return 0;
}

五、采药

标签：DP、01背包问题

思路：其实就是一个简单版的 $01$ 背包的一个应用，何为应用就是加了个背景，让这个抽象的模板有一个具体的实例。然后就是对应到模板，数量就是草药的数量，时间就是体积，价值就是价值，然后套模板即可。

题目描述：

辰辰是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。

为此，他想拜附近最有威望的医师为师。

医师为了判断他的资质，给他出了一个难题。

医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有
它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药
的总价值最大。”

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

输入格式
输入文件的第一行有两个整数 T 和 M，用一个空格隔开，T 代表总共能够用来采药的时间，M 代表山洞里的草药的数目。

接下来的 M 行每行包括两个在 1 到 100 之间（包括 1 和 100）的整数，分别表示采摘某株草药的时间和这株草药的价值。

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

数据范围
1≤T≤1000,1≤M≤100
输入样例：
70 3
71 100
69 1
1 2
输出样例：
3

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1010, M = N, INF = 0x3f3f3f3f;

int n, m;
int f[N];

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> m >> n;
	for(int i = 0; i < n; ++i)
	{
		int v, w; cin >> v >> w;
		for(int j = m; j >= v; --j)
		{
			f[j] = max(f[j], f[j-v]+w);
		}
	}
	
	cout << f[m] << endl;
	
	return 0;
}

六、装箱问题

标签：DP、01背包问题

思路：这道题问的是使箱子的剩余空间最小，即箱子的空间最大，那么也就是把体积看作价值，然后就是 $01$ 背包的模板了。

题目描述：

有一个箱子容量为 V，同时有 n 个物品，每个物品有一个体积（正整数）。

要求 n 个物品中，任取若干个装入箱内，使箱子的剩余空间为最小。

输入格式
第一行是一个整数 V，表示箱子容量。

第二行是一个整数 n，表示物品数。

接下来 n 行，每行一个正整数（不超过10000），分别表示这 n 个物品的各自体积。

输出格式
一个整数，表示箱子剩余空间。

数据范围
0<V≤20000,0<n≤30
输入样例：
24
6
8
3
12
7
9
7
输出样例：
0

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 2e4+10, M = N, INF = 0x3f3f3f3f;

int n, m;
int f[N];

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> m >> n;
	for(int i = 0; i < n; ++i)
	{
		int v, w; cin >> v;
		w = v;
		for(int j = m; j >= v; --j)
		{
			f[j] = max(f[j], f[j-v]+w);	
		}
	}
	
	cout << m - f[m] << endl;
	
	return 0;
}

七、宠物小精灵之收服

标签：DP、01背包问题、阅读理解

思路：这道题首先是一个 $01$ 背包问题，然后这道题的限制有两个，其实就是两个体积而已，其实就是关于一个物品选或者不选，然后枚举每一种情况下（也就是体积）选或者不选，找出最大值即可。因为其中有一个体力不能为零，也就是说这个体积不能被使用完，那就枚举的时候不枚举即可。第二问求的是最有情况下的剩余体力最大，那么就是满足答案的情况下，需要的体积最少，用一个 $w hi l e$ 枚举就行了，然后剩余拿总值一减即可。

题目描述：

宠物小精灵是一部讲述小智和他的搭档皮卡丘一起冒险的故事。

一天，小智和皮卡丘来到了小精灵狩猎场，里面有很多珍贵的野生宠物小精灵。

小智也想收服其中的一些小精灵。

然而，野生的小精灵并不那么容易被收服。

对于每一个野生小精灵而言，小智可能需要使用很多个精灵球才能收服它，而在收服过程中，野生小精灵也会对皮卡丘造成一定
的伤害（从而减少皮卡丘的体力）。

当皮卡丘的体力小于等于0时，小智就必须结束狩猎（因为他需要给皮卡丘疗伤），而使得皮卡丘体力小于等于0的野生小精灵也
不会被小智收服。

当小智的精灵球用完时，狩猎也宣告结束。

我们假设小智遇到野生小精灵时有两个选择：收服它，或者离开它。

如果小智选择了收服，那么一定会扔出能够收服该小精灵的精灵球，而皮卡丘也一定会受到相应的伤害；如果选择离开它，那么
小智不会损失精灵球，皮卡丘也不会损失体力。

小智的目标有两个：主要目标是收服尽可能多的野生小精灵；如果可以收服的小精灵数量一样，小智希望皮卡丘受到的伤害越小
（剩余体力越大），因为他们还要继续冒险。

现在已知小智的精灵球数量和皮卡丘的初始体力，已知每一个小精灵需要的用于收服的精灵球数目和它在被收服过程中会对皮卡
丘造成的伤害数目。

请问，小智该如何选择收服哪些小精灵以达到他的目标呢？

输入格式
输入数据的第一行包含三个整数：N，M，K，分别代表小智的精灵球数量、皮卡丘初始的体力值、野生小精灵的数量。

之后的K行，每一行代表一个野生小精灵，包括两个整数：收服该小精灵需要的精灵球的数量，以及收服过程中对皮卡丘造成的伤害。

输出格式
输出为一行，包含两个整数：C，R，分别表示最多收服C个小精灵，以及收服C个小精灵时皮卡丘的剩余体力值最多为R。

数据范围
0<N≤1000,0<M≤500,0<K≤100
输入样例1：
10 100 5
7 10
2 40
2 50
1 20
4 20
输出样例1：
3 30
输入样例2：
10 100 5
8 110
12 10
20 10
5 200
1 110
输出样例2：
0 100

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1010, M = 510, INF = 0x3f3f3f3f;

int n, V1, V2;
int f[N][M];

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> V1 >> V2 >> n;
	for(int i = 0; i < n; ++i)
	{
		int v1, v2; cin >> v1 >> v2;
		for(int j = V1; j >= v1; --j)
		{
			for(int k = V2 - 1; k >= v2; --k)
			{
				f[j][k] = max(f[j][k], f[j-v1][k-v2]+1);
			}
		}
	}
	
	int res = f[V1][V2-1];
	int k = V2 - 1;
	while(k >= 0 && f[V1][k] == res) k--;
	k++;
	
	cout << res << " " << V2 - k << endl;
	
	return 0;
}

八、数字组合

标签：动态规划、01背包问题

思路：本质上是一个 $01$ 背包求方案数的问题，然后就是初始状态 $f [0] = 1$ ，因为什么都不选产生的和为 $1$ 是一种方案。然后就还是枚举每个物品，然后枚举体积，当前物品选或者不选产生的体积的方案数，是由当前物品选或者不选组成的，若不选那就是 $f [j]$ ，若选那就是 $f [j - v]$ 所产生的方案数，一加就是了，所以状态转移方程为 $f [j] = f [j] + f [j - v]$ ，最终答案就是 $f [m]$ ，其余的都是模板。

题目描述：

给定 N 个正整数 A1,A2,…,AN，从中选出若干个数，使它们的和为 M，求有多少种选择方案。

输入格式
第一行包含两个整数 N 和 M。

第二行包含 N 个整数，表示 A1,A2,…,AN。

输出格式
包含一个整数，表示可选方案数。

数据范围
1≤N≤100,1≤M≤10000,1≤Ai≤1000,答案保证在 int 范围内。

输入样例：
4 4
1 1 2 2
输出样例：
3

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1e4+10, M = N, INF = 0x3f3f3f3f;

int n, m;
int f[N];

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n >> m;
	
	f[0] = 1;
	for(int i = 0; i < n; ++i)
	{
		int v; cin >> v;
		for(int j = m; j >= v; --j)
		{
			f[j] += f[j-v]; 
		}
	}
	
	cout << f[m] << endl;
	
	return 0;
}

九、买书

标签：DP、完全背包问题、背包问题求方案数

思路：本质上是一个完全背包求方案数，思路跟上一题的一样，只不过 $01$ 背包变成了完全背包，在状态压缩的情况下，区别就是遍历体积的时候是由小到大遍历的，其余的都是一样的。我觉得在写完全背包的时候先把 $01$ 背包写出来，然后再变成完全背包就行了。

题目描述：

小明手里有n元钱全部用来买书，书的价格为10元，20元，50元，100元。

问小明有多少种买书方案？（每种书可购买多本）

输入格式
一个整数 n，代表总共钱数。

输出格式
一个整数，代表选择方案种数。

数据范围
0≤n≤1000
输入样例1：
20
输出样例1：
2
输入样例2：
15
输出样例2：
0
输入样例3：
0
输出样例3：
1

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1010, M = N, INF = 0x3f3f3f3f;

int n, m;
int v[4] = {10,20,50,100};
int f[N];

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	n = 4;
	cin >> m;
	
	f[0] = 1;
	for(int i = 0; i < n; ++i)
	{
		for(int j = v[i]; j <= m; ++j)
		{
			f[j] += f[j-v[i]]; 
		}
	}
	
	cout << f[m] << endl;
	
	return 0;
}

十、货币系统

标签：DP、背包问题求方案数

思路：还是一个完全背包求方案数问题，与上一题不一样的是，这道题的体积是通过输入给的，其实反而简单了，还是一次性的没有依赖，直接输入然后循环计算即可。

题目描述：

给你一个n种面值的货币系统，求组成面值为m的货币有多少种方案。

输入格式
第一行，包含两个整数n和m。

接下来n行，每行包含一个整数，表示一种货币的面值。

输出格式
共一行，包含一个整数，表示方案数。

数据范围
n≤15,m≤3000
输入样例：
3 10
1
2
5
输出样例：
10

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 20, M = 3010, INF = 0x3f3f3f3f;

int n, m;
LL f[M];

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n >> m;
	
	f[0] = 1;
	for(int i = 0; i < n; ++i)
	{
		int v; cin >> v;
		for(int j = v; j <= m; ++j)
		{
			f[j] += f[j-v]; 
		}
	}
	
	cout << f[m] << endl;
	
	return 0;
}

十一、货币系统

标签：DP、背包问题、数学、线性代数、贪心

思路：问的是与已知的货币系统等价且种类最少，其实问的就是在已知的货币系统中哪些货币能被其它货币表示出来，那其实就是完全背包求方案数了。然后因为大的货币肯定只能会被小的货币表示，所以枚举货币时先由小到大排序，然后看这个货币能否被之前的货币表示出来，也就是方案数是否不为 $0$ ，然后拿该货币及其之前的去枚举体积的方案数。

题目描述：

在网友的国度中共有 n 种不同面额的货币，第 i 种货币的面额为 a[i]，你可以假设每一种货币都有无穷多张。

为了方便，我们把货币种数为 n、面额数组为 a[1..n] 的货币系统记作 (n,a)。 

在一个完善的货币系统中，每一个非负整数的金额 x 都应该可以被表示出，即对每一个非负整数 x，都存在 n 个非负整数 
t[i] 满足 a[i]×t[i] 的和为 x。

然而，在网友的国度中，货币系统可能是不完善的，即可能存在金额 x 不能被该货币系统表示出。

例如在货币系统 n=3, a=[2,5,9] 中，金额 1,3 就无法被表示出来。 

两个货币系统 (n,a) 和 (m,b) 是等价的，当且仅当对于任意非负整数 x，它要么均可以被两个货币系统表出，要么不能被其中任
何一个表出。 

现在网友们打算简化一下货币系统。

他们希望找到一个货币系统 (m,b)，满足 (m,b) 与原来的货币系统 (n,a) 等价，且 m 尽可能的小。

他们希望你来协助完成这个艰巨的任务：找到最小的 m。

输入格式
输入文件的第一行包含一个整数 T，表示数据的组数。

接下来按照如下格式分别给出 T 组数据。 

每组数据的第一行包含一个正整数 n。

接下来一行包含 n 个由空格隔开的正整数 a[i]。

输出格式
输出文件共有 T 行，对于每组数据，输出一行一个正整数，表示所有与 (n,a) 等价的货币系统 (m,b) 中，最小的 m。

数据范围
1≤n≤100,1≤a[i]≤25000,1≤T≤20
输入样例：
2 
4 
3 19 10 6 
5 
11 29 13 19 17 
输出样例：
2
5

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 110, M = 3e4+10, INF = 0x3f3f3f3f;

int n, m;
int v[N], f[M];

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	int T; cin >> T;
	while(T--)
	{
		memset(f, 0, sizeof f);
		cin >> n;
		for(int i = 0; i < n; ++i) cin >> v[i];
		sort(v, v+n);
		
		f[0] = 1, m = v[n-1];
		int res = 0;
		for(int i = 0; i < n; ++i)
		{
			if(!f[v[i]]) res++;
			for(int j = v[i]; j <= m; ++j)
			{
				f[j] += f[j-v[i]];
			}
		}
		
		cout << res << endl;
	}
	
	return 0;
}

十二、庆功会

标签：DP、多重背包问题

思路：就是一个多重背包的一个简单应用问题，我其实只会写二进制优化版的，因为单调队列优化的看起来就难，又因为打蓝桥杯还是这种的就够了。另外为什么 $k$ 从 $1$ 开始枚举，因为本身不选就是 $f [i] [j]$ ，选是 $f [i] [j - v * k] + w * k$ ，本身状态压缩，取最值的地方就是不选的。

题目描述：

为了庆贺班级在校运动会上取得全校第一名成绩，班主任决定开一场庆功会，为此拨款购买奖品犒劳运动员。

期望拨款金额能购买最大价值的奖品，可以补充他们的精力和体力。

输入格式
第一行二个数n，m，其中n代表希望购买的奖品的种数，m表示拨款金额。

接下来n行，每行3个数，v、w、s，分别表示第I种奖品的价格、价值（价格与价值是不同的概念）和能购买的最大数量（买0件到
s件均可）。

输出格式
一行：一个数，表示此次购买能获得的最大的价值（注意！不是价格）。

数据范围
n≤500,m≤6000,v≤100,w≤1000,s≤10
输入样例：
5 1000
80 20 4
40 50 9
30 50 7
40 30 6
20 20 1
输出样例：
1040

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 6010, M = N, INF = 0x3f3f3f3f;

int n, m;
int f[N];

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n >> m;
	for(int i = 0; i < n; ++i)
	{
		int v, w, s; cin >> v >> w >> s;
		for(int k = 1; k <= s; k *= 2)
		{
			for(int j = m; j >= k * v; --j)
			{
				f[j] = max(f[j], f[j-v*k]+w*k);
			}
			s -= k;
		}
		if(s > 0)
		{
			for(int j = m; j >= s * v; --j)
			{
				f[j] = max(f[j], f[j-s*v]+s*w);
			}
		}
	}
	
	cout << f[m] << endl;
	
	return 0;
}

十三、混合背包问题

标签：背包问题、DP

思路：其实不同的背包问题就是枚举体积的那一层循环不一样，用一个判断隔开就行了，然后是什么背包就用哪种状态转移方程，就感觉很奇特。另外可以把 $01$ 背包看成特殊的完全背包，这样减少代码量。详情见代码。

题目描述：

有 N 种物品和一个容量是 V 的背包。

物品一共有三类：

第一类物品只能用1次（01背包）；
第二类物品可以用无限次（完全背包）；
第三类物品最多只能用 si 次（多重背包）；每种体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。

接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。

si=−1 表示第 i 种物品只能用1次；
si=0 表示第 i 种物品可以用无限次；
si>0 表示第 i 种物品可以使用 si 次；

输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤1000
0<vi,wi≤1000
−1≤si≤1000
输入样例
4 5
1 2 -1
2 4 1
3 4 0
4 5 2
输出样例：
8

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1010, M = N, INF = 0x3f3f3f3f;

int n, m;
int f[N];

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n >> m;
	for(int i = 0; i < n; ++i)
	{
		int v, w, s; cin >> v >> w >> s;
		if(!s)  // 完全背包 
		{
			for(int j = v; j <= m; ++j)
			{
				f[j] = max(f[j], f[j-v]+w);
			}
		}
		else  // 01背包看成多重背包 
		{
			if(s == -1) s = 1;
			for(int k = 1; k <= s; k *= 2)
			{
				for(int j = m; j >= k * v; --j)
				{
					f[j] = max(f[j], f[j-k*v]+k*w);
				}
				s -= k;
			}
			if(s > 0)
			{
				for(int j = m; j >= s * v; --j)
				{
					f[j] = max(f[j], f[j-s*v]+s*w);
				}
			}
		}
	}
	
	cout << f[m] << endl;
	
	return 0;
}

十四、二维费用的背包问题

标签：背包问题、DP、模板题

思路：这道题其实是宠物小精灵之收服这道题的模板题，因为练习网站上的顺序，所以我也按照这个顺序来的。其实就是多了一个限制，多了一层循环而已。

题目描述：

有 N 件物品和一个容量是 V 的背包，背包能承受的最大重量是 M。

每件物品只能用一次。体积是 vi，重量是 mi，价值是 wi。

求解将哪些物品装入背包，可使物品总体积不超过背包容量，总重量不超过背包可承受的最大重量，且价值总和最大。
输出最大价值。

输入格式
第一行三个整数，N,V,M，用空格隔开，分别表示物品件数、背包容积和背包可承受的最大重量。

接下来有 N 行，每行三个整数 vi,mi,wi，用空格隔开，分别表示第 i 件物品的体积、重量和价值。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N≤1000
0<V,M≤100
0<vi,mi≤100
0<wi≤1000
输入样例
4 5 6
1 2 3
2 4 4
3 4 5
4 5 6
输出样例：
8

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 110, M = N, INF = 0x3f3f3f3f;

int V1, V2, n;
int f[N][N];

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n >> V1 >> V2;
	for(int i = 0; i < n; ++i)
	{
		int v1, v2, w; cin >> v1 >> v2 >> w;
		for(int j = V1; j >= v1; --j)
		{
			for(int k = V2; k >= v2; --k)
			{
				f[j][k] = max(f[j][k], f[j-v1][k-v2]+w);
			}
		}
	}
	
	cout << f[V1][V2] << endl;
	
	return 0;
}

十五、潜水员

标签：DP、二维费用的背包问题

思路：首先这是一个二位费用的 $01$ 背包问题，然后不一样的是状态定义不一样了，这道题求的是在保证两个体积满足的情况下，最少的费用问题。所以我们的状态定义要改变为 $f [v 1] [v 2]$ 代表体积至少为 $v 1, v 2$ 的情况下的最少花费，因为定义变了，首先初始状态除了 $f [0] [0] = 0$ ，其余的都不合法（根据概念），然后因为是至少，所以 $f [- j] [- k]$ 也是存在的，只不过取 $f [0] [0]$ 罢了，所以状态枚举也要变为 $V\sim 0$ ，而不是 $V\sim v$ ，因为本身的限制也是为了防止取到负数而已，所以这个也得变，其余就是模板了，另外附上一张之前总结过的图。这里的第一维指的是物品数，为了方便理解，因为一半都写压缩空间版的。
在这里插入图片描述

题目描述：

潜水员为了潜水要使用特殊的装备。

他有一个带2种气体的气缸：一个为氧气，一个为氮气。

让潜水员下潜的深度需要各种数量的氧和氮。

潜水员有一定数量的气缸。

每个气缸都有重量和气体容量。

潜水员为了完成他的工作需要特定数量的氧和氮。

他完成工作所需气缸的总重的最低限度的是多少？

例如：潜水员有5个气缸。每行三个数字为：氧，氮的（升）量和气缸的重量：

3 36 120

10 25 129

5 50 250

1 45 130

4 20 119
如果潜水员需要5升的氧和60升的氮则总重最小为249（1，2或者4，5号气缸）。

你的任务就是计算潜水员为了完成他的工作需要的气缸的重量的最低值。

输入格式
第一行有2个整数 m，n。它们表示氧，氮各自需要的量。

第二行为整数 k 表示气缸的个数。

此后的 k 行，每行包括ai，bi，ci，3个整数。这些各自是：第 i 个气缸里的氧和氮的容量及气缸重量。

输出格式
仅一行包含一个整数，为潜水员完成工作所需的气缸的重量总和的最低值。

数据范围
1≤m≤21,1≤n≤79,1≤k≤1000,1≤ai≤21,1≤bi≤79,1≤ci≤800
输入样例：
5 60
5
3 36 120
10 25 129
5 50 250
1 45 130
4 20 119
输出样例：
249

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 22, M = 80, INF = 0x3f3f3f3f;

int V1, V2, n;
int f[N][M];

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> V1 >> V2 >> n;
	
	memset(f, 0x3f, sizeof f);
	f[0][0] = 0;
	
	for(int i = 0; i < n; ++i)
	{
		int v1, v2, w; cin >> v1 >> v2 >> w;
		for(int j = V1; j >= 0; --j)
		{
			for(int k = V2; k >= 0; --k)
			{
				f[j][k] = min(f[j][k], f[max(0,j-v1)][max(0,k-v2)]+w);
			}
		}
	}
	
	cout << f[V1][V2] << endl;
	
	return 0;
}

十六、机器分配

标签：DP、分组背包问题

思路：这道题其实是一个分组背包问题，可以看把每个公司的设备数与盈利数看作一个物品的体积和价值，求的就是在不超过总体积的情况下，每个公司最多只能选一个物品的方案数，这不就是分组背包问题嘛。然后这道题麻烦的是需要求出具体的方案，这就不能压缩维数了，因为求方案是通过答案倒推出是由哪一个状态转移过来的，所以得正常写，然后具体就见代码。

题目描述：

总公司拥有 M 台 相同 的高效设备，准备分给下属的 N 个分公司。

各分公司若获得这些设备，可以为国家提供一定的盈利。盈利与分配的设备数量有关。

问：如何分配这M台设备才能使国家得到的盈利最大？

求出最大盈利值。

分配原则：每个公司有权获得任意数目的设备，但总台数不超过设备数 M。

输入格式
第一行有两个数，第一个数是分公司数 N，第二个数是设备台数 M；

接下来是一个 N×M 的矩阵，矩阵中的第 i 行第 j 列的整数表示第 i 个公司分配 j 台机器时的盈利。

输出格式
第一行输出最大盈利值；

接下 N 行，每行有 2 个数，即分公司编号和该分公司获得设备台数。

答案不唯一，输出任意合法方案即可。

数据范围
1≤N≤10,1≤M≤15
输入样例：
3 3
30 40 50
20 30 50
20 25 30
输出样例：
70
1 1
2 1
3 1

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 11, M = 16, INF = 0x3f3f3f3f;

int n, m;
int w[N][M];
int f[N][M];
int way[N];

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n >> m;
	for(int i = 1; i <= n; ++i)
	{
		for(int j = 1; j <= m; ++j)
		{
			cin >> w[i][j];
		}
	}
	
	for(int i = 1; i <= n; ++i)
	{
		for(int j = 0; j <= m; ++j)
		{
			for(int k = 0; k <= j; ++k)
			{
				f[i][j] = max(f[i][j], f[i-1][j-k]+w[i][k]);
			}
		}
	}
	
	cout << f[n][m] << endl;
	
	int j = m;
	for(int i = n; i; --i)
	{
		for(int k = 0; k <= j; ++k)
		{
			if(f[i][j] == f[i-1][j-k] + w[i][k])
			{
				way[i] = k;
				j -= k;
				break;
			}
		}
	}
	
	for(int i = 1; i <= n; ++i) cout << i << " " << way[i] << endl;
	
	return 0;
}

十七、开心的金明

标签：DP、01背包问题

思路：其实就是价值变成了价值乘以重要度，然后其余的就是模板。

题目描述：

金明今天很开心，家里购置的新房就要领钥匙了，新房里有一间他自己专用的很宽敞的房间。

更让他高兴的是，妈妈昨天对他说：“你的房间需要购买哪些物品，怎么布置，你说了算，只要不超过 N 元钱就行”。

今天一早金明就开始做预算，但是他想买的东西太多了，肯定会超过妈妈限定的 N 元。

于是，他把每件物品规定了一个重要度，分为 5 等：用整数 1∼5 表示，第 5 等最重要。

他还从因特网上查到了每件物品的价格（都是整数元）。

他希望在不超过 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 表示总钱数，m 为希望购买物品的个数） 

从第 2 行到第 m+1 行，第 j 行给出了编号为 j−1 的物品的基本数据，每行有 2 个非负整数 v 和 p。（其中 v 表示该物品的价格，
p 表示该物品的重要度）

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

数据范围
1≤N<30000,1≤m<25,0≤v≤10000,1≤p≤5
输入样例：
1000 5
800 2
400 5
300 5
400 3
200 2
输出样例：
3900

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 26, M = 3e4+10, INF = 0x3f3f3f3f;

int n, m;
int f[M];

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> m >> n;
	for(int i = 0; i < n; ++i)
	{
		int v, p; cin >> v >> p;
		for(int j = m; j >= v; --j)
		{
			f[j] = max(f[j], f[j-v]+v*p);
		}
	}
	
	cout << f[m] << endl;
	
	return 0;
}

十八、有依赖的背包问题

标签：背包问题、DP

思路：首先定义状态 $f [i] [j]$ 代表以 $i$ 为根结点的这棵子树在体积不超过 $j$ 的情况下所拥有的最大价值。然后是用递归的思路去做，用子结点去推父节点，然后父结点去枚举子结点相当于遍历物品组，然后把体积当作分类去执行分组背包，然后再循环决策。该结点遍历完成之后，将该物品放入该结点中，不能放入的就置为零，相当于用子结点更新完父结点之后，因为子结点放了，父节点必须要放，当然在遍历的时候也是给父结点留好空间了。

题目描述：

有 N 个物品和一个容量是 V 的背包。

物品之间具有依赖关系，且依赖关系组成一棵树的形状。如果选择一个物品，则必须选择它的父节点。

如下图所示：

如果选择物品5，则必须选择物品1和2。这是因为2是5的父节点，1是2的父节点。

每件物品的编号是 i，体积是 vi，价值是 wi，依赖的父节点编号是 pi。物品的下标范围是 1…N。

求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。

输出最大价值。

输入格式
第一行有两个整数 N，V，用空格隔开，分别表示物品个数和背包容量。

接下来有 N 行数据，每行数据表示一个物品。
第 i 行有三个整数 vi,wi,pi，用空格隔开，分别表示物品的体积、价值和依赖的物品编号。
如果 pi=−1，表示根节点。 数据保证所有物品构成一棵树。

输出格式
输出一个整数，表示最大价值。

数据范围
1≤N,V≤100
1≤vi,wi≤100
父节点编号范围：
内部结点：1≤pi≤N;
根节点 pi=−1;
输入样例
5 7
2 3 -1
2 2 1
3 5 1
4 7 2
3 6 2
输出样例：
11

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 110, M = 110, INF = 0x3f3f3f3f;

int n, m;
int v[N], w[N];
int h[N], e[M], ne[M], idx;
int f[N][N];

void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

void dfs(int u)
{
	for(int i = h[u]; i != -1; i = ne[i])  // 枚举物品组 
	{
		int son = e[i];
		dfs(son);
		
		// 分组背包 把体积看成决策 
		for(int j = m - v[u]; j >= 0; --j)  // 枚举体积 
		{
			for(int k = 0; k <= j; ++k)  // 枚举决策 
			{
				f[u][j] = max(f[u][j], f[u][j-k]+f[son][k]);
			}
		}
	}
	
	for(int i = m; i >= v[u]; --i) f[u][i] = f[u][i-v[u]] + w[u];  // 把物品u放进去 
	for(int i = 0; i < v[u]; ++i) f[u][i] = 0;  // 根结点都选不了当然为0 
}

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n >> m;
	memset(h, -1, sizeof h);
	int root;
	for(int i = 1; i <= n; ++i)
	{
		int p; cin >> v[i] >> w[i] >> p;
		if(p == -1) root = i;
		else add(p,i);
	}
	
	dfs(root);
	
	cout << f[root][m] << endl;
	
	return 0;
}

十九、背包问题求方案数

标签：背包问题、DP

思路：其实就是另外开一个数组 $g [i]$ ，代表体积是 $i$ 的最优解所对应的方案数。然后在求最优解的过程中，只要判断 $f [j]$ 是从哪个状态转移过来的，然后累加就行了。最后判断是最优解的情况下所对应的方案数即可。

题目描述：

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。

第 i 件物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。

输出 最优选法的方案数。注意答案可能很大，请输出答案模 109+7 的结果。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。

接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。

输出格式
输出一个整数，表示 方案数 模 109+7 的结果。

数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 6
输出样例：
2

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1010, M = N, MOD = 1e9+7;

int n, m;
int f[N], g[N]; 

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n >> m;
	g[0] = 1;  // 代表体积为i的方案数 
	
	for(int i = 0; i < n; ++i)
	{
		int v, w; cin >> v >> w;
		for(int j = m; j >= v; --j)
		{
			int maxv = max(f[j], f[j-v]+w); 
			int s = 0;
			if(maxv == f[j]) s = g[j];
			if(maxv == f[j-v]+w) s = (s + g[j-v]) % MOD;
			g[j] = s;
			f[j] = maxv;
		}
	}
	
	int sum = 0;
	for(int i = 0; i <= m; ++i)
	{
		if(f[m] == f[i]) sum = (sum + g[i]) % MOD;
	}
	
	cout << sum << endl;
	
	return 0;
}

二十、背包问题求具体方案

标签：背包问题、DP、求方案

思路：这道题其实跟那个机器划分都是求具体的方案，主要的的思想还是先用朴素办法求出最优解，然后根据最优解和上一个状态的最优解判断该物品是否被选择了。因为需要输出字典序最小，并且最优解的方案不止一个，所以就从后往前选物品，然后从前往后判断该物品是否被选，这样就行了。另外跟机器划分不一样的是，本问题是 $01$ 背包，而它是分组背包，因为不知道哪一个物品要被选，所以还要枚举每个背包里的物品，所以就多了一层循环。

题目描述：

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。

第 i 件物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。

输出 字典序最小的方案。这里的字典序是指：所选物品的编号所构成的序列。物品的编号范围是 1…N。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。

接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。

输出格式
输出一行，包含若干个用空格隔开的整数，表示最优解中所选物品的编号序列，且该编号序列的字典序最小。

物品编号范围是 1…N。

数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 6
输出样例：
1 4

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1010, M = N, INF = 0x3f3f3f3f;

int n, m;
int v[N], w[N];
int f[N][N];

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n >> m;
	for(int i = 1; i <= n; ++i) cin >> v[i] >> w[i];
	
	for(int i = n; i >= 1; --i)  // 因为要求字典序最小的，直接从后向前选 
	{
		for(int j = 0; j <= m; ++j)  // 只要没有状态压缩，顺序无所谓 
		{
			f[i][j] = f[i+1][j];
			if(j >= v[i]) f[i][j] = max(f[i][j], f[i+1][j-v[i]]+w[i]);
		}
	}
	
	// f[1][m] 
	int j = m;
	for(int i = 1; i <= n; ++i)
	{
		if(j >= v[i] && f[i][j] == f[i+1][j-v[i]] + w[i])  // 说由上一个状态的最优解得，从最优解算了当前状态 
		{
			cout << i << " ";
			j -= v[i];
		}
	}
	
	return 0;
}

二十一、金明的预算方案

标签：DP、背包问题、分组背包

思路：这道题跟有依赖的背包问题很像，不过这道题的依赖关系只有两三个，但因为都是有依赖的问题，而且我觉得出题肯定会出分支很多的这种情况，如果少的话暴力做起来就很容易过，所以还是继续按照有依赖的背包问题的思路去做。建一棵树，然后用子结点更新父结点，在枚举体积的过程中，再进行体积进行划分，意思是用子结点的哪一种体积决策，然后更新，最后把当前结点加进去。

题目描述：

金明今天很开心，家里购置的新房就要领钥匙了，新房里有一间金明自己专用的很宽敞的房间。

更让他高兴的是，妈妈昨天对他说：“你的房间需要购买哪些物品，怎么布置，你说了算，只要不超过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表示总钱数，m为希望购买物品的个数。

从第2行到第m+1行，第j行给出了编号为j-1的物品的基本数据，每行有3个非负整数v p q，其中v表示该物品的价格，p表示该物
品的重要度（1~5），q表示该物品是主件还是附件。

如果q=0，表示该物品为主件，如果q>0，表示该物品为附件，q是所属主件的编号。

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

数据范围
N<32000,m<60,v<10000
输入样例：
1000 5
800 2 0
400 5 1
300 5 1
400 3 0
500 2 0
输出样例：
2200

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 65, M = 32010, INF = 0x3f3f3f3f;

int n, m;
int v[N], w[N];
int h[N], e[M], ne[M], idx;
int f[N][M];
int root;

void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

void dfs(int u)
{
	for(int i = h[u]; i != -1; i = ne[i])  // 枚举物品组 
	{
		int son = e[i];
		dfs(son);
		
		// 分组背包 把体积看成决策 
		for(int j = m - v[u]; j >= 0; --j)  // 枚举体积 
		{
			for(int k = 0; k <= j; ++k)  // 枚举决策 
			{
				f[u][j] = max(f[u][j], f[u][j-k]+f[son][k]);
			}
		}
	}
	
	for(int i = m; i >= v[u]; --i) f[u][i] = f[u][i-v[u]] + w[u];  // 把物品u放进去 
	for(int i = 0; i < v[u]; ++i) f[u][i] = 0;  // 根结点都选不了当然为0 
}

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	memset(h, -1, sizeof h);
	cin >> m >> n;
	for(int i = 1; i <= n; ++i)
	{
		int t1, t2, q; cin >> t1 >> t2 >> q;
		v[i] = t1, w[i] = t1 * t2;
		if(!q) add(0,i);
		else add(q,i);
	}
	
	dfs(root);
	
	cout << f[root][m] << endl;
	
	return 0;
}

lijiachang030718

关注

5
点赞
踩
9

收藏

觉得还不错? 一键收藏
打赏
0
评论
算法刷题day50：背包模型

在动态规划中这个背包问题还是比较重要的，用法很多变换也很多，因为本质上就是一个从 $n$ 件物品里选 $m$ 件使得收益最大的问题，这是一个决策性问题，动态规划相当于对原先暴力枚举的方案进行了一个加速，所以仔细一想这种问题还是非常之多的。然后根据选法制定了一些规则，使得背包问题分为很多种，然后今天打算全部复习一遍，也是一项很大的工程啊，那就开始吧，当然还是以题目的方式进行讲解。
复制链接

扫一扫