背包模型.

供自己学习，欢迎讨论。

---

采药

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

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

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

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

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

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

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

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

数据范围
1 ≤ T ≤ 1000,
1 ≤ M ≤ 100

输入样例：

70 3
71 100
69 1
1 2

输出样例：

3

采药总时间相当于背包容量，每一株药相当于一件物品，采药时间相当于该物品的体积，草药的价值相当于物品价值。

那么本题就可以看做是一个背包问题了

由于每株草药只有一个，也就是要么采，要么不采两种方案，所以该题是一个 01背包问题

状态表示f(i,j)—集合： 考虑前 i 个物品，且当前已使用体积不超过 j 的方案

状态表示f(i,j)—属性： 该方案的价值为最大值 max

初始状态：f[0][0]
目标状态：f[n][m]

时间复杂度

01背包问题的时间复杂度等于 物品数量 × 背包容量，因此本题的时间复杂度是 O(nm)。

#include <iostream>
#include <algorithm>
using namespace std;
typedef pair<int, int> PII;
const int N = 1010;
int t, m;
int v[N], w[N];
int f[N];
int main()
{
	cin >> t >> m;
	for (int i = 1; i <= m; i ++ ) cin >> v[i] >> w[i];
	for (int i = 1; i <= m; i ++ )
		for (int j = t; j >= v[i]; j -- )
			f[j] = max(f[j], f[j - v[i]] + w[i]);
	cout << f[t];
	return 0;
} 

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

int m, n;
int f[N];

int main()
{
    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;
}

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1010;
int n, m;
int v[N], w[N];
int f[N][N];
int main()
{
	cin >> n >> m;
	for (int i = 1; i <= n; i ++ ) cin >> v[i] >> w[i];
	for (int i = 1; i <= n; i ++ )
		for (int j = 1; j <= m; j ++ ) {
			if (j < v[i]) f[i][j] = f[i - 1][j];
			else f[i][j] = max(f[i - 1][j], f[i - 1][j - v[i]] + w[i]); 
		}
	cout << f[n][m];
	return 0;
}

---

装箱问题

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

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

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

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

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

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

数据范围
0 < V ≤ 20000,
0 < n ≤ 30

输入样例：

24
6
8
3
12
7
9
7

输出样例：

0

方法一：

完全类似于01背包问题，将物品体积同时看作物品价值求解。
f[i] 表示容量为 i 的背包最多能装多少价值的物品。

#include <iostream>
using namespace std;
const int N = 20010;
int n, m;
int f[N];
int main()
{
	cin >> n >> m;
	for (int i = 1; i <= m; i ++ ) {
		int v;
		cin >> v;
		for (int j = n; j >= v; j -- ) 
			f[j] = max(f[j], f[j - v] + v);
	} 
	cout << n - f[n];
	return 0;
}

方法二:

f[i]表示容量为i的背包能否被填满。
状态转移方程：f[i]=f[i] | f[i−v]

#include<bits/stdc++.h>
using namespace std;
const int N = 2e4+5;
int t,n;
bool f[N];
int main(){
    cin>>t>>n;
    f[0]=1;
    for(int i=1;i<=n;i++){
        int v;
        cin>>v;
        for(int j=t;j>=v;j--)
            f[j]=f[j]|f[j-v];
    }
    for(int i=t;i;i--){
        if(f[i]) {
            cout<<t-i<<endl;
            break;
        }
    }
    return 0;
}

笔记、代码学习：
作者：Tenshi
链接：https://www.acwing.com/solution/content/30335/
来源：AcWing

---

宠物小精灵之收服

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

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

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

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

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

当皮卡丘的体力小于等于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

二维费用01背包问题

花费1： 精灵球数量

花费2： 皮卡丘体力值

价值： 小精灵的数量(每只精灵价值为1)

状态表示： f[i,j,k]表示所有只考虑前i个物品，且花费1不超过j，花费2不超过k的选法的最大值

状态计算： f[i,j,k] = Max(f[i - 1,j,k],f[i - 1,j - v1[i],k - v2[i]] + 1)

最大收服的小精灵的数量f[K,N,M]
在收拾最大数量时，消耗的最少体力，从K - 1开始枚举到0，找出收服数量为f[k,N,M]的最小k值

注意： 题目说道：使得皮卡丘体力小于等于0的野生小精灵也不会被小智收服，因此皮卡丘的体力值需在V2 - 1时开始

#include <iostream>
using namespace std;
const int N = 1010, M = 510;
int V1, V2, n; // 球儿数 体力值 精灵数量 
int f[N][M]; // 球儿数是i 体力值是j 的最大精灵数量 
int main()
{
	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);
	}
	cout << f[V1][V2 - 1] << ' ';
	// 找到满足最大价值的所有状态里，第二维费用消耗最少的
	int k = V2 - 1;
	while (k > 0 && f[V1][k - 1] == f[V1][V2 - 1]) k -- ;
	cout << V2 - k;
	return 0;
}

---

数字组合

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

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

第二行包含 N 个整数，表示 A₁,A₂,…,A_N。

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

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

输入样例：

4 4
1 1 2 2

输出样例：

3

算法
(DP,01背包问题) O(nm)
可以转化为01背包问题求方案数：

• 将总和 M 看作背包容量；
• 将每个数 A_i 看作体积为 A_i 的物品；

时间复杂度
背包问题的时间复杂度是 O(nm)。

#include <iostream>
using namespace std;
const int N = 10010;
int n, m; 
int f[N];
int main()
{
	cin >> n >> m;
	f[0] = 1;
	for (int i = 1; i <= n; i ++ ) {
		int v;
		cin >> v;
		for (int j = m; j >= v; j -- ) 
			f[j] += f[j - v];
	}
	cout << f[m];
	return 0;
}

---

买书

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

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

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

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

数据范围
0 ≤ n ≤ 1000

输入样例1：

20

输出样例1：

2

输入样例2：

15

输出样例2：

0

输入样例3：

0

输出样例3：

1

闫氏DP分析法

初始状态：f[0][0]

目标状态：f[n][m]

// 朴素做法
#include <iostream>
using namespace std;
const int N = 1010;
int v[5] = {0, 10, 20, 50, 100};
int f[5][N];
int main()
{
	int n;
	cin >> n;
	f[0][0] = 1;
	for (int i = 1; i <= 4; i ++ ) 
		for (int j = 0; j <= n; j ++ ) {
			f[i][j] = f[i - 1][j];
			if (j >= v[i])
				f[i][j] += f[i][j - v[i]];
		}
	cout << f[4][n];
	return 0;
}

// 优化版本：一维
#include <iostream>
using namespace std;
const int N = 1010;
int v[5] = {0, 10, 20, 50, 100};
int f[N];
int main()
{
	int n;
	cin >> n;
	f[0] = 1;
	for (int i = 1; i <= 4; i ++ ) 
		for (int j = 0; j <= n; j ++ ) {
			if (j >= v[i])
				f[j] += f[j - v[i]];
		}
	cout << f[n];
	return 0;
}

---

1021.货币系统

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

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

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

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

数据范围
n ≤ 15, m ≤ 3000

输入样例：

3 10
1
2
5

输出样例：

10

闫氏DP分析法

初始状态：f[0][0]

目标状态：f[n][m]

注意本题方案数会爆 int ，需要开 long long 来存状态

关于 空间/时间优化 ，可以参考这篇 AcWing 1023. 买书【完全背包求解方案数+朴素优化】

//  朴素二维版
#include <iostream>
using namespace std;
const int N = 25, M = 3010;
int n, m;
int a[N];
long long f[N][M];
int main()
{
	cin >> n >> m;
	f[0][0] = 1;
	for (int i = 1; i <= n; i ++ ) {
		cin >> a[i];
		for (int j = 0; j <= m; j ++ ) {
			f[i][j] = f[i - 1][j];
			if (j >= a[i])
				f[i][j] += f[i][j - a[i]];
		}	
	}
	cout << f[n][m];
	return 0;
}

// 优化一维版
#include <iostream>
using namespace std;
typedef long long LL;
const int M = 3010;
int n, m;
LL f[M];
int main()
{
    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;
}

---

532. 货币系统

在网友的国度中共有 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

定义一个 货币系统 (n,a)：一共有 n 种货币，每种货币对应面值为 a_i
每种货币可以使用 任意多个，进行线性组合：

k=x₁a₁+x₂a₂+⋯+x_na_n，其中x_i∈Z0 i=1,2,⋯

k 为该 货币系统 (n,a) 能够 线性表出 的数值

【注】本题的 线性表出 对于 系数的要求 和 线性代数 中的 线性表出 是不一样的
本题的系数必须是 非负整数

分析
n 种货币，每种货币可以使用 无穷多个

通过这些信息，我们可以初步识别该题目是一个 完全背包 的变种题目

接着我们需要挖掘一下题目里的性质：

学过 线性代数 的同学可以无视这一部分，跳到下面的分割线继续看

研究 货币系统 (n,a) ，如果存在 a_j 可以被 a 中其他的向量 线性表出：

a_j = ∑_i≠j c_i a_i

则 a_j 在这个货币系统中是 无效的 (所有线性表示中需要用到a_j的项，都可以用 ∑_i≠j c_i a_i 代替)

因此，我们需要求出 货币系统 (n,a)(n,a) 的 最大无关向量组，即任意 aiai 都不能被其他向量 线性表出

如何求向量组 (a1,a2,⋯,an) 的 最大无关向量组
我们可以利用到 数论 中 埃式筛法 的思想：

对于一个 无效的 元素 ai，他只会被 小于 他的元素的 线性组合 表出，满足该要求的 ai 就要被 筛掉

所以我们要先 排序

而我们在做 完全背包 的时候，需要求出所有恰好能被前 i 个物品选出的体积的方案

即就是在 完全背包 求方案数的过程中，统计那些 初始不能被满足 的物品体积 个数

这就是我们在 AcWing 1021. 货币系统 中所使用的 DP模型

那一题我们求解的是方案数，这题稍微改一下，改成这种方案能否被满足即可，具体如下

闫氏DP分析法

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 110, M = 25010;
int t, n;
int a[N];
bool f[M];
int main()
{
	cin >> t;
	while (t -- ) {
		cin >> n;
		for (int i = 0; i < n; i ++ ) cin >> a[i];
		sort(a, a + n);
		memset(f, 0, sizeof f);
		f[0] = true;
		int res = 0;
		for (int i = 0; i < n; i ++ ) { 
			if (!f[a[i]]) res ++ ;
			for (int j = a[i]; j <= a[n - 1]; j ++ ) 
				// 对于 & | 还不是很理解
				f[j] |= f[j - a[i]];
		}
		cout << res << endl;
	} 
	return 0;
}

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 110, M = 25010;
int t, n;
int a[N];
int f[M];
int main()
{
	cin >> t;
	while (t -- ) {
		cin >> n;
		for (int i = 0; i < n; i ++ ) cin >> a[i];
		sort(a, a + n);
		memset(f, 0, sizeof f);
		f[0] = 1;
		int res = 0;
		for (int i = 0; i < n; i ++ ) { 
			if (!f[a[i]]) res ++ ;
			for (int j = a[i]; j <= a[n - 1]; j ++ ) 
				f[j] += f[j - a[i]];
		}
		cout << res << endl;
	} 
	return 0;
}

---

多重背包问题 III

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

第 i 种物品最多有 s_i 件，每件体积是 v_i，价值是 w_i。

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

输入格式
第一行两个整数，N，V (0 < N ≤ 1000, 0 < V ≤ 20000)，用空格隔开，分别表示物品种数和背包容积。

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

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

数据范围
0 < N ≤ 1000
0 < V ≤ 20000
0 < v_i,w_i,s_i ≤ 20000

提示
本题考查多重背包的单调队列优化方法。

输入样例

4 5
1 2 3
2 4 1
3 4 3
4 5 2

输出样例：

10

没懂

(单调队列优化) O(NV)

一共 n 类物品，背包的容量是 m

每类物品的体积为v, 价值为w，个数为s

我们先来回顾一下传统的dp方程

dp[i][j] 表示将前 i 种物品放入容量为 j 的背包中所得到的最大价值
dp[i][j] = max(不放入物品 i，放入1个物品 i，放入2个物品 i, ... , 放入k个物品 i)
这里 k 要满足：k <= s, j - k*v >= 0

不放物品  i = dp[i-1][j]
放k个物品 i = dp[i-1][j - k*v] + k*w

dp[i][j] = max(dp[i-1][j], dp[i-1][j-v] + w, dp[i-1][j-2*v] + 2*w,..., dp[i-1][j-k*v] + k*w)

实际上我们并不需要二维的dp数组，适当的调整循环条件，我们可以重复利用dp数组来保存上一轮的信息

我们令 dp[j] 表示容量为j的情况下，获得的最大价值
那么，针对每一类物品 i ，我们都更新一下 dp[m] --> dp[0] 的值，最后 dp[m] 就是一个全局最优值

dp[m] = max(dp[m], dp[m-v] + w, dp[m-2*v] + 2*w, dp[m-3*v] + 3*w, ...)

接下来，我们把 dp[0] --> dp[m] 写成下面这种形式
dp[0], dp[v],   dp[2*v],   dp[3*v],   ... , dp[k*v]
dp[1], dp[v+1], dp[2*v+1], dp[3*v+1], ... , dp[k*v+1]
dp[2], dp[v+2], dp[2*v+2], dp[3*v+2], ... , dp[k*v+2]
...
dp[j], dp[v+j], dp[2*v+j], dp[3*v+j], ... , dp[k*v+j]

显而易见，m 一定等于 k*v + j，其中  0 <= j < v
所以，我们可以把 dp 数组分成 j 个类，每一类中的值，都是在同类之间转换得到的
也就是说，dp[k*v+j] 只依赖于 { dp[j], dp[v+j], dp[2*v+j], dp[3*v+j], ... , dp[k*v+j] }

因为我们需要的是{ dp[j], dp[v+j], dp[2*v+j], dp[3*v+j], ... , dp[k*v+j] } 中的最大值，
可以通过维护一个单调队列来得到结果。这样的话，问题就变成了 j 个单调队列的问题

所以，我们可以得到
dp[j]    =     dp[j]
dp[j+v]  = max(dp[j] +  w,  dp[j+v])
dp[j+2v] = max(dp[j] + 2w,  dp[j+v] +  w, dp[j+2v])
dp[j+3v] = max(dp[j] + 3w,  dp[j+v] + 2w, dp[j+2v] + w, dp[j+3v])
...
但是，这个队列中前面的数，每次都会增加一个 w ，所以我们需要做一些转换

dp[j]    =     dp[j]
dp[j+v]  = max(dp[j], dp[j+v] - w) + w
dp[j+2v] = max(dp[j], dp[j+v] - w, dp[j+2v] - 2w) + 2w
dp[j+3v] = max(dp[j], dp[j+v] - w, dp[j+2v] - 2w, dp[j+3v] - 3w) + 3w
...
这样，每次入队的值是 dp[j+k*v] - k*w

单调队列问题，最重要的两点
1）维护队列元素的个数，如果不能继续入队，弹出队头元素
2）维护队列的单调性，即：尾值 >= dp[j + k*v] - k*w

本题中，队列中元素的个数应该为 s+1 个，即 0 -- s 个物品 i

#include <iostream>
#include <cstring>
using namespace std;
const int N = 20010; 
int n, m;
int dp[N], pre[N], q[N];
int main()
{
	cin >> n >> m;
	for (int i = 0; i < n; i ++ ) {
		memcpy(pre, dp, sizeof(dp));
		int v, w, s;
		cin >> v >> w >> s;
		for (int j = 0; j < v; j ++ ) {
			int head = 0, tail = -1;
			for (int k = j; k <= m; k += v) {
				if (head <= tail && k - s * v > q[head]) ++ head;
				while (head <= tail && pre[q[tail]] - (q[tail] - j) / v * w <= pre[k] - (k - j) / v * w) 
					-- tail;
				if (head <= tail)
					dp[k] = max(dp[k], pre[q[head]] + (k - q[head]) / v * w);
				q[++ tail] = k;
			}
		}
	}
	cout << dp[m];
	return 0;
}

优质题解 1
优质题解 2
优质题解 3
Y总代码

笔记、代码学习：
作者：lys
链接：https://www.acwing.com/solution/content/6500/
来源：AcWing

---

庆功会

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

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

输入格式
第一行二个数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

分析

物品个数为 n，总体积为m，初步识别是一个 背包问题

观察到每个物品有 数量限制，断定该题是 多重背包问题

本题是一道 多重背包 的裸题

多重背包问题三种解法：
朴素版 / 优化版 / 单调队列版本题解
单调队列就是 多重背包问题|||

闫氏DP分析法
初始状态：f[0][0]
目标状态：f[n][m]

朴素版

// 朴素版
// 时间复杂度：O(n×m×s)
// 空间复杂度：O(n×m)
#include <iostream>
using namespace std;
const int N = 510, M = 6010;
int n, m;
int v[N], w[N], s[N];
int f[N][M];
int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; ++ i) cin >> v[i] >> w[i] >> s[i];
    for (int i = 1; i <= n; ++ i)
    {
        for (int j = 0; j <= m; ++ j)
        {
            for (int k = 0; k <= s[i]; ++ k)
            {
                if (j - k * v[i] >= 0)
                {
                    f[i][j] = max(f[i][j], f[i - 1][j - k * v[i]] + k * w[i]);
                }
            }
        }
    }
    cout << f[n][m] << endl;
    return 0;
}

朴素优化

同 01背包 ，对于第 i 阶段的状态更新只会用到第 i-1 阶段的状态

因此可以采用 滚动数组 或者根据状态更新的顺序，直接压缩成 一维 的优化方式

时间复杂度：O(n×m×s)
空间复杂度：O(m)

#include <iostream>
using namespace std;
const int N = 6010;
int n, m;
int f[N];
int main()
{
	cin >> n >> m;
	for (int i = 0; i < n; i ++ ) {
		int v, w, s;
		cin >> v >> w >> s;
		for (int j = m; j >= 0; j -- ) 
			for (int k = 0; k <= s && k * v <= j; k ++ )
				f[j] = max(f[j], f[j - k * v] + k * w);
	}
	cout << f[m];	
	return 0;
}

---

混合背包问题

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

物品一共有三类：

• 第一类物品只能用1次（01背包）；
• 第二类物品可以用无限次（完全背包）；
• 第三类物品最多只能用 s_i 次（多重背包）；

每种体积是 v_i，价值是 w_i。

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

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

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

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

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

数据范围
0 < N,V ≤ 1000
0 < v_i,w_i ≤ 1000
−1 ≤ s_i ≤ 1000

输入样例

4 5
1 2 -1
2 4 1
3 4 0
4 5 2

输出样例：

8

该题就是一道 混合背包 的裸题

结合每个 物品 的属性，分别做不同的 状态转移 即可

可以结合 01背包、完全背包、多重背包 配套使用

此处的多重背包还要采用 二进制优化 变成多个 01背包 来做，不然会卡 TLE

#include <iostream>
using namespace std;
const int N = 1010;
int n, m;
int f[N];
int main()
{
	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 {
			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) {
				for (int j = m; j >= s * v; j -- ) 
					f[j] = max(f[j], f[j - s * v] + s * w);
			}
		}
	}
	cout << f[m];
	return 0;
} 

---

二维费用的背包问题

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

每件物品只能用一次。体积是 v_i，重量是 m_i，价值是 w_i。

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

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

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

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

数据范围
0 < N ≤ 1000
0 < V,M ≤ 100
0 < v_i,m_i ≤ 100
0 < w_i ≤ 1000

输入样例

4 5 6
1 2 3
2 4 4
3 4 5
4 5 6

输出样例：

8

每件物品只能 用一次 因此是个 01背包模型

费用一共有两个，一个是 体积，一个是 重量，因此是个 01背包二维费用问题

本题是一道裸题，直接上 闫氏DP分析法
初始状态：f[0][0][0]

目标状态：f[n][V][M]

#include <iostream>
using namespace std;
const int N = 1010;
int n, v, m;
int f[N][N]; // 体积是i 质量是j 的最大价值 
int main()
{
	cin >> n >> v >> m;
	for (int i = 1 ; i <= n; i ++ ) {
		int a, b, c; // 体积 质量 价值 
		cin >> a >> b >> c;
		for (int j = v; j >= a; j -- ) 
			for (int k = m; k >= b; k -- ) 
				f[j][k] = max(f[j][k], f[j - a][k - b] + c);
	}
	cout << f[v][m];
	return 0;
} 

潜水员

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

他有一个带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 行，每行包括a_i，b_i，c_i，3个整数。这些各自是：第 i 个气缸里的氧和氮的容量及气缸重量。

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

数据范围
1 ≤ m ≤ 21,
1 ≤ n ≤ 79,
1 ≤ k ≤ 1000,
1 ≤ a_i ≤21,
1 ≤ b_i ≤79,
1 ≤ c_i ≤800

输入样例：

5 60
5
3 36 120
10 25 129
5 50 250
1 45 130
4 20 119

输出样例：

249

算法分析

• 状态表示f[i,j,k]:所有从前i个物品中选,且氧气含量至少是j,氮气含量至少是k的所有选法的气缸重量总和的最小值

• 状态计算：

  • 所有不包含物品i的所有选法：f[i - 1,j,k]

  • 所有包含物品i的所有选法：f[i - 1,j - v1,k - v2]

注意：即使所需要的氧气或者氮气所需的是数量是负数，但其所需数量与0是等价的，因此可以通过所需数量为0来转移

扩展
可能很多人会有这样的疑问，二维费用的背包问题的状态转移方程代码如下

for(int j =  V;j >= v;j --)
    for(int k = M;k >= m;k --)
        f[j][k] = max(f[j][k], f[j - v][k - m] + w);

而本题的状态转移方程代码如下

for(int j = V;j >= 0;j --)
    for(int k = M;k >= 0;k --)
        f[j][k] = min(f[j][k], f[max(0, j - v)][max(0, k - m)] + w);

为什么上面的代码 j只需要遍历到v，k只能遍历到m。而下面的代码 j还需要遍历到0，k还需要遍历到0 ？同时为什么氧气或者氮气所需的是数量是负数时，可以与数量0的状态等价？

解答：对比两题的思路，二维费用的背包问题，求的是不能超过体积V，重量M的情况下，能拿到价值的最大值。而本题是至少需要体积V，重量M的情况下，能拿到价值的最小值。就拿体积来说，至少需要多少体积，也就是说有体积比需要的体积大的物品还是能用得到，例如f[3][5]，至少需要3个体积，5个重量，求能拿到价值的最小值，现在只有一个物品，体积是4，重量是4，价值w，它说至少需要3个体积，那么体积是4还是可以用到，只是多了1个体积没用占着而已，不影响其价值。因此若用了这个物品，则变成了求f[0][1] + w，表示体积已经不再需求了，只需要0个体积即可

求最大值最小值初始化总结
二维情况

1. 体积至多j，f[i,k] = 0，0 <= i <= n, 0 <= k <= m（只会求价值的最大值）
2. 体积恰好j，
   当求价值的最小值：f[0][0] = 0, 其余是INF
   当求价值的最大值：f[0][0] = 0, 其余是-INF
3. 体积至少j，f[0][0] = 0，其余是INF（只会求价值的最小值）

一维情况

1. 体积至多j，f[i] = 0, 0 <= i <= m（只会求价值的最大值）
2. 体积恰好j，
   当求价值的最小值：f[0] = 0, 其余是INF
   当求价值的最大值：f[0] = 0, 其余是-INF
3. 体积至少j，f[0] = 0，其余是INF（只会求价值的最小值）

具体参考这篇分享 背包问题中 体积至多是 j ，恰好是 j ，至少是 j 的初始化问题的研究

时间复杂度 O(nmk)

#include <iostream>
#include <cstring>
using namespace std;
const int N = 22, M = 80;
int n, m, k; // 氧 氮 重量 
int f[N][M]; // 前i个物品，氧气至少是j，氮气至少是k 的最小质量 
int main()
{
	cin >> n >> m >> k;
	memset(f, 0x3f, sizeof f);
	f[0][0] = 0;
	while(k -- ) {
		int a, b, c; // 氧 氮 重量 
		cin >> a >> b >> c;
		for (int i = n; i >= 0; i -- ) 
			for (int j = m; j >= 0; j -- ) 
				f[i][j] = min(f[i][j], f[max(0, i - a)][max(0, j - b)] + c);
	}
	cout << f[n][m];
	return 0;
} 

笔记学习：
作者：小呆呆
链接：https://www.acwing.com/solution/content/7438/
来源：AcWing

---

机器分配

总公司拥有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

分析

本题乍一看很像是 背包DP，为了转换成 背包DP 问题，我们需要对里面的一些叙述做出 等价变换

每家公司 我们可以看一个 物品组，又因为 每家公司 最终能够被分配的 机器数量 是固定的

因此对于分给第 i 个 公司 的不同 机器数量 可以分别看作是一个 物品组 内的 物品

该 物品 k 的含义：分给第 i 个 公司 k 台机器
该 物品 k 的体积：k
该 物品 k 的价值：w_ik

于是，本题就转换成了一个 分组背包问题

直接上 分组背包 的 闫氏DP分析法

分组背包问题解题思路
三重循环

1. 物品种类
2. 枚举背包体积
3. 决策数：当前种类物品的数量

动态规划求状态转移路径

这里我介绍一个从 图论 角度思考的方法

动态规划 本质是在一个 拓扑图 内找最短路

我们可以把每个 状态f[i][j]看作一个 点，状态的转移 看作一条 边，把 状态的值 理解为 最短路径长

具体如下图所示：

对于 点 f[i][j] 来说，他的 最短路径长 是通过所有到他的 边 更新出来的

更新 最短路 的 规则 因题而已，本题的 更新规则 是 f(i,j)=maxf(i−1,j−vi)+wif(i,j)=maxf(i−1,j−vi)+wi
最终，我们会把从 初始状态（起点）到 目标状态 （终点）的 最短路径长 更新出来

随着这个更新的过程，也就在整个 图 中生成了一颗 最短路径树

该 最短路径树 上 起点 到 终点 的 路径 就是我们要求的 动态规划的状态转移路径

如下图所示：
那么 动态规划求状态转移路径 就变成了在 拓扑图 中找 最短路径 的问题了

可以直接沿用 最短路 输出路径的方法就可以找出 状态的转移

多思考，多做类型题，温故知新

对于需要输出合法方案的具体情况，如每个物品选择情况时，这种问题需要搞懂存储状态的数组的意义，数组存储的是完整的过程，需要将它们一一找出。

#include <iostream>
using namespace std;
const int N = 20;
int n, m;
int w[N][N];
int f[N][N]; // 前i个物品选择j个数量的最大盈利 
int way[N];
int main()
{
	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 ++ ) {
			f[i][j] = f[i - 1][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;
	// 回溯过程，找到最优解的路线
	// 理解二维数组f存储数据的意义为存储了整个过程 
	// f[n][m]==f[i-1][j-k]+w[i][k] 全部的最优解等于前n-1物品的最优解+当前第n个物品的最优解 
	// 当找到第n个物品最优解，在全部中删除它，
	// 并将最大数量j减去第n个物品的数量，得到前n-1个物品的最大物品数量 
	// 重复步骤，循环之前n-1个物品的数据，直至全部得出。 
	int j = m;
	for (int i = n; i >= 1; 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;
}

---

开心的金明

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

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

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

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

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

他希望在不超过 N 元（可以等于 N 元）的前提下，使每件物品的价格与重要度的乘积的总和最大。

设第 j 件物品的价格为 v[j]，重要度为 w[j]，共选中了 k 件物品，编号依次为 j₁，j₂，…，j_k，则所求的总和为：

v[j₁]×w[j₁]+v[j₂]×w[j₂]+…+v[j_k]×w[j_k]
请你帮助金明设计一个满足要求的购物单。

输入格式
输入文件的第 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

算法

(DP,背包问题) O(nm)
将原问题做如下转化

• 总钱数相当于背包总容量；
• 每件物品的价格相当于体积；
• 每件物品的价格乘以重要度相当于价值；

那么就变成了经典的01背包问题。

时间复杂度

01背包问题的时间复杂度是 O(nm)，其中 n 是物品个数，m 是背包容量。

状态计算：

f[i][j] 表示所有从前i个物品选，且总体积不超过j的选法集合中的价值最大值

那么f[n][m]就表示从前n种物品中选，且总体积不超过为m的所有选法集合的价值最大值，即为答案。

集合划分：

按照第i种物品选或者不选划分 f[i][j]集合。

不选第i种物品,f[i][j] = f[i-1][j];
问题转化为从前i-1个物品选，且总体积不超过j的选法集合中的最大值。

选第i种物品, f[i][j] = f[i-1][j-v] + v* w ;
已经确定选第i种物品，那么问题转化为从前i-1个物品选，且总体积不超过j-v的选法集合中的最大值再加上 v* w。

#include <iostream>
#include <cstring>
using namespace std;
const int N = 30010; 
int n, m;
int f[N];
int main()
{
	cin >> n >> m;
	for (int i = 1; i <= m; i ++ ) {
		int v, p;
		cin >> v >> p;
		for (int j = n; j >= v; j -- ) 
			f[j] = max(f[j], f[j - v] + v * p);
	} 
	cout << f[n];
	return 0;
}

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 30010;

int n, m;
int f[N];

int main()
{
    cin >> m >> n;

    for (int i = 0; i < n; i ++ )
    {
        int v, w;
        cin >> v >> w;
        w *= v;
        for (int j = m; j >= v; j -- )
            f[j] = max(f[j], f[j - v] + w);
    }

    cout << f[m] << endl;

    return 0;
}

笔记、代码学习：
作者：yxc
链接：https://www.acwing.com/solution/content/4538/
https://www.acwing.com/solution/content/4538/
来源：AcWing
作者：z林深时见鹿
链接：https://www.acwing.com/solution/content/25677/
来源：AcWing

---

有依赖的背包问题

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

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

如下图所示：

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

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

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

输出最大价值。

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

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

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

数据范围
1 ≤ N,V ≤ 100
1 ≤ v_i,w_i ≤ 100
父节点编号范围：

• 内部结点：1 ≤ p_i ≤ N;
• 根节点 p_i=−1;

输入样例

5 7
2 3 -1
2 2 1
3 5 1
4 7 2
3 6 2

输出样例：

11

对于搜索的理解不透彻，需要对搜索有理解后，回顾。

分析
这是一道 背包DP 的 变种题目

根据题设的 拓扑结构 可以观察出每个 物品 的关系构成了一棵 树

而以往的 背包DP 每个 物品 关系是 任意的（但我们一般视为 线性的）

所以，这题沿用 背包DP 的话，要从原来的 线性DP 改成 树形DP 即可

然后思考 树形DP 的 状态转移

先比较一下以往 线性背包DP 的 状态转移，第 i 件 物品 只会依赖第 i−1 件 物品 的状态

如果本题我们也采用该种 状态依赖关系 的话，对于节点 i，我们需要枚举他所有子节点的组合 2k 种可能

再枚举 体积，最坏时间复杂度 可能会达到 O(N×2^N×V)（所有子节点都依赖根节点）
最终毫无疑问会 TLE

因此我们需要换一种思考方式，那就是枚举每个 状态 分给各个子节点 的 体积

这样 时间复杂度 就是 O(N×V×V)
具体分析如下：

笔记、代码学习：
作者：彩色铅笔
链接：https://www.acwing.com/solution/content/54139/
来源：AcWing

#include <iostream>
#include <cstring>
using namespace std;
const int N = 110;
int n, m;
int v[N], w[N];
int h[N], e[N], ne[N], 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; i = ne[i]) {
		int son = e[i];
		dfs(e[i]);
		// 分组背包 
		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]); 
	}
	// 将物品u放进去 
	for (int i = m; i >= v[u]; i -- ) f[u][i] = f[u][i - v[u]] + w[u];
	for (int i = 0; i < v[u]; i ++ ) f[u][i] = 0;
}
int main()
{
	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];
	return 0;
}  

---

背包问题求方案数

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

第 i 件物品的体积是 v_i，价值是 w_i。

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

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

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

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

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

数据范围
0 < N,V ≤ 1000
0 < v_i,w_i ≤ 1000

输入样例

4 5
1 2
2 4
3 4
4 6

输出样例：

2

闫氏DP分析法

01背包模型 f[i][j]

状态表示f(i,j)f(i,j)—集合： 考虑前 i 个物品，且当前已使用体积不超过 j 的方案

状态表示f(i,j)f(i,j)—属性： 该方案的价值为最大值 max

路径跟踪 g[i][j]

状态表示g(i,j)—集合： 考虑前 i 个物品，当前已使用体积恰好是 j 的，且 价值 为最大的方案

状态表示g(i,j)—属性： 方案的数量 Sum

状态转移g(i,j)：

如果f[i,j]=f[i−1,j] 且 f[i,j]=f[i−1,j−v]+w 则 g[i,j]=g[i−1,j]+g[i−1,j−v]
如果f[i,j]=f[i−1,j] 且 f[i,j]≠f[i−1,j−v]+w 则 g[i,j]=g[i−1,j]
如果f[i,j]≠f[i−1,j] 且 f[i,j]=f[i−1,j−v]+w 则 g[i,j]=g[i−1,j−v]

初始状态：g[0][0] = 1

Code(朴素写法)
时间复杂度： O(N×V)O(N×V)
空间复杂度： O(N×V)

#include <iostream>
using namespace std;
const int mod = 1e9 + 7, N = 1010;
int n, m;
int f[N], g[N]; // f存储i体积下的最大价值 g存储i体积下的最大方案数
int main()
{
    cin >> n >> m;
    g[0] = 1; 
    for (int i = 1; i <= n; i ++ ) {
        int v, w;
        cin >> v >> w;
        for (int j = m; j >= v; j -- ) {
            int t = max(f[j], f[j - v] + w); // 记录j体积下的最大价值
            int s = 0; // 记录j体积下的最大方案数
            // 针对最大方案的计算
            if (t == f[j]) s = g[j];
            if (t == f[j - v] + w) s += g[j - v];
            if (s >= mod) s -= mod;
            f[j] = t;
            g[j] = s;
        }
    }
    int maxv = 0, res = 0;
    for (int i = 1; i <= m; i ++ ) 
        if (f[maxv] < f[i])
            maxv = i;
    for (int i = 1; i <= m; i ++ ) 
        if (f[maxv] == f[i])
            res = (res + g[i]) % mod;
    cout << res;
    return 0;
}

笔记学习：
作者：彩色铅笔
链接：https://www.acwing.com/solution/content/54273/
来源：AcWing

---

背包问题求具体方案

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

第 i 件物品的体积是 v_i，价值是 w_i。

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

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

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

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

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

物品编号范围是 1…N。

数据范围
0 < N,V ≤ 1000
0 < v_i,w_i ≤ 1000

输入样例

4 5
1 2
2 4
3 4
4 6

输出样例：

1 4

题目要求输出字典序最小的解，假设存在一个包含第1个物品的最优解，为了确保字典序最小那么我们必然要选第一个。那么问题就转化成从2～N这些物品中找到最优解。之前的f(i,j)记录的都是前i个物品总容量为j的最优解，那么我们现在将f(i,j)定义为从第i个元素到最后一个元素总容量为j的最优解。接下来考虑状态转移：

f(i,j)=max(f(i+1,j), f(i+1,j−v[i])+w[i])
两种情况，第一种是不选第i个物品，那么最优解等同于从第i+1个物品到最后一个元素总容量为jj的最优解；第二种是选了第i个物品，那么最优解等于当前物品的价值w[i]加上从第i+1个物品到最后一个元素总容量为j−v[i]的最优解。

计算完状态表示后，考虑如何的到最小字典序的解。首先f(1,m)肯定是最大价值，那么我们便开始考虑能否选取第1个物品呢。

如果f(1,m)=f(2,m−v[1])+w[1]，说明选取了第1个物品可以得到最优解。

如果f(1,m)=f(2,m)，说明不选取第一个物品才能得到最优解。

如果f(1,m)=f(2,m)=f(2,m−v[1])+w[1]，说明选不选都可以得到最优解，但是为了考虑字典序最小，我们也需要选取该物品。

#include <iostream>
using namespace std;
const int N = 1010;
int n, m;
int v[N], w[N];
int f[N][N]; // i到n 体积为j 的最大价值 
int main()
{
	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]);
		}
	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; 
} 

笔记学习：
作者：T-SHLoRk
链接：https://www.acwing.com/solution/content/2687/
来源：AcWing

---

能量石

岩石怪物杜达生活在魔法森林中，他在午餐时收集了 N 块能量石准备开吃。

由于他的嘴很小，所以一次只能吃一块能量石。

能量石很硬，吃完需要花不少时间。

吃完第 i 块能量石需要花费的时间为 S_i 秒。

杜达靠吃能量石来获取能量。

不同的能量石包含的能量可能不同。

此外，能量石会随着时间流逝逐渐失去能量。

第 i 块能量石最初包含 E_i 单位的能量，并且每秒将失去 L_i 单位的能量。

当杜达开始吃一块能量石时，他就会立即获得该能量石所含的全部能量（无论实际吃完该石头需要多少时间）。

能量石中包含的能量最多降低至 0。

请问杜达通过吃能量石可以获得的最大能量是多少？

输入格式
第一行包含整数 T，表示共有 T 组测试数据。

每组数据第一行包含整数 N，表示能量石的数量。

接下来 N 行，每行包含三个整数 S_i,E_i,L_i。

输出格式
每组数据输出一个结果，每个结果占一行。

结果表示为 Case #x: y，其中 x 是组别编号（从 1 开始），y 是可以获得的最大能量值。

数据范围
1 ≤ T ≤ 10,
1 ≤ N ≤ 100,
1 ≤ S_i ≤ 100,
1 ≤ E_i ≤ 105,
0 ≤ L_i ≤ 105

输入样例：

3
4
20 10 1
5 30 5
100 30 1
5 80 60
3
10 4 1000
10 3 1000
10 8 1000
2
12 300 50
5 200 0

输出样例：

Case #1: 105
Case #2: 8
Case #3: 500

样例解释
在样例＃1中，有 N=4 个宝石。杜达可以选择的一个吃石头顺序是：

• 吃第四块石头。这需要 5 秒，并给他 80 单位的能量。
• 吃第二块石头。这需要 5 秒，并给他 5 单位的能量（第二块石头开始时具有 30 单位能量，5 秒后失去了 25 单位的能量）。
• 吃第三块石头。这需要 100 秒，并给他 20 单位的能量（第三块石头开始时具有 30 单位能量，10 秒后失去了 10 单位的能量）。
• 吃第一块石头。这需要 20 秒，并给他 0 单位的能量（第一块石头以 10 单位能量开始，110 秒后已经失去了所有的能量）。

他一共获得了 105 单位的能量，这是能获得的最大值，所以答案是 105。

在样本案例＃2中，有 N=3 个宝石。

无论杜达选择吃哪块石头，剩下的两个石头的能量都会耗光。

所以他应该吃第三块石头，给他提供 8 单位的能量。

在样本案例＃3中，有 N=2 个宝石。杜达可以：

• 吃第一块石头。这需要 12 秒，并给他 300 单位的能量。
• 吃第二块石头。这需要 5 秒，并给他 200 单位的能量（第二块石头随着时间的推移不会失去任何能量！）。

所以答案是 500。

分析

贪心+01DP


贪心（微扰） + dp
这道题还是比较难的，前置知识：

1. 贪心的微扰（邻项交换）证法，例题：国王游戏，耍杂技的牛
2. 01背包

算法1：暴力 O(T∗n!∗n)
可以dfs全排列枚举所有吃的方案，然后每次线性算能量取最大值即可。

算法2：贪心 + dp

贪心将问题转化
发现有可能存在最优解的某些宝石的贡献为0，我们剔除了这些宝石。

假设最优解的能量石排列长度为k(1<=k<=n) 因为去掉了那些没有贡献的宝石，位置为：
a₁,a₂,a₃…a_k。

那么对于任意两个位置i=a_l, j=a_l+1(1<=l<k)
交换后两个宝石的贡献总和不会变得更大，即（假设之前的总时间为tt ）：

整理后：

Si∗Lj<=Sj∗Li。

我们可以把跟ii有关的放到一边，调整一下:

这样，我们只要以如上条件作为宝石间排序的条件，进行一次sort。

因为对于其他形式的放置规律，必然可以通过交换满足

的相邻的两项来得到更小值。

那么最优解的坐标（新的坐标）一定满足：

a_i<a₂<a₃…<a_k

dp

那么，我们只要搞个01背包，S_i作为费用，max(0,E_i−(t−S_i)∗L_i) 作为价值 (t为当前花费时长)。

f[t] 表示当前正好花tt时间得到的最大能量。

状态转移方程：

f[t]=max(f[t],f[t−S_i]+max(0,E_i−(t−S_i)∗L_i))

由于我们背包放物品（宝石）的顺序是坐标从1到n的，所以一定能枚举到最优解。

初始状态：f[0]=0，其余为负无穷

答案：

二维做法

// 一维版
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 10010;
int n;
struct Stone {
	int s, e, l;
	bool operator< (const Stone & W) const {
		return s * W.l < l * W.s;
	}
}stone[N];
int f[N]; // 恰好是j时间得到的最大能量 
int main()
{
	int T;
	cin >> T;
	for (int C = 1; C <= T; C ++ ) {
		int m = 0; // 最大时间 
		cin >> n;
		for (int i = 0; i < n; i ++ ) {
			int s, e, l;
			cin >> s >> e >> l;
			stone[i] = {s, e, l};
			m += s; 
		}
		memset(f, -0x3f, sizeof f); // 恰好时需要初始化为无穷小 
		f[0] = 0;
		sort(stone, stone + n);
		for (int i = 0 ; i < n; i ++ ) {
			int s = stone[i].s;
			int e = stone[i].e;
			int l = stone[i].l;
			for (int j = m; j >= s; j -- )
				f[j] = max(f[j], f[j - s] + e - (j - s) * l);
		}	
		int res = 0;
		for (int i = 0; i <= m; i ++ ) res = max(res, f[i]);
		cout << "Case #" << C << ": "<< res << endl;
	}
	return 0;
}

笔记学习：
作者：墨染空
链接：https://www.acwing.com/solution/content/4639/
来源：AcWing

---

金明的预算方案

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

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

今天一早，金明就开始做预算了，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：

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

每个主件可以有0个、1个或2个附件。

附件不再有从属于自己的附件。

金明想买的东西很多，肯定会超过妈妈限定的N元。

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

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

他希望在不超过N元（可以等于N元）的前提下，使每件物品的价格与重要度的乘积的总和最大。

设第j件物品的价格为v[j]，重要度为w[j]，共选中了k件物品，编号依次为j₁，j₂，…，j_k，则所求的总和为：

v[j₁]∗w[j₁]+v[j₂]∗w[j₂]+…+v[j_k]∗w[j_k]（其中*为乘号）

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

输入格式
输入文件的第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

纯粹的分组背包问题

算法
(DP,分组背包问题) O(Nm)
可以将每个主件及其附件看作一个物品组，记主件为 p，两个附件为 a,b，则最多一共有4种组合：

1. p
2. p,a
3. p,b
4. p,a,b

这四种组合是互斥的，最多只能从中选一种，因此可以将每种组合看作一个物品，那么问题就变成了分组背包问题。可以参考分组背包问题。

其每个组中的划分只能用其中的一个。所以求出对应的组的每个划分块需要多少钱（相当于体积），钱 * 重要程度（相当于价值）。

在枚举四种组合时可以使用二进制的思想，可以简化代码。
此题最重要的一个地方就是使用二进制优化：

一共有n个物品，求n个物品每一个一组，每两个一组，每三个一组....一直到每n个一组可以使用二进制来进行表示，枚举的一个技巧。

for(int k = 0 ; k < 1 << n ; k++) // 1 << n结果为: 10000...0。 一个“1”，n个“0”。
{
    for(int u = 0 ; u < n ; u++)  //判断n个位即可
    {
        if(k >> u & 1) //就可以判断对应的位是否为1，代表某个物品被选中。 u 为 0 时，代表第一个物品被选中。u为1，代表第二个物品被选中。
        {

        }
    }
}

时间复杂度
分组背包的时间复杂度是 物品总数 * 总体积，因此总时间复杂度是 O(Nm)。

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#define v first
#define w second
using namespace std;
typedef pair<int, int> PII;
const int N = 60, M = 32010;
int n, m;s
PII master[N];
vector<PII> servent[N];
int f[M]; 
int main()
{
	cin >> m >> n;
	for (int i = 1; i <= n; i ++ ) {
		int v, p, q;
		cin >> v >> p >> q;
		p *= v; // 题目求价格和重要度乘积的总和的最大值
		if (!q) master[i] = {v, p}; 
		else servent[q].push_back({v, p});
	}
	for (int i = 1; i <= n; i ++ ) // 数量 
		for (int u = m; u >= 0; u -- ) // 价格 
			for (int j = 0; j < 1 << servent[i].size(); j ++ ) { // 主键数量 + 附件数量 
				int v = master[i].v, w = master[i].w; // 主键
				for (int k = 0; k < servent[i].size(); k ++ ) // 如果有附件，则判断附件每一种选择 
					if (j >> k & 1) { // 对应每一个物品是否被选中 
						v += servent[i][k].v;
						w += servent[i][k].w; 
					}
				if (u >= v) f[u] = max(f[u], f[u - v] + w); 
			}  
	cout << f[m];
	return 0;
}

笔记、代码学习：
作者：yxc
链接：https://www.acwing.com/solution/content/3803/
来源：AcWing
笔记学习：
作者：啦啦啦123
链接：https://www.acwing.com/solution/content/48338/
来源：AcWing

---