【代码模板】01背包

1. 题目描述：

有 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
 

2. 算法构思：

1. 定义：

v[i] ：第i个物品的体积

w[i]：第i个物品的价值

f[i][j] ：前i个物品放入体积为j的物品后，最大价值

2. 算法：dp

对于第i个物品，我们有一下两种选择：选或者不选

①选：我们选择价值更大的一个

          将前 i-1 件物品的最大值与现在的作比较

          ·前 i-1 件物品价值最大值我们存到了f[i-1][j]中

          ·现在物品价值最大值为前 i-1件物品当中，体积不超过 （V-当前物品体积 ）的价值加上第i个物品的价值

②不选：即为前 i-1 个物品的最大价值

最后输出f[n][v]表示前n个物品的最大价值

朴素版代码如下：

#include<bits/stdc++.h>
using namespace std;
int v[1005],w[1005];
int f[1005][1005];
int main()
{
	int n,m,i,j,k,V;
	cin>>n>>V;
	for(int i=1;i<=n;i++)
	{
		cin>>v[i]>>w[i];
	}
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=V;j++)
		{
			if(j>=v[i])//！！！当前j-v[i]>0才能放
			{
				f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
			}
			else f[i][j]=f[i-1][j];
		}
	}
	cout<<f[n][V];
	return 0;
}

3. 优化

为了节省空间，我们要尝试把二维数组变为一维数组，更高效：

我们发现每次f[i][j] 都是从上一轮算好的 f[i-1] 得来的

核心代码：

for(int i=1;i<=n;i++)
{
	for(int j=V;j>=v[i];j--)
	{
		f[j]=max(f[j],f[j-v[i]]+w[i]);
	}
}

为什么j要倒着循环呢？

已知 f[] 为价值，是从小到大的。

如果 j 正着来，则这一轮调用上一轮的值时，会更新先前的 f[j] ，这时算 i 的值时，所调用的并不是上一轮算好的，而是这一轮的新更改的，不符合；

反之，则调用 i 时，对上一轮较小的数没有改动，符合

3. 01背包朴素版、优化版完整代码

朴素二维版：

#include<bits/stdc++.h>
using namespace std;
int v[1005],w[1005];
int f[1005][1005];
int main()
{
	int n,m,i,j,k,V;
	cin>>n>>V;
	for(int i=1;i<=n;i++)
	{
		cin>>v[i]>>w[i];
	}
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=V;j++)
		{
			if(j>=v[i])
			{
				f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
			}
			else f[i][j]=f[i-1][j];
		}
	}
	cout<<f[n][V];
	return 0;
}

优化一维版（明显看起来更简洁了 :D)

#include<bits/stdc++.h>
using namespace std;
int v[1005],w[1005];
int f[1005];
int main()
{
	int n,m,i,j,k,V;
	cin>>n>>V;
	for(int i=1;i<=n;i++)
	{
		cin>>v[i]>>w[i];
	}
	for(int i=1;i<=n;i++)
	{
		for(int j=V;j>=v[i];j--)
		{
			f[j]=max(f[j],f[j-v[i]]+w[i]);
		}
	}
	cout<<f[V];
	return 0;
}