题目链接：http://poj.org/problem?id=3624
Description
Bessie has gone to the mall's jewelry store and spies a charm bracelet. Of course, she'd like to fill it with the best charms possible from the N (1 ≤ N ≤ 3,402) available charms. Each charm i in the supplied list has a weightWi (1 ≤ Wi ≤ 400), a 'desirability' factor Di (1 ≤ Di ≤ 100), and can be used at most once. Bessie can only support a charm bracelet whose weight is no more than M (1 ≤ M ≤ 12,880).
Given that weight limit as a constraint and a list of the charms with their weights and desirability rating, deduce the maximum possible sum of ratings.
Input
* Line 1: Two space-separated integers: N and M
* Lines 2..N+1: Line i+1 describes charm i with two space-separated integers: Wi and Di
Output
* Line 1: A single integer that is the greatest sum of charm desirabilities that can be achieved given the weight constraints
Sample Input
4 6 1 4 2 6 3 12 2 7
Sample Output
23
首先先放上Time Limited Exceeded的代码：
#include<iostream>
#include<fstream>
#include<vector>
#include<string>
#include<map>
#include<iterator>
#include<algorithm>
#include<numeric>
#include<cmath>
#include<sstream>
#include<bitset>
using namespace std;
int n(0);
vector<int> w;
vector<int> v;
int rec(int i, int j);
int main()
{
#ifdef ONLINE_JUDGE
#else
freopen("D:\\in.txt", "r", stdin);
freopen("D:\\out.txt", "w", stdout);
#endif // ONLINE_JUDEG
int m(0);
int a(0), b(0);
cin>>n>>m;
for (int i = 0; i < n; i++)
{
cin >> a >> b;
w.push_back(a);
v.push_back(b);
}
int value = rec(0, m);
cout << value << endl;
return 0;
}
int rec(int i, int j)//从第i个物品开始挑选总重小于j的部分
{
int res;
if (i == n)//已经没有剩余物品了
{
res = 0;
}
else if (j < w[i])//无法挑选这个商品
{
res = rec(i + 1, j);
}
else //挑选和不挑选的情况都试一下
{
res = max(rec(i + 1, j), rec(i + 1, j - w[i]) + v[i]);
}
return res;
}这种方法的搜索深度是n,而且每一层的搜索都需要两次分支，最坏就需要O（2 n）的时间，当n比较大时就没办法解了。由递归调用树可知，相同参数的rect函数可能计算多次。
如果参数相同，那么计算结果也应该相同，让我们在这里把第一次计算的结果记录下来，省略掉第二次以后的重复计算试试看。
代码如下：
#include<iostream>
#include<fstream>
#include<vector>
#include<string>
#include<map>
#include<iterator>
#include<algorithm>
#include<numeric>
#include<cmath>
#include<sstream>
#include<bitset>
using namespace std;
int n(0);
vector<int> w;
vector<int> v;
int rec(int i, int j);
const int MaxN = 3500;
const int MaxW = 12880;
int dp[MaxN][MaxW];//记忆化数组（变动地方之一，开辟记忆化数组）
int main()
{
#ifdef ONLINE_JUDGE
#else
freopen("D:\\in.txt", "r", stdin);
freopen("D:\\out.txt", "w", stdout);
#endif // ONLINE_JUDEG
int m(0);
int a(0), b(0);
cin>>n>>m;
for (int i = 0; i < n; i++)
{
cin >> a >> b;
w.push_back(a);
v.push_back(b);
}
memset(dp, -1, sizeof(dp));
int value = rec(0, m);
cout << value << endl;
return 0;
}
int rec(int i, int j)//从第i个物品开始挑选总重小于j的部分,这也是开辟记忆化数组的来源
{
if (dp[i][j] > 0)
{
//已经计算过的话直接使用之前的结果（变动地方之二，避免重复计算）
return dp[i][j];
}
int res;
if (i == n)//已经没有剩余物品了
{
res = 0;
}
else if (j < w[i])//无法挑选这个商品
{
res = rec(i + 1, j);
}
else //挑选和不挑选的情况都试一下
{
res = max(rec(i + 1, j), rec(i + 1, j - w[i]) + v[i]);
}
return dp[i][j]=res; //将结果记录在数组中（变动地方之三，避免重复计算）
}dp[n][j]=0
dp[i][j]= dp[i+1][j] (j<w[i])
max(dp[i+1][j], dp[i+1][j-w[i]]+v[i]) (其他)
如上所示，不难写出递推函数，直接利用递推式将各项的值计算出来，简单地利用二重循环也可以解决这一问题。
代码如下：
#include<iostream>
#include<fstream>
#include<vector>
#include<string>
#include<map>
#include<iterator>
#include<algorithm>
#include<numeric>
#include<cmath>
#include<sstream>
#include<bitset>
using namespace std;
int n(0);
vector<int> w;
vector<int> v;
int rec(int i, int j);
const int MaxN = 3403;
const int MaxW = 12881;
int dp[MaxN][MaxW];//记忆化数组（变动地方之一，开辟记忆化数组）
int main()
{
#ifdef ONLINE_JUDGE
#else
freopen("D:\\in.txt", "r", stdin);
freopen("D:\\out.txt", "w", stdout);
#endif // ONLINE_JUDEG
int m(0);
int a(0), b(0);
scanf("%d%d",&n,&m);
for (int i = 0; i < n; i++)
{
scanf("%d%d", &a, &b);
w.push_back(a);
v.push_back(b);
}
memset(dp, -1, sizeof(dp)); // 记忆化数组的初值均设为－1，代表dp[i][j]还没有被计算过
for (int j = 0; j < m; j++)//这里是边界条件
{
dp[n][j] = 0;
}
for (int i = n - 1; i >= 0; i--)
for (int j = 0; j <= m; j++)
{
if (j < w[i]) //无法放下这个商品
{
dp[i][j] = dp[i + 1][j];
}
else
{
dp[i][j] = max(dp[i+1][j],dp[i+1][j-w[i]]+v[i]);//放与不放的两种情况都尝试一下
}
}
cout <<dp[0][m]<< endl;
return 0;
}上面的DP中关于 i 的循环是逆向进行的。反之，如果按照如下的定义递推关系的话，关于 i 的循环就能够正向进行。
dp[i+1][j] := 从前i个物品中选出总重量不超过 j 的物品时的总价值的最大值
dp[0][j] = 0
dp[i+1][j] = dp[i][j] (j<w[i]) （无法放入这个物品）
max(dp[i][j],dp[i][j-w[i]]+v[i]) (其他) （第 i+1 个物品放与不放都尝试一下）
代码如下：
#include<iostream>
#include<fstream>
#include<vector>
#include<string>
#include<map>
#include<iterator>
#include<algorithm>
#include<numeric>
#include<cmath>
#include<sstream>
#include<bitset>
using namespace std;
int n(0);
const int MaxN = 3403;
const int MaxW = 12881;
int dp[MaxN][MaxW];
vector<int> w;
vector<int> v;
int main()
{
#ifdef ONLINE_JUDGE
#else
freopen("D:\\in.txt", "r", stdin);
freopen("D:\\out.txt", "w", stdout);
#endif // ONLINE_JUDEG
int m(0);
memset(dp, 0, sizeof(dp));
scanf("%d%d", &n, &m);
int weight(0), value(0);
for (int i = 0; i < n; i++)
{
cin >> weight >> value;
w.push_back(weight);
v.push_back(value);
}
for (int i = 0; i <n; i++)
{
for (int j = 0; j <=m; j++)
{
if (j < w[i])
{
dp[i + 1][j] = dp[i][j];
}
else //放与不放两种情况都尝试一下
{
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
}
}
}
cout << dp[n][m] << endl;
return 0;
}下面尝试，采用“滚动数组”。最终AC。这里为了使用采用滚动数组，采用的对称状态的定义：用f(i,j)表示“把前i个物品装入到最大重量为m的背包中的最大价值”，它的状态转移方程也不难得出： f(i,j)=max( f(i-1,j),f(i-1,j-w[i]) + v[i] )
标准的01背包，动态转移方程如下。其中f[i,j]表示的是前i个物品装入容量为j的背包里所能产生的最大价值，w[i]是第i个物品的重量，v[i]是第i个物品的价值。如果某物品超过背包容量，则该物品一定不放入背包，问题变为剩余i-1个物品装入容量为j的背包所能产生的最大价值；否则该物品装入背包，问题变为剩余i-1个物品装入容量为j-w[i]的背包所能产生的最大价值加上物品i的价值d[i]...恩，多清晰...
还有一点是，这题我之前使用二维数组做的，不过提交之后MLE了...所以只能想办法使用一维数组，手工模拟一下发现 f[i,j] 只跟之前的某几个值有关，再之前计算的结果就都没用了...所以我们就可以用一个数组来重复使用了，不过注意要倒序，保证无后效性...
if (w[i]>j) dp[i,j] = dp[i-1,j]
else dp[i,j] = max(dp[i-1,j-w[i]]+d[i],dp[i-1,j])
代码如下：
#include<iostream>
#include<fstream>
#include<vector>
#include<string>
#include<map>
#include<iterator>
#include<algorithm>
#include<numeric>
#include<cmath>
#include<sstream>
#include<bitset>
using namespace std;
int n(0);
const int MaxW = 12881;
int f[MaxW] = { 0 };//开辟滚动数组，这里按最大可容纳的重量来开辟
int main()
{
#ifdef ONLINE_JUDGE
#else
freopen("D:\\in.txt", "r", stdin);
freopen("D:\\out.txt", "w", stdout);
#endif // ONLINE_JUDEG
int m(0);
int v(0), w(0);
memset(f, 0, sizeof(f));
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
{
scanf("%d%d", &w, &v);
for (int j = m; j >= w; j--)
{
f[j] = max(f[j], f[j - w] + v);//放与不放两种情况都尝试一下
}
}
cout << f[m] << endl;
return 0;
}另外一种写法：
#include<iostream>
#include<fstream>
#include<vector>
#include<string>
#include<map>
#include<iterator>
#include<algorithm>
#include<numeric>
#include<cmath>
#include<sstream>
#include<bitset>
using namespace std;
const int MaxN = 3403;
const int MaxW = 12881;
int f[MaxW] = { 0 };
int w[MaxN] = { 0 };//各个商品的重量
int v[MaxN] = { 0 };//各个商品的价值
int main()
{
#ifdef ONLINE_JUDGE
#else
freopen("D:\\in.txt", "r", stdin);
freopen("D:\\out.txt", "w", stdout);
#endif // ONLINE_JUDEG
memset(f, 0, sizeof(f));
int n(0);
int m(0);
scanf("%d%d",&n,&m);
for (int i = 1; i <= n; i++)//依次把各个商品的重量和价值放入相应的数组中
{
cin >> w[i] >> v[i];
}
for (int i = 1; i <= n; i++)
{
for (int j = m; j >= w[i]; j--)
{
f[j] = max(f[j], f[j - w[i]]+ v[i]);//放与不放两种情况都尝试一下
}
}
cout << f[m] << endl;
return 0;
}
扫一扫
233
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
