您的位置: 首页  >  IT文章  >  01双肩包、完全背包、多重背包

01双肩包、完全背包、多重背包

分类: IT文章 • 2023-11-01 10:18:14
01背包、完全背包、多重背包

前言

今天花了一下午加一晚上的时间，在九度oj才ac了一道简单的多重背包题目，之前没做过多重背包的题目，导致我做题时复杂化了，虽然是假期但是也不能这么浪费时间，果断总结一下，这里参考了dd_engi大牛的《背包问题九讲》，原文链接：http://love-oriented.com/pack/

01背包


题目

有N件物品和一个容量为V的背包。第i建物品的费用是c[i],价值是w[i]。求解将哪些物品装入背包可使价值总和最大

思路

这是最基础的背包问题，特点是：每种物品只有一件，可以选择放或者不放

用子问题定义状态：即dp[i][j]表示前i件物品放入一个容量为j的背包可以获得的最大价值。则其状态转移方程为：

dp[i][j] = max{dp[i - 1][j], dp[i - 1][j - c[i] + w[i]]}

这个方程非常重要，基本上所有跟背包相关的问题的方程都是由它衍生出来。这里详细解释一下：

将前i件物品放入容量为j的背包中这个子问题，若只考虑第i件物品的策略（放或者不放），那么就可以转换为一个只牵扯前i-1件物品的问题。
  • 如果不放第i件物品，那么问题就转换为前i-1件物品放入容量为j的背包中的最大价值，价值为dp[i - 1][j]
  • 如果放入第i件物品，那么问题就转换为前i-1件物品放入容量为j-c[i]的背包中，此时能获得的最大价值是dp[i-1][j-c[i]],再加上放入第i件物品获得的价值w[i]

优化空间复杂度

先考虑一下上面的状态转移方程如何实现，肯定有一个主循环i = 1...N,每次算出来二维数组dp[i][0..V]的所有值。那么如果只用一个数组f[0...V],能不能保证第i次循环结束后f[v]就是我们定义的状态f[i][v]呢？f[i][v]是由f[i-1][v]和f[i-1][v-c[i]]两个子问题递推而来，能否保证在推f[i][v]时（也即在第i次主循环中推f[v]时）能够得到f[i-1][v]和f[i-1][v-c[i]]的值呢？事实上，这要求在每次主循环中我们以v=V...0的顺序推f[v]，这样才能保证推f[v]时f[v-c[i]]保存的是状态f[i-1][v-c[i]]的值。伪代码如下：

for i  in 0 ... N
    for  v = V ... 0
        f[v] = max{f[v], f[v-c[i]] + w[i]}


练习题目

题目：http://acm.hdu.edu.cn/showproblem.php?pid=2602

代码：

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

#define N 1010

int value[N], volume[N], dp[N];

// 0-1背包，优化空间
void dpPackage(int n, int v)
{
	int i, j;

	memset(dp, 0, sizeof(dp));

	for (i = 1; i <= n; i ++) {
		for (j = v; j >= volume[i]; j --) {
				dp[j] = dp[j] > dp[j - volume[i]] + value[i] ? dp[j] : dp[j - volume[i]] + value[i];
		}
	}

	printf("%d\n", dp[v]);
}

int main(void)
{
	int i, t, n, v;

	scanf("%d", &t);

	while (t --) {
		// 接收参数
		scanf("%d %d", &n, &v);

		for (i = 1; i <= n; i ++)	scanf("%d", value + i);
		for (i = 1; i <= n; i ++)	scanf("%d", volume + i);

		// 0-1背包
		dpPackage(n, v);
	}

	return 0;
}


完全背包问题


题目

有N种物品和一个容量为V的背包，每种物品都有无限件可用。第i种物品的费用是c[i]，价格是w[i].求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大

思路

这个问题类似于01背包问题，所不同的是每种物品有无限件。也就是从每种物品的角度考虑，与它相关的策略已非取或不取两种，而且右取0件、取1件、取2件...等很多种。如果仍然按照01背包的思路，令dp[i][v]表示前i种物品恰好放入一个容量为v的背包的最大权值。仍然可以按照每种物品不同的策略写出状态转移方程：

dp[i][v] = max{dp[i-1][v - k * c[i]] + k * w[i] | 0 <= k * c[i]<= v}

转化为01背包求解

最简单的想法是：考虑到第i种物品最多选V/c[i]件，于是可以把第i种物品转换为V/c[i]件费用及价值均不变的物品，然后求解这个01背包问题。但是这样完全没有改进时间复杂度，但这毕竟给了我们将完全背包转换为01背包问题的思路：将一种物品拆成多件物品

O(VN)的算法

这个算法使用一维数组，先看伪代码：

for i = 1 ... N
    for v = 0 ... V
        f[v] = max{f[v], f[v-cost] + weight}

你会发现，这个伪代码与01背包的伪代码只有v的循环次序不同而已。为什么这样一改就行呢？首先，想想为什么01背包问题中要按照v=V...0的逆序来循环。这是因为要保证第i次循环中的状态f[i][v]是由状态f[i-1][v-c[i]]递推而来。换句话说，这正是为了保证每件物品只选一次，保证在考虑“选入第i件物品”这件策略时，依据的是一个绝无已经选入第i件物品的子结果f[i-1][v-c[i]]。而现在完全背包的特点恰好是每种物品可选无限件，所以在考虑“加选一件dii种物品”这种策略时，却正需要一个可能已选入第i种物品的子结果f[i][c-v[i]],所以就可以并且必须采用v=0...V的顺序循环


练习题目

题目链接：http://ac.jobdu.com/problem.php?pid=1454

代码：

/**
 * 完全背包问题
 */

#include <stdio.h>
#include <stdlib.h>

#define INF 50000000

typedef struct coin {
	int price, weight;
} coin;

void dynamicPackage(coin *coins, int n, int v)
{
	if (v < 0) {
		printf("This is impossible.\n");
		return;
	}

	int i, j, *dp;

	// 动态分配内存
	dp = (int *)malloc(sizeof(int) * (v + 1));

	// 初始化
	dp[0] = 0;
	for (i = 1; i <= v; i ++)	dp[i] = INF;

	// 完全背包问题
	for (i = 1; i <= n; i ++) {
		for (j = coins[i].weight; j <= v; j ++) {
			dp[j] = (dp[j] < dp[j - coins[i].weight] + coins[i].price) ? dp[j] : dp[j - coins[i].weight] + coins[i].price;
		}
	}

	if (dp[v] >= INF)
		printf("This is impossible.\n");
	else
		printf("The minimum amount of money in the piggy-bank is %d.\n", dp[v]);


	// 清理内存
	free(dp);
	dp = NULL;
}


int main(void)
{
	int t, e, f, n, i;
	coin *coins;

	scanf("%d", &t);

	while (t --) {
		scanf("%d %d", &e, &f);
		scanf("%d", &n);

		// 接收货币
		coins = (coin *)malloc(sizeof(coin) * (n + 1));
		if (coins == NULL)	exit(-1);

		for (i = 1; i <= n; i ++) {
			scanf("%d %d", &coins[i].price, &coins[i].weight);
		}

		// 完全背包
		dynamicPackage(coins, n, f - e);


		free(coins);
		coins = NULL;	
	}	

	return 0;
}


多重背包问题


题目

有N种物品和一个容量为V的背包。第i种物品最多有n[i]件，每件费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大

思路

多重背包问题的思路跟完全背包的思路非常类似，只是k的取值是有限制的，因为每件物品的数量是有限制的，状态转移方程为：

dp[i][v] = max{dp[i - 1][v - k * c[i]] + w[i] | 0 <=k <= n[i]}


练习题目

题目：http://ac.jobdu.com/problem.php?pid=1455

代码：

#include <stdio.h>
#include <stdlib.h>
 
typedef struct rice {
    int price, weight, num;
} rice;
 
void dynamic(rice *rices, int m, int n)
{
    int i, j, cur, k, **dp;
 
    // 动态申请二维数组
    dp = (int **)malloc(sizeof(int *) * (m + 1));
    for (i = 0; i <= m; i ++)
        dp[i] = (int *)malloc(sizeof(int) * (n + 1));
 
    // 初始化
    for (i = 0; i <= m; i ++)
        for (j = 0; j <= n; j ++)
            dp[i][j] = 0;
 
    // 动态规划
    for (i = 1; i <= m; i ++) {
        for (j = 1; j <= n; j ++) {
            for (k = 0; k <= rices[i].num; k ++) {
                if (j - k * rices[i].price >= 0) {
                    cur = dp[i - 1][j - k * rices[i].price] + k * rices[i].weight;
                    dp[i][j] = dp[i][j] > cur ? dp[i][j] : cur;
                } else {
                    break;
                }
            }
        }
    }
 
    printf("%d\n", dp[m][n]);
 
    for (i = 0; i <= m; i ++)
        free(dp[i]);
}
 
 
int main(void)
{
    int i, c, n, m;
     
    rice rices[2010];
 
    scanf("%d", &c);
 
    while (c --) {
        scanf("%d %d", &n, &m);
 
        // 接收数据
        for (i = 1; i <= m; i ++) {
            scanf("%d %d %d", &rices[i].price, &rices[i].weight, &rices[i].num);
        }
 
        // 多重背包问题
        dynamic(rices, m, n);
    }
 
 
    return 0;
}

后记

主要还是为了巩固01背包问题并且多做点题目，所以记录了一下学习《背包九讲》的过程，大家真想搞清楚背包问题，建议还是参考原文链接：http://love-oriented.com/pack/

相关推荐