【刷题】动态规划——背包问题：背包九讲模板

最新推荐文章于 2022-07-19 09:49:41 发布
最新推荐文章于 2022-07-19 09:49:41 发布
阅读量553 收藏 2
点赞数
分类专栏： 刷题 文章标签： 动态规划 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42581685/article/details/121911994
版权

文章目录

一、01背包

题目链接

1、朴素做法 O(nm)

f[i][j]表示前i个物品，体积和不超过j的情况下所能拿的最大价值。
考虑第i个物品，两种情况：取和不取
不取：f[i][j] = f[i - 1][j]
取：f[i][j] = f[i - 1][j - v[i]] + w[i]

#include <iostream>
using namespace std;
const int N = 1005, M = 1005;
int n, m, v[N], w[N], f[N][M];
int main() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++) {
		scanf("%d%d", &v[i], &w[i]);
	}
	for (int i = 1; i <= n; i++) {
		for (int j = 0; j <= m; j++) {
			if (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];
		}
	}
	printf("%d\n", f[n][m]);
}

2、滚动数组去掉第一维

观察两个递推式
递推式1：f[i][j] = f[i - 1][j]
递推式2：f[i][j] = f[i - 1][j - v[i]] + w[i]

可以看到递推式f[i]只用到了f[i-1]，f[1]~f[i-2]再也不会用到，显然可以将f的i维从1至n缩减成1至2，即f[i]可以覆盖f[i-2]的位置。

更进一步看，f的i维可以缩减成1。

对于递推式1，直接用f[i][j]覆盖掉f[i-1][j]的位置，也就是去掉第一维，i仍然是从小到大，转移仍可以顺利进行，因为 f[j]不会在后面被用到。递推式变成f[j] = f[j]，这是一个恒等式，可以不写。

对于递推式2，如果j是从小到大，去掉第一维会有问题，因为f[j]在用f[j-v[i]]时，f[j - v[i]]已经在这层循环被更新过了，也就是f[i][j]用的是f[i][j - v[i]]而不是f[i - 1][j - v[i]]，和原来的递推式不等价。
红色的是去掉第一维前，蓝色是去掉第一维后那么如何防止f[j]用f[j - v[i]]时f[j - v[i]]被更新呢？只需让j从大到小循环即可。
在这里插入图片描述

#include <iostream>
using namespace std;
const int N = 1005, M = 1005;
int n, m, v[N], w[N], f[M];
int main() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++) {
		scanf("%d%d", &v[i], &w[i]);
	}
	for (int i = 1; i <= n; i++) {
		for (int j = m; j >= v[i]; j--) {
			f[j] = max(f[j], f[j - v[i]] + w[i]);
		}
	}
	printf("%d\n", f[m]);
}

二、完全背包

相比01背包，每个物品能取任意个
题目链接

1、朴素做法 O(nm^2)

枚举第i个物品是取0, 1, 2…个
f[i][j] = f[i - 1][j - k * v[i]] + k * w[i]

#include <iostream>
using namespace std;
const int N = 1005, M = 1005;
int n, m, v[N], w[N], f[N][M];
int main() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++) {
		scanf("%d%d", &v[i], &w[i]);
	}
	for (int i = 1; i <= n; i++) {
		for (int j = 0; j <= m; j++) {
			for (int k = 0; k * v[i] <= j; k++) {
				f[i][j] = max(f[i][j], f[i - 1][j - k * v[i]] + k * w[i]);
			}
		}
	}
	printf("%d\n", f[n][m]);
}

2、去掉内层循环 O(nm)

原本的递推式是
递推式1：f[i][j] = max(f[i-1][j], f[i-1][j-v] + w, f[i-1][j-2v] + 2w, f[i-1][j-3v] + 3w, ...)
观察f[i][j-v]的递推式（下划线方便与上面对齐）
递推式2：f[i][j-v] = max(_________f[i-1][j-v], ____f[i-1][j-2v] + w, _f[i-1][j-3v] + 2w, ...)

对比发现
递推式1的第2项f[i-1][j-v] + w 是 递推式2的第1项f[i-1][j-v] 加上w
递推式1的第3项f[i-1][j-2v] + 2w 是 递推式2的第2项f[i-1][j-2v] + w 加上w
以此类推。

将递推式2代入递推式1，（递推式1的第2项之后全替换成 递推式2的第1项之后 + w）
max(f[i-1][j-v] + w, f[i-1][j-2v] + 2w, f[i-1][j-3v] + 3w ... )
= max(f[i-1][j-v], f[i-1][j-2v] + w, f[i-1][j-3v] + 2w, ... ) + w
= f[i][j-v] + w

故递推式变成f[i][j] = max(f[i-1][j], f[i][j-v]+w)

#include <iostream>
using namespace std;
const int N = 1005, M = 1005;
int n, m, v[N], w[N], f[N][M];
int main() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++) {
		scanf("%d%d", &v[i], &w[i]);
	}
	for (int i = 1; i <= n; i++) {
		for (int j = 0; j <= m; j++) {
			f[i][j] = max(f[i][j], f[i - 1][j]);
			if (j >= v[i])
				f[i][j] = max(f[i][j], f[i][j - v[i]] + w[i]);
		}
	}
	printf("%d\n", f[n][m]);
}

3、滚动数组去掉第一维

和01背包不同，这边f[i][j]就是从f[i][j - v[i]]递推而来，要的是这层循环更新后的数据，因此j要从前往后。所以直接去掉第一维即可。

#include <iostream>
using namespace std;
const int N = 1005, M = 1005;
int n, m, v[N], w[N], f[M];
int main() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++) {
		scanf("%d%d", &v[i], &w[i]);
	}
	for (int i = 1; i <= n; i++) {
		for (int j = v[i]; j <= m; j++) {
			f[j] = max(f[j], f[j - v[i]] + w[i]);
		}
	}
	printf("%d\n", f[m]);
}

三、多重背包

和完全背包不同，多重背包每件物品数量有限制，不能取无限个
题目链接

1、朴素做法 O(nms)

和完全背包差不多，k循环加个条件 k <= 物品个数s[i]即可

#include <iostream>
using namespace std;
const int N = 1005, M = 1005;
int n, m, v[N], w[N], s[N], f[N][M];
int main() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++) {
		scanf("%d%d%d", &v[i], &w[i], &s[i]);
	}
	for (int i = 1; i <= n; i++) {
		for (int j = 0; j <= m; j++) {
			for (int k = 0;  k <= s[i] && k * v[i] <= j; k++) {
				f[i][j] = max(f[i][j], f[i - 1][j - k * v[i]] + k * w[i]);
			}
		}
	}
	printf("%d\n", f[n][m]);
}

2、滚动数组去掉第一维

同01背包，j需要从大到小

#include <iostream>
using namespace std;
const int N = 1005, M = 1005;
int n, m, v[N], w[N], s[N], f[M];
int main() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++) {
		scanf("%d%d%d", &v[i], &w[i], &s[i]);
	}
	for (int i = 1; i <= n; i++) {
		for (int j = m; j >= 0; j--) {
			for (int k = 0;  k <= s[i] && k * v[i] <= j; k++) {
				f[j] = max(f[j], f[j - k * v[i]] + k * w[i]);
			}
		}
	}
	printf("%d\n", f[m]);
}

3、二进制优化 O(nmlogs)

首先多重背包不能像完全背包一样直接去掉内重循环
f[i][j] = max(f[i-1][j], f[i-1][j-v] + w, f[i-1][j-2v] + 2w, f[i-1][j-3v] + 3w, ... , f[i-1][j-sv] + sw)
f[i][j-v] = max(_________f[i-1][j-v], ____f[i-1][j-2v] + w, _f[i-1][j-3v] + 2w, ... , f[i-1][j-sv] + (s-1)w, f[i-1][j-(s+1)v] + sw)
由于多了最后一项f[i-1][j-(s+1)v] + sw，所以并不能直接用f[i][j-v]去取代f[i][j]递推式第2项之后的最大值。

二进制优化是将物品的数目拆分成多组，各组数目是1,2,4,8,16…，每组至多只能选一次。因为1,2,4,8,16…可以凑出任意正整数，例如7可拆成4+2+1，100可拆成64+32+4，都不选就是0。
假如把s拆成1, 2, 4, 8, …, 2k, c，有c < 2k+1 。首先1, 2, 4, 8, …, 2k 可以凑出[0, 2k+1-1]中的任意数，拿这些数+c后可凑出[c, 2k+1-1+c]的任意数，而2k+1-1+c = s，也就是[c, s]，又因为c < 2k+1 ，因此[0, 2k+1-1]和[c, s]包括了[0, s]
综上1, 2, 4, 8, …, 2k 可以凑出0 ~ s。

因此把物品数s拆成多组二进制的形式，并用01背包的做法就可以解决多重背包。这样循环k就从O(s)优化成了O(logs)。

#include <iostream>
using namespace std;
const int N = 25005, M = 2005;
int n, m, v[N], w[N], f[M];
int main() {
	scanf("%d%d", &n, &m);
	int cnt = 0, tv, tw, s; 
	for (int i = 1; i <= n; i++) {
		scanf("%d%d%d", &tv, &tw, &s);
		int k = 1;
		while (k <= s) {
			cnt++;
			v[cnt] = tv * k;
			w[cnt] = tw * k;
			s -= k;
			k *= 2;
		}
		if(s > 0) {
			cnt++;
			v[cnt] = tv * s;
			w[cnt] = tw * s;
		}
	}
	n = cnt;
	for (int i = 1; i <= n; i++) {
		for (int j = m; j >= v[i]; j--) {
			f[j] = max(f[j], f[j - v[i]] + w[i]);
		}
	}
	printf("%d\n", f[m]);
}

4、单调队列优化 O(nm)

再看这几个递推式
f[i][j] = max(f[i-1][j], f[i-1][j-v] + w, f[i-1][j-2v] + 2w, f[i-1][j-3v] + 3w, ... , f[i-1][j-sv] + sw)
f[i][j-v] = max(_________f[i-1][j-v], ____f[i-1][j-2v] + w, _f[i-1][j-3v] + 2w, ... , f[i-1][j-sv] + (s-1)w, f[i-1][j-(s+1)v] + sw)
…
简单表示为
f[j]=max(f[j], f[j-v], f[j-2v], f[j-3v], ... , f[j-sv])
f[j-v] = max(__f[j-v], f[j-2v], f[j-3v], ... , f[j-sv], f[j-(s+1)v])
f[j-2v] = max(_________f[j-2v], f[j-3v], ... , f[j-sv], f[j-(s+1)v], f[j-(s+2)v])
f[j-3v] = max(_________________ f[j-3v], ... , f[j-sv], f[j-(s+1)v], f[j-(s+2)v], f[j-(s+3)v])
其实这相当于一个长度为s+1的滑动窗口求最大值问题，可以在循环j的同时用单调队列求窗口内最大值。
（而完全背包则是求前缀最大值，所以用1个数不断更新记录最大值即可，这个数恰好是f[i][j-v]）

具体实现可用单调队列存f[i][j]的下标j（也就是体积）而不是最大值。
用下标可直接算出状态转移式。具体如下：
原本的递推式是f[i][j] = f[i-1][j-kv] + kw。不妨设窗口最大值(单调队列队头)存的下标是j'。j' = j - kv，于是k = (j - j') / v ，递推式变为f[i][j] = f[i - 1][j'] + (j - j') / v * w。

注意递推式的每项加的w数不同，第1项是0w，第二项是1w，第三项是2w…，j越前加的w越多，因此单调队列进队时需要考虑这点，例如j-2v和j-5v就差了3w。具体地，j1跟j2比较时(j1 > j2)，需要比较f[i - 1][j1]和f[i - 1][j2] + (j1 - j2) / v * w大小。

同时窗口每向右挪动一格，递推式各项都要+w，但各项+w不会改变窗口最大值是哪一项。

不使用滚动数组

#include <iostream>
using namespace std;
const int N = 1005, M = 20005;
int n, m, v[N], w[N], s[N], f[N][M];
int que[M], head, tail; //队列存的元素是下标(体积)，即f[i][j]的j 
int main() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i ++) {
		scanf("%d%d%d", &v[i], &w[i], &s[i]);
	}
	for (int i = 1; i <= n; i ++) {
		for (int j = 0; j < v[i]; j ++) {
			head = 0, tail = -1;
			for (int k = j; k <= m; k += v[i]) {
				// 队列不为空，且队头下标在窗口外，队头出队 
				if (head <= tail && que[head] < k - s[i] * v[i]) head++;
				
				// 进队，考虑不同项加的w个数不同 
				while (head <= tail && 
				f[i-1][k] >= f[i - 1][que[tail]] + (k - que[tail]) / v[i] * w[i]) tail --;
				que[++ tail] = k;
				
				// 更新f[i][k]
				if (head <= tail) {
					f[i][k] = max(f[i][k], f[i - 1][que[head]] + (k - que[head]) / v[i] * w[i]);
				}
			}
		}
	}
	
	printf("%d\n", f[n][m]);
}

滚动数组保留两行

只需保留f[i]和f[i - 1]即可，用f表示f[i]，g表示f[i - 1]

#include <iostream>
#include <cstring>
using namespace std;
const int N = 1005, M = 20005;
int n, m, v[N], w[N], s[N], f[M], g[M];
int que[M], head, tail; //队列存的元素是下标(体积)，即f[i][j]的j 
int main() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i ++) {
		scanf("%d%d%d", &v[i], &w[i], &s[i]);
	}
	for (int i = 1; i <= n; i ++) {
		memcpy(g, f, sizeof(f));
		for (int j = 0; j < v[i]; j ++) {
			head = 0, tail = -1;
			for (int k = j; k <= m; k += v[i]) {
				// 队列不为空，且队头下标在窗口外，队头出队 
				if (head <= tail && que[head] < k - s[i] * v[i]) head++;
				
				// 进队，考虑不同项加的w个数不同 
				while (head <= tail && 
				g[k] >= g[que[tail]] + (k - que[tail]) / v[i] * w[i]) tail --;
				que[++ tail] = k;
				
				// 更新f[i][k]
				if (head <= tail) {
					f[k] = max(f[k], g[que[head]] + (k - que[head]) / v[i] * w[i]);
				}
			}
		}
	}
	
	printf("%d\n", f[m]);
}

四、混合背包问题

物品有3类，分别是只能选1次、选无限次、选si次。相当于01背包、完全背包、多重背包混合。
题目链接

还是分两类，取第i件物品和不取第i件物品。
1、不取第i件物品：f[i][j] = f[i - 1][j]
2、取第i件物品：看第i件物品的类别，如果只选1次用01背包的递推式，选无限次按完全背包的递推式，选si次按多重背包的递推式。
2.1、选1次：f[i][j] = f[i - 1][j - v[i]] + w[i]
2.2、选无限次：f[i][j] = f[i][j - v[i]] + w[i]
2.3、选si次：f[i][j] = max(f[i - 1][j], f[i - 1][j - v[i]] + w[i], f[i - 1][j - 2v[i]] + 2w[i], ...) ，数据量较大可用多重背包的二进制优化。

#include <iostream>
using namespace std;
const int MAX_N = 1005 * 10, MAX_V = 1005;
int N, V, v[MAX_N], w[MAX_N], s[MAX_N], f[MAX_V];
int main() {
	scanf("%d%d", &N, &V);
	int cnt = 0, tv, tw, ts; 
	for (int i = 1; i <= N; i++) {
		scanf("%d%d%d", &tv, &tw, &ts);
		if (ts == -1 || ts == 0) {
			cnt++;
			v[cnt] = tv;
			w[cnt] = tw;
			s[cnt] = ts;
		}
		else {
			int k = 1;
			while (k <= ts) {
				cnt++;
				v[cnt] = tv * k;
				w[cnt] = tw * k;
				s[cnt] = k;
				ts -= k;
				k *= 2;
			}
			if(ts > 0) {
				cnt++;
				v[cnt] = tv * ts;
				w[cnt] = tw * ts;
				s[cnt] = k;
			}
		}
	}
	N = cnt;
	for (int i = 1; i <= N; i++) {
		if (s[i] != 0) { // 01或多重背包 
			for (int j = V; j >= v[i]; j--) {
				f[j] = max(f[j], f[j - v[i]] + w[i]);
			}
		}
		else { // 完全背包 
			for (int j = v[i]; j <= V; j++) {
				f[j] = max(f[j], f[j - v[i]] + w[i]);
			}
		}
	}
	printf("%d\n", f[V]);
	
}

更优雅的写法（其实就是不存输入）

#include <iostream>
using namespace std;
const int MAX_N = 1005 * 10, MAX_V = 1005;
int N, V, f[MAX_V];
int main() {
	scanf("%d%d", &N, &V);
	int v, w, s; 
	for (int i = 1; i <= N; i++) {
		scanf("%d%d%d", &v, &w, &s);
		if (s == -1) s = 1;
		if (s) { // 01或多重背包 
			for (int k = 1; k <= s; k *= 2) {
				for (int j = V; j >= k * v; j--) {
					f[j] = max(f[j], f[j - k * v] + k * w);
				}
				s -= k;
			}
			if (s) {
				for (int j = V; j >= s * v; j--) {
					f[j] = max(f[j], f[j - s * v] + s * w);
				}
			}
		} 
		else {// 完全背包 
			for (int j = v; j <= V; j++) {
				f[j] = max(f[j], f[j - v] + w);
			}
		}
	}
	printf("%d\n", f[V]);
}

五、二维费用背包问题 O(nvm)

除了体积限制以外，还有重量限制。
题目链接

f[i][j][k]表示前i个物品，体积不大于j，重量不大于k的价值和最大。
可以分成两种，选第i组物品和不选第i组物品
1、不选第i个物品：f[i][j][k] = f[i-1][j][k]
2、选第i个物品：f[i][j][k] = f[i-1][j - v[i]][k - m[i]] + w[i]
写法基本和01背包相同。也可用滚动数组去掉第一维。

#include <iostream>
using namespace std;
const int NAX_N = 1005, MAX_V = 105, MAX_M = 105;
int N, V, M, f[MAX_V][MAX_M];
int main() {
	scanf("%d%d%d", &N, &V, &M);
	int v, m, w;
	for (int i = 1; i <= N; i++) {
		scanf("%d%d%d", &v, &m, &w);
		
		for (int j = V; j >= v; j--) {
			for (int k = M; k >= m; k--) 
			f[j][k] = max(f[j][k], f[j - v][k - m] + w);
		}
	}
	printf("%d\n", f[V][M]);
}

六、分组背包 O(nm)

每组有物品若干个，同一组内的物品最多只能选一个。
题目链接

1、朴素做法

f[i][j]表示前i组物品，体积不大于j的价值和最大。
可以分成两种，选第i组物品和不选第i组物品
1、不选第i组物品：f[i][j] = f[i-1][j]
2、选第i组物品：枚举选的是第i组的哪个物品
f[i][j] = f[i-1][j - v[i][k]] + w[i][k] v[i][k]、w[i][k]表示i组第k个物品的体积、价值
写法基本和多重背包相同。

#include <iostream>
using namespace std;
const int N = 105, S = 105, M = 105;
int n, m, v[S][N], w[S][N], s[N], f[N][M];
int main() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++) {
		scanf("%d", &s[i]);
		for (int j = 1; j <= s[i]; j++) {
			scanf("%d%d", &v[i][j], &w[i][j]);
		}
	}
	for (int i = 1; i <= n; i++) {
		for (int j = 0; j <= m; j++) {
			f[i][j] = f[i - 1][j];
			for (int k = 1; k <= s[i]; k++) {
				if (j - v[i][k] >= 0)
					f[i][j] = max(f[i][j], f[i - 1][j - v[i][k]] + w[i][k]);
			}
		}
	}
	printf("%d\n", f[n][m]);
}

2、滚动数组去掉第一维

同01背包，j从大到小

#include <iostream>
using namespace std;
const int N = 105, S = 105, M = 105;
int n, m, v[S][N], w[S][N], s[N], f[M];
int main() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++) {
		scanf("%d", &s[i]);
		for (int j = 1; j <= s[i]; j++) {
			scanf("%d%d", &v[i][j], &w[i][j]);
		}
	}
	for (int i = 1; i <= n; i++) {
		for (int j = m; j >= 0; j--) {
			for (int k = 1; k <= s[i]; k++) {
				if (j - v[i][k] >= 0)
					f[j] = max(f[j], f[j - v[i][k]] + w[i][k]);
			}
		}
	}
	printf("%d\n", f[m]);
}

七、有依赖背包问题 O(nm^2)

购买某个物品必须要把它的前置物品给买了。
题目链接

由于物品之间有相互依赖关系，这个依赖关系呈树形，因此考虑用树形DP解决。

f[i, j]表示：以第i个物品为根节点的子树，选物品i，总体积不超过j的方案的最大价值。
这边条件加上必须选取i是因为只有购买了i才能考虑购买i的子树。

考虑最后状态如何转移，不像01背包那样只要考虑取或不取上一个，这边k个孩子可以选取其中任意个，那么可能的方案就是2k种，将这些方案都考虑一遍显然会超时。

因此不再考虑要选取几个孩子，而是考虑选k体积方案的孩子，其中0 <= k <= m。
因为体积j的最优方案必然是从某一个k转移过来，而这边k有m+1种，这就类似分组背包问题，将m+1个k看成1组，从这组中挑选1个转移。

不妨设i的孩子是s1、s2、…、sn，因此转移方程式就变成
f[i][j] = f[i][j-k] + max(f[s1][k], f[s2][k], ..., f[sn][k])

这样乍一看好像是只挑了一个孩子，不符合我们取任意几个孩子的决策，其实不然。这只是针对当前体积从这个孩子里取最大的，体积是其他的时候还会包括选其他孩子的方案。
举个例子，不妨假设最优解是挑s1、s2，他们的体积分别是k1、k2。
那么选s1体积k1的方案，在递归s1时已经包括在f[i][j-k2]中了；递归s2时f[i][j-k2]再加上选s2体积k2的方案就得到f[i][j]。

PS1：这边的j要从大到小枚举，不然同一组的物品可能选多次

PS2：因为f[i, j]为必须购买i，因此j循环范围是从V-v[i]到0，要先预留物品i的空间

PS3：在遍历完所有孩子后，v[i] <= j <=V的部分必须加上物品i，即f[i][j] = f[i][j - v[i]] + w[i]，注意不是f[i][j] = max(f[i][j], f[i][j - v[i]] + w[i])，因为不买i是不符合f的定义的

PS4：在遍历完所有孩子后，要对j<= v[i]的部分清0，因为这部分体积的方案只能买子树而不能买物品i，不符合题意

#include <iostream>
#include <cstring>
using namespace std;
int N, V, v[105], w[105], f[105][105];
int head[105], val[105], nxt[105], len;

void add_node(int a, int b) {
	val[len] = b;
	nxt[len] = head[a];
	head[a] = len ++;
}

void dfs(int u) {
	for (int i = head[u]; i != -1; i = nxt[i]) {
		int son = val[i];
		dfs(son);
		
		for (int j = V - v[u]; j >= 0; j--) {
			for (int k = 0; k <= j; k++) {
				f[u][j] = max(f[u][j], f[u][j - k] + f[son][k]);
			}
		}
	}
	for (int j = V; j >= v[u]; j--) f[u][j] = f[u][j - v[u]] + w[u];
	for (int j = v[u] - 1; j >= 0; j--) f[u][j] = 0;
}

int main() {
	scanf("%d%d", &N, &V);
	int p, root;
	memset(head, -1, sizeof(head));
	for (int i = 1; i <= N; i ++) {
		scanf("%d%d%d", &v[i], &w[i], &p);
		if (p == -1) {
			root = i;
			continue;
		}
		add_node(p, i);
	}
	
	dfs(root);
	printf("%d\n", f[root][V]);
	return 0;
}

八、泛化物品

在这里插入图片描述

九、背包问题问法的变化

1、不同条件的背包（体积限制改成不少于/恰好是，求价值由最大改为最小等）

1、初始化不同。
初始化只需看i=0（一个都不选）的情况，i>0可由i=0递推而来。
“不超过” 的初始化要将f[0][j]全部设为0，是因为体积不超过j，包括了体积为0的选法。
“恰好是” 的初始化只有f[0][0]=0，其余都是无穷，因为一个都不选体积只能是0，不能是其他值。
“至少是” 的初始化只有f[0][0]=0，其余都是无穷。因为一个都不选体积只能是0，所以只有体积至少是0才是合法的。

2、j的循环范围不同
“不超过”和“恰好是”的情况下，j - v[i] < 0是无意义的，体积不超过-1和恰好是-1都是不可能的选法，因为体积最小就是0。
”至少是“的情况下，当j - v[i] < 0的时候仍然可以进行状态转移，因为体积至少是-1、-2、-3也是有意义的，它包括了体积>=0的选法。可将负数的部分答案记在f[i][0]中。

体积条件写法
不超过f全初始化为0；循环时保证j-v[i]>=0
恰好是f[0]=0，其余无穷；循环时保证j-v[i]>=0
至少是f[0]=0，其余无穷；循环时不必保证j-v[i]>=0

ps1.初始化取正无穷还是负无穷取决于问题求价值最大值还是最小值，求最大取负无穷，求最小取正无穷。
ps2. 如果不是求价值问题，初始化0和无穷可根据题意更改，例如求方案数往往f[0][0] = 1，其余是0。

2、背包问题求具体方案（字典序最小）

题目链接
以01背包为例，状态转移只有两种可能
不取第i件物品：f[i][j] = f[i - 1][j]
取第i件物品：f[i][j] = f[i - 1][j - v[i]] + w[i]
如果取和不取的得到的答案一样，那就选取的方案，这样输出的字典序会更小。（字典序只要相同位置小就更小，跟长度无关，’\0’当成最小的，例如123<21，12<123）因为选了i在放这位，肯定比不选i，选i之后的放在这位更好。例如i是3，选了i是1235，不选i是125，1235 < 135。

具体实现时，比较f[i][j]和f[i - 1][j - v[i]] + w[i] 的值，相同则输出i。但这样就是从后往前推，输出的方案会优先包括n更大的，也就是将字典序最大的解倒序输出。
要想输出字典序最小的解，只需要把输入顺序进行反向，输出N - i + 1即可，也就是把第1个物品当成第n个，第2个物品当成第n - 1个…

#include <iostream>
using namespace std;
const int MAX_N = 1005, MAX_V = 1005;
int N, V, f[MAX_N][MAX_V], v[MAX_N], w[MAX_N];
int main() {
	scanf("%d%d", &N, &V);
	for (int i = N; i >= 1; i--) {
		scanf("%d%d", &v[i], &w[i]);
	}
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= V; j++) {
			f[i][j] = f[i - 1][j];
			if (j >= v[i]) f[i][j] = max(f[i][j], f[i - 1][j - v[i]] + w[i]);
		}
	}
	
	int j = V;
	for (int i = N; i >= 1; i--) {
		if (j >= v[i] && f[i][j] == f[i - 1][j - v[i]] + w[i]) {
			printf("%d ", N - i + 1);
			j -= v[i];
		}
	}
}

广为流传的貌似是另一种写法，不改变输入顺序和输出，改变递推式推导的方向，从第一个往后推，也可以达到相同的效果。

#include <iostream>
using namespace std;
const int MAX_N = 1005, MAX_V = 1005;
int N, V, f[MAX_N][MAX_V], v[MAX_N], w[MAX_N];
int main() {
	scanf("%d%d", &N, &V);
	for (int i = 1; i <= N; i++) {
		scanf("%d%d", &v[i], &w[i]);
	}
	for (int i = N; i >= 1; i--) {
		for (int j = 1; j <= V; j++) {
			f[i][j] = f[i + 1][j];
			if (j >= v[i]) f[i][j] = max(f[i][j], f[i + 1][j - v[i]] + w[i]);
		}
	}
	
	int j = V;
	for (int i = 1; i <= N; i++) {
		if (j >= v[i] && f[i][j] == f[i + 1][j - v[i]] + w[i]) {
			printf("%d ", i);
			j -= v[i];
		}
	}
	return 0; 
}

3、背包问题求体积为V的方案数

把递推式的max改成相加即可。
01背包可参考：数字组合【求体积恰好为V的方案数】
完全背包可参考：买书【体积恰好是V求方案数】

4、背包问题求最优解(最大价值)的方案数

求的是取到最大价值的方案数
题目链接

开一个数组g[i, j]表示f[i, j]取最大值的方案数。

考虑是第i个物品取的价值大还是不取的价值大。
不取价值大：f[i, j] = f[i - 1, j] ，g[i, j] = g[i-1, j]
取价值大：f[i, j] = f[i-1, j-v[i]] + w[i] ，g[i, j] = g[i-1, j-v[i]]
取和不取一样大：g[i, j] = g[i-1, j] + g[i-1, j-v[i]]

注意这边g[i, j]只表示f[i, j]的方案数，条件是“前i个物品，体积恰好是j的最大价值方案数”，可能f[i', j']也能达到最优解，这种方案数记录在g[i', j']中，因此要把所有能达到最优解的f对应的g累加起来

#include <iostream>
using namespace std;
int N, V;
int f[1005], g[1005];
const int mod = 1e9 + 7;
int main() {
	scanf("%d%d", &N, &V);
	int v, w;
	g[0] = 1;
	int max_f = 0;
	for (int i = 1; i <= N; i ++) {
		scanf("%d%d", &v, &w);
		for (int j = V; j >= v; j --) {
			if (f[j] < f[j - v] + w) {
				f[j] = f[j - v] + w;
				g[j] = g[j - v];
			}
			else if(f[j] == f[j - v] + w) {
				g[j] = (g[j] + g[j - v]) % mod;
			}
		}
	}
	int ans = 0;
	for (int i = 0; i <= V; i ++) {
		if (f[i] == f[V]) ans = (ans + g[i]) % mod;
	}
	printf("%d\n", ans);
	return 0;
}
seth25
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
背包问题模板（背包九讲）
shiuxin的博客
10-15 155
01背包 题目：有 N 件物品和一个容量为 V 的背包。第 i 件物品的体积（费用）是 c[i]，价值是 w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。 代码如下 （一维数组） #include<stdio.h> #include<string.h> #include<algorithm> using namespace std; #define M 100010 int c[M],w[M],dp[M]; int main() {
背包问题求方案数
qq_43690454的博客
11-16 160
第二天叫醒我的不是闹钟，是梦想！ 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出 最优选法的方案数。注意答案可能很大，请输出答案模 109+7 的结果。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每行...
【动态规划】【背包模板】
loving coding
07-26 246
ACM模板void CompletePack(int cost,int weight,int V) {//完全背包 int i; for( i = cost; i <= V;i ++) dp[i] = max(dp[i],dp[i-cost]+weight); return ; }void ZeroOnePack(int cost,int weight,int
【动态规划】—— 背包模型
forever_bryant的博客
07-19 479
【动态规划】—— 背包模型
背包九讲_模板整理
这是我的笔记本，记录学习历程，分享学习经验，菜鸡一枚，感谢支持！
03-14 175
背包九讲,常用背包模板整理,代码模板,算法竞赛模板,80%代码,中高级写法
动态规划（DP）-背包问题算法详解背包九讲
01-12
动态规划（DP）——背包问题算法详解[背包九讲]
背包九讲——背包问题的详细分析
12-03
对背包问题进行细致地讲解和优化，看完会对动态规划算法有较深的了解
动态规划之背包九讲崔添翼版本
10-05
"动态规划之背包九讲崔添翼版本"是一份深入讲解背包问题的资料，其中涵盖了动态规划在背包问题中的应用。 背包问题是一个经典的优化问题，描述如下：假设我们有N件物品，每件物品有自己的重量Ci1和对应的收益Wi。...
01背包问题动态规划，背包问题介绍算法实现
01-21
01背包问题是一种经典的组合优化问题，主要涉及算法和动态规划。它的核心在于寻找最佳物品组合，以在不超过背包容量的限制下最大化物品的总价值。动态规划是解决这类问题的有效方法，因为它能够避免重复计算，通过...
基于Python使用递归和动态规划解决背包问题.zip
最新发布
05-10
在这个场景中，我们将专注于使用Python编程语言结合递归和动态规划的方法来解决0-1背包问题。 首先，让我们理解递归。递归是一种解决问题的方法，它通过调用自身来解决更小的问题。在背包问题中，我们可以定义一个...
背包九讲模板整理
fighting_yifeng的博客
03-28 291
1.01背包 1.1 题目 有N件物品和一个容量为V的背包。第i件物品的费用是w[i]，价值是v[i]，求将哪些物品装入背包可使价值总和最大。1.2 特点 每种物品仅有一件，可以选择放与不放。 1.3 基本的状态转移方程 f[i][j]= max(f[i − 1][j], f[i − 1][j − w[i]] + v[i]) 1.4 基本模板 for(int i = 0; i ...
动态规划 背包问题 模板
zpf1998的博客
11-08 137
背包九讲模板（部分） 背包九讲pdf资源 pdf下载 题目 题目链接第1-10题 01背包 cin>>n>>m; for(int i=0;i<n;++i){ cin>>v>>w; for(int j=m;j>=v;--j){ f[j]=max(f[j],f[j-v]+w); } } 完全背包 cin>>n>>m; fo
动态规划之01背包，完全背包，多重背包模板
唐唐唐唐人的博客
08-24 457
自己整理的模板，记录一下：#include <iostream> #include <vector> #include <deque> #include <algorithm>using namespace std;const int M = 500; const int N = 500;#pragma region"01背包问题" // 未优化版 int pack01(vector<int>& w
动态规划之背包问题的几种模板
R的博客
03-13 1894
背包模板，不懂的可以私信，欢迎指错
背包九讲（纯思路+模板）
weixin_45363113的博客
04-11 246
背包九讲 先循环物品，在循环体积，再循环决策。 01背包 完全背包 多重背包（两种优化，只会一种） 混合背包 二维费用背包 分组背包 有依赖性的背包问题 （1）.01背包 给n个物品，每个物品有价值Vi, 体积Wi。 给一个背包，总容量m。 问，背包可以装的最大价值（物品不可拆） #include<iostream> #include<cstdio> using na...
[模板练习]背包的方案数
今天的北宅依旧没有回家
12-21 297
原题链接原题链接是洛谷上的小A点菜。 比较简单的模板，概括起来就是f[j]=f[j]+f[j-a[i]]，即当放入第i件物品时，放入后会满的背包空间需要再加上不放入时的方案数。01背包#include<iostream> #include<cstdio> #include<cstring> #include<cmath> #include<algorithm> #include<queue> us
算法模板：动态规划之01背包【沈七】
只想和你一起进步
03-30 1175
讲解动态规划当中经典的01背包问题，以及对应例题的优质题解。
背包问题解题模板
furfur-jiang的博客
05-23 166
如何看出是背包问题？ 背包容量target和物品nums的类型可能是数，也可能是字符串 target可能题目已经给出(显式)，也可能是需要我们从题目的信息中挖掘出来(非显式)(常见的非显式target比如sum/2等) 选取方式有常见的一下几种：每个元素选一次/每个元素选多次/选元素进行排列组合 常见的背包类型主要有以下几种 1、0/1背包问题：每个元素最多选取一次 2、完全背包问题：每个元素可以重复选择 3、组合背包问题：背包中的物品要考虑顺序 4、分组背包问题：不止一个背包，需要遍历每个背包** 而
P1164 小A点菜 AC于2018.10.19
流年成沙的成长史
10-19 116
原题 题目背景 uim神犇拿到了uoi的ra（镭牌）后，立刻拉着基友小A到了一家……餐馆，很低端的那种。 uim指着墙上的价目表（太低级了没有菜单），说：“随便点”。 题目描述 不过uim由于买了一些辅（e）辅（ro）书，口袋里只剩M元(M≤10000)。 餐馆虽低端，但是菜品种类不少，有N种(N≤100)，第i种卖ai​元(ai​≤1000)。由于是很低端的餐馆，所以每种菜只有一份。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值