01揹包、完全揹包、多重揹包 模板

參考鏈接
https://blog.csdn.net/Scar_Halo/article/details/82765736
https://blog.csdn.net/sinat_30973431/article/details/85119871
https://blog.csdn.net/qian2213762498/article/details/79857508
https://blog.csdn.net/qq_38984851/article/details/81133840)

01揹包(ZeroOnePack)： 有N件物品和一個容量爲V的揹包。（每種物品均只有一件）第i件物品的費用是c[i]，價值是w[i]。求解將哪些物品裝入揹包可使價值總和最大。

完全揹包(CompletePack)： 有N種物品和一個容量爲V的揹包，每種物品都有無限件可用。第i種物品的費用是c[i]，價值是w[i]。求解將哪些物品裝入揹包可使這些物品的費用總和不超過揹包容量，且價值總和最大。

多重揹包(MultiplePack)： 有N種物品和一個容量爲V的揹包。第i種物品最多有n[i]件可用，每件費用是c[i]，價值是w[i]。求解將哪些物品裝入揹包可使這些物品的費用總和不超過揹包容量，且價值總和最大。

比較三個題目，會發現不同點在於每種揹包的數量，01揹包是每種只有一件，完全揹包是每種無限件，而多重揹包是每種有限件。

01揹包：

狀態轉移方程便是：

               f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]}

把這個過程理解下：在前i件物品放進容量v的揹包時，它有兩種情況： 第一種是第i件不放進去，這時所得價值爲:f[i-1][v] 第二種是第i件放進去，這時所得價值爲：f[i-1][v-c[i]]+w[i] （第二種是什麼意思？就是如果第i件放進去，那麼在容量v-c[i]裏就要放進前i-1件物品） 最後比較第一種與第二種所得價值的大小，哪種相對大，f[i][v]的值就是哪種。

要求將i個物品裝進容量爲j的揹包的最大價值：即取以下倆箇中的較大的一個 一個是：i-1個物品裝進容量爲（j）的揹包的最大價值； 一個是：i-1個物品裝進容量爲（j減去第i個物品的重量）的揹包的價值，再加上第i個物品的價值。

這裏是用二位數組存儲的，可以把空間優化，用一位數組存儲。

逆序！

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

01揹包模板

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=10005;
 
int n, m;
int w[maxn], v[maxn];
int dp[maxn];
bool path[maxn][maxn];
 
void output() {	//路徑輸出
	int i=n, j=m;
	while (i>=0 && j>0) {
		if(path[i][j] == 1) {
			printf("%d ", i+1);
			j -= w[i];
		}
		i--;
	}
	printf("\n");
}
 
int main() {
	scanf("%d%d", &n, &m);
	for(int i=0; i<n; i++)
		scanf("%d%d", &w[i], &v[i]);
	memset(dp, 0, sizeof(dp));
	memset(path, false, sizeof(path));
 
	for(int i=0; i<n; i++) {
		for(int j=m; j>=w[i]; j--)	//注意是逆序、逆序、逆序！！
			if (dp[j] < dp[j - w[i]] + v[i]) {
				dp[j] = dp[j - w[i]] + v[i];
				path[i][j]=true;
			}
	}
	printf("%d\n", dp[m]);
	output();
}

完全揹包：

順序！

想必大家看出了和01揹包的區別，這裏的內循環是順序的，而01揹包是逆序的。

現在關鍵的是考慮：爲何完全揹包可以這麼寫？
在次我們先來回憶下，01揹包逆序的原因？是爲了是max中的兩項是前一狀態值，這就對了。
那麼這裏，我們順序寫，這裏的max中的兩項當然就是當前狀態的值了，爲何？

因爲每種揹包都是無限的。當我們把i從1到N循環時，f[v]表示容量爲v在前i種揹包時所得的價值，這裏我們要添加的不是前一個揹包，而是當前揹包。所以我們要考慮的當然是當前狀態。

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

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=10005;
 
int n, m;
int w[maxn], v[maxn];
int dp[maxn];
bool path[maxn][maxn];
 
void output() {
	int i=n, j=m;
	while (i>=0 && j>0) {
		if(path[i][j] == 1) {
			printf("%d ", i+1);
			j -= w[i];
		} else i--;
	}
	printf("\n");
}
 
int main() {
	scanf("%d%d", &n, &m);
	for(int i=0; i<n; i++)
		scanf("%d%d", &w[i], &v[i]);
	memset(dp, 0, sizeof(dp));
	memset(path, false, sizeof(path));
 
	for(int i=0; i<n; i++) {
		for(int j=w[i]; j<=m; j++)	//注意是順序、順序、順序！！
			if (dp[j] < dp[j - w[i]] + v[i]) {
				dp[j] = dp[j - w[i]] + v[i];
				path[i][j]=true;
			}
	}
	printf("%d\n", dp[m]);
	output();
}

多重揹包：

逆序

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=10005;
 
int n, m;
int w[maxn], v[maxn], c[maxn];
int dp[maxn];
bool path[maxn][maxn];
 
void output() {
	int i=n, j=m;
	while (i>=0 && j>0) {
		if(path[i][j] == 1 && c[i]) {
			printf("%d ", i+1);
			j -= w[i];
			c[i]--;
		} else
			i--;
	}
	printf("\n");
}
 
int main() {
	scanf("%d%d", &n, &m);
	for(int i=0; i<n; i++)
		scanf("%d%d%d", &w[i], &v[i], &c[i]);
	memset(dp, 0, sizeof(dp));
	memset(path, false, sizeof(path));
 
	for(int i=0; i<n; i++)
		for(int k=0; k<c[i]; k++)
			for(int j=m; j>=w[i]; j--)	//也是逆序！！ 相當於重複01揹包！
				if (dp[j] < dp[j - w[i]] + v[i]) {
					dp[j] = dp[j - w[i]] + v[i];
					path[i][j] = true;
				}
 
	printf("%d\n", dp[m]);
	output();
}

多重揹包+二進制優化：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=100005;
 
int n, m;
int w[maxn], v[maxn], c[maxn];
int dp[maxn];
 
void zero(int weight, int value) {
	for(int i=m; i>=weight; i--)
		dp[i] = max(dp[i], dp[i-weight]+value);
}
 
void complet(int weight, int value) {
	for(int i=weight; i<=m; i++)
		dp[i] = max(dp[i], dp[i-weight]+value);
}
 
void multi(int weight, int value, int amount) {
	if(weight*amount >= m) {	//容量小的時候相當於無限揹包
		complet(weight, value);
		return;
	}
	int k = 1;
	while(k < amount) {	//當k個仍小於容量時，用01揹包
		zero(k*weight, k*value);
		amount -= k;
		k <<= 1;
	}
	zero(amount*weight, amount*value);	//最後剩餘再用01揹包
}
 
int main() {
	scanf("%d%d", &n, &m);
	memset(dp, 0, sizeof(dp));
	for(int i=0; i<n; i++)
		scanf("%d%d%d", &w[i], &v[i], &c[i]);
 
	for(int i=0; i<n; i++)
		multi(w[i], v[i], c[i]);
 
	printf("%d\n", dp[m]);
}