nyoj 289（0-1背包）

苹果

时间限制： 3000 ms  |  内存限制： 65535 KB

难度： 3

描述

ctest有n个苹果，要将它放入容量为v的背包。给出第i个苹果的大小和价钱，求出能放入背包的苹果的总价钱最大值。

输入

有多组测试数据，每组测试数据第一行为2个正整数，分别代表苹果的个数n和背包的容量v，n、v同时为0时结束测试，此时不输出。接下来的n行，每行2个正整数，用空格隔开，分别代表苹果的大小c和价钱w。所有输入数字的范围大于等于0，小于等于1000。

输出

对每组测试数据输出一个整数，代表能放入背包的苹果的总价值。

样例输入

3 3
1 1
2 1
3 1
0 0

样例输出

2

  该题为典型的动态规划之0-1背包问题，关键在于理解状态转移方程：result[n][v] = max(result[n - 1][v], result[n - 1][v - c] + w);result[n][v]表示背包的容量为v，待选择的苹果数为n时背包中能包含的价值，c，w表示标号为n的苹果的大小和价钱。表达式的含义即为：现在有标号为1,2,3....n - 1,n这n个苹果，我们考虑的是这标号为n的苹果是不是要放在背包里，最优的取法中有没有取这标号为n的苹果。这就无非两种情况：如果不放入背包，那么背包的容量还是v，待选择的苹果数变为了n - 1,此时result[n][v]的值就是result[n - 1][v]的值;反之，背包的容量变成了v - c，待选择的苹果数变成了n - 1,由于此时背包里放入了苹果n，背包的苹果的总价值要加上苹果n的价钱w，result[n][v]的值就是result[n - 1][v - c] + w的值。所以result[n][v]的最大值就是max(result[n - 1][v], result[n - 1][v - c] + w).如果v - c < 0,即此时背包放不下苹果n，result[n][v]只能为result[n - 1][v].

容易理解的自顶向下的递归写法：（超时~~（×_×）~~）

#include <stdio.h>
#include <string.h>

int array[1001][2];

inline int max(int a, int b) {
	return a > b ? a : b;
}

int dp1(int n, int v) {
	if(n <= 0 || v <= 0)
		return 0;
	else {
		if(v - array[n - 1][0] >= 0)
			return max(dp1(n - 1, v), dp1(n - 1, v - array[n - 1][0]) + array[n - 1][1]);
		else
			return dp1(n - 1, v);
	}
}

int main() {
	int n, v, i, k;
	while(scanf("%d%d", &n, &v)) {
		if(!n && !v)
			break;
		for(i = 0; i < n; i++)
			scanf("%d%d", &array[i][0], &array[i][1]);
		printf("%d\n", dp1(n, v));
	}
	return 0;
}

上述方法由于每个相同子问题的解都要重复计算，超时是难免的。于是我们可以考虑带备忘的自顶向下的递归思路：（可以AC了，但时间有点长^-^）

#include <stdio.h>
#include <string.h>

int array[1001][2];
int result[1001][1001];

inline int max(int a, int b) {
	return a > b ? a : b;
}

int dp1(int n, int v) {
	if(n <= 0 || v <= 0)
		return 0;
	else if(result[n][v])
		return result[n][v];
	else {
		if(v - array[n - 1][0] >= 0)
			return result[n][v] = max(dp1(n - 1, v), dp1(n - 1, v - array[n - 1][0]) + array[n - 1][1]);
		else
			return result[n][v] = dp1(n - 1, v);
	}
}

int main() {
	int n, v, i, k;
	while(scanf("%d%d", &n, &v)) {
		memset(result, 0, sizeof(result));
		if(!n && !v)
			break;
		for(i = 0; i < n; i++)
			scanf("%d%d", &array[i][0], &array[i][1]);
		printf("%d\n", dp1(n, v));
	}
	return 0;
}

学长教育我们：代码不是AC了就可以滴。还要更优化。既然每次求解都要得知它子问题的解，那为什么不自底向上求解呢。虽然时间复杂度是一样的（相差一个常量系数），但自底向上算法（从最小的问题开始解决）没有递归调用的开销，时间又会少很多的。自底向上法：

#include <stdio.h>
#include <string.h>

int array[1001][2];
int result[1001][1001];

inline int max(int a, int b) {
	return a > b ? a : b;
}

void dp2(int n, int v) {
	int i, k;
	for(i = 1; i <= n; i++)
		for(k = 0; k <= v; k++) {
			if(k - array[i - 1][0] >= 0)
				result[i][k] = max(result[i - 1][k], result[i - 1][k - array[i - 1][0]] + array[i - 1][1]);
			else
				result[i][k] = result[i - 1][k];
		}
}

int main() {
	int n, v, i, k;
	int c, w;
	while(scanf("%d%d", &n, &v)) {
		memset(result, 0, sizeof(result));
		if(!n && !v)
			break;
		for(i = 0; i < n; i++)
			scanf("%d%d", &array[i][0], &array[i][1]);
		dp2(n, v);
		printf("%d\n", result[n][v]);
	}
	return 0;
}

大家可能发现了，如果自底向上法不写成函数的形式，就没有必要开array数组，完全可以读一组数据处理一组，小优化：

#include <stdio.h>
#include <string.h>

int result[1001][1001];

inline int max(int a, int b) {
	return a > b ? a : b;
}

int main() {
	int n, v, i, k;
	int c, w;
	while(scanf("%d%d", &n, &v)) {
		memset(result, 0, sizeof(result));
		if(!n && !v)
			break;
		for(i = 1; i <= n; i++) {
			scanf("%d%d", &c, &w);
			for(k = 0; k <= v; k++) {
				if(k - c >= 0)
					result[i][k] = max(result[i - 1][k], result[i - 1][k - c] + w);
				else
					result[i][k] = result[i - 1][k];
			}
		}
		printf("%d\n", result[n][v]);
	}
	return 0;
}

最后一发，AC榜上大牛们内存怎么那么少呢？再细细分析我们可以发现，要求result[n][v]我们只需要知道result[n - 1][v]和result[n - 1][v - c] + w的值。以n为行v为列，模拟求解过程，result数组滚动起来只与上一层的解有关，即要单方面求result[n][v]我们根本不需要知道result[n - 2][?]，result[n - 3][?]的值是多少。那么不就表示我们只需要一个一维数组来滚动求解最终答案，这样内存就又少很多了。so：

#include <stdio.h>
#include <string.h>

int result[1001];

inline int max(int a, int b) {
	return a > b ? a : b;
}

int main() {
	int n, v, i, k;
	int c, w;
	while(scanf("%d%d", &n, &v)) {
		memset(result, 0, sizeof(result));
		if(!n && !v)
			break;
		for(i = 1; i <= n; i++) {
			scanf("%d%d", &c, &w);
			for(k = v; k >= c; k--) {
				result[k] = max(result[k], result[k - c] + w);
			}
		}
		printf("%d\n", result[v]);
	}
	return 0;
}