背包一遍过

01背包：n种物品，你的背包容量m，每种物品最多取一次，求最大的价值
完全背包：同01，不过，每种物品可以拿无限次
多重背包：就是在原本的背包基础上，对每种物品的个数进行限制。
即：给出物品的重量、价值以及个数。

统一解释：w[i]表示i物品的重量（体积） v[i]表示i物品的价值

01背包

我们直接对于所有物品遍历，再遍历所有的剩余容量递推即可。

#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 1e3 + 50;
int w[maxn];
int v[maxn];
int dp[maxn] = {0};
//dp[i],i容量的最大价值 
int main()
{
	ios::sync_with_stdio(0);//关闭同步流，使得cin，cout速度加快 
	cin.tie(0);
	cout.tie(0);
	
	int n,m;
	cin >> n >> m;
	for(int i = 1; i <= n; i++)
	{
		cin >> w[i] >> v[i];//输入第i个物品的重量，价值 
	} 
	for(int i = 1; i <= n; i++)
	{//遍历所有的物品 
		for(int j = m; j >= w[i]; j--)
		{//容量从最大遍历到当前物品 
			dp[j] = max(dp[j],dp[j-w[i]] + v[i]);
			//不拿             拿 = 减去当前物品体积， + 价值 
		}
	}
	cout << dp[m] << endl;
	return 0;
}

完全背包

沙雕方法
我们只需要在01背包的基础之上，暴力每种物品可能取多少个即可

#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 1e3 + 50;
int w[maxn];
int v[maxn];
int dp[maxn] = {0};
//dp[i],i容量的最大价值 
int main()
{
	ios::sync_with_stdio(0);//关闭同步流，使得cin，cout速度加快 
	cin.tie(0);
	cout.tie(0);
	
	int n,m;
	cin >> n >> m;
	for(int i = 1; i <= n; i++)
	{
		cin >> w[i] >> v[i];//输入第i个物品的重量，价值 
	} 
	for(int i = 1; i <= n; i++)
	{//遍历所有的物品 
		for(int j = m; j >= w[i]; j--)
		{//容量从最大遍历到当前物品 
			for(int k = 0; k * w[i] <= j; k++)
			dp[j] = max(dp[j],dp[j-k*w[i]] + k*v[i]);
			//不拿             拿 = 减去当前物品体积， + 价值 
		}
	}
	cout << dp[m] << endl;
	return 0;
}

当然，上述的暴力方法在数据量特别大的时候容易超时，所以我们需要优化
如何去取代每一个容量都暴力物品的个数呢？
反着递推！！！
为什么？？
当我们从w[i]到m遍历剩余容量时，如果取当前1个物品会使我们的价值变大，当前的dp[j] = dp[ j - w[i] ] + v[i];
而我们是从小到大遍历的，这个时候dp[ j - w[i] ]我们已经知道他的大小了（在这个容量的时候还取不取i这个物品也决定了）。
由此可以避免单纯的瞎暴力

#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 1e3 + 50;
int w[maxn];
int v[maxn];
int dp[maxn] = {0};
//dp[i],i容量的最大价值 
int main()
{
	ios::sync_with_stdio(0);//关闭同步流，使得cin，cout速度加快 
	cin.tie(0);
	cout.tie(0);
	
	int n,m;
	cin >> n >> m;
	for(int i = 1; i <= n; i++)
	{
		cin >> w[i] >> v[i];//输入第i个物品的重量，价值 
	} 
	for(int i = 1; i <= n; i++)
	{//遍历所有的物品 
		for(int j = w[i]; j <= m; j++)
		{//从小到大遍历剩余容量即可
			dp[j] = max(dp[j],dp[j-w[i]] + v[i]);
			//不拿             拿 = 减去当前物品体积， + 价值 
		}
	}
	cout << dp[m] << endl;
	return 0;
}

多重背包

在完全背包的基础之上限制每种物品的个数，所以我们不可以去从小到大地递推了（因为不知道物品个数剩多少）
将 一种物品多个 转化成 多种物品（每种一个）
使用二进制的思想！！
已知，每个数都可以用二进制的形式来表示，对于给定的n，我们只要把它分解为从2的x 次幂的数，（最后剩下的一个直接补齐，不要求2^x）就可以组成任意件小于等于x的数。
比如：一个物品，重量为2，价值为3，个数为5
我们把这个物品的个数5分解成：1 2 2
这5个物品转化成：
物品A 重量为2 * 1，价值为3 * 1，个数1
物品B 重量为2 * 2，价值为3 * 2，个数1
物品C 重量为2 * 2，价值为3 * 2，个数1
这样子可以很大程度的将个数n转化成log（n）
等到都转化完成后，我们就把他当做01背包写即可

#include <iostream>
#include <algorithm>
#include <string.h>
using namespace std;
const int maxn = 250;
struct node
{
	int p,h,c;
}a[maxn];
int w[maxn*10],v[10*maxn];
int main() 
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t;
    cin >> t;
    while(t--)
    {
    	int n,m;
		cin >> n >> m;
		int z = 0;
		for(int i = 0; i < m; i++)
		{
			cin >> a[i].p >> a[i].h >> a[i].c;
			for(int j = 1; j <= a[i].c; j*=2)//把所有可能都记录下来 
			{//二进制优化 
			//1,2，4,8,16......
			
				w[z] = a[i].p * j;
				v[z] = a[i].h * j;
				z++;
				a[i].c -= j;
			}
			if(a[i].c)//二进制优化之后，剩下一个数，无论是多少，直接把他当成一个物品就行
			{
				w[z] = a[i].c *a[i].p;
				v[z] = a[i].c * a[i].h;
				z++;
			}
		} 
		int dp[105] = {0};//表示花i块钱，最多的重量
		for(int i = 0; i < z; i++)
		{
			for(int j = n; j >= w[i]; j--)
			{
				dp[j] = max(dp[j],dp[j-w[i]]+v[i]);
			}
		}
		cout << dp[n] << endl; 
	}
    return 0;
}

排版抓瞎请见谅，如有问题欢迎指出。