Java数据结构与算法----动态规划（背包篇）
1. 0/1背包
1.1.算法思路
0/1背包是动态规划、背包问题中最经典的问题啦！它主要的问题是：
给定n种物品、这n种物品的重量分别是
，价值分别是
，而你有一个容量为C的背包，请问如何求出所能拿的最大价值呢？
对于动态规划，我们先需要找到一条推导公式，然后确定边界：
我们设dp[i][j]为一个背包，表示前 i 个物品装入容器为 j 的背包中可以获得的最大价值。
我们可以推导出： dp[i] [j] = max(dp[i-1] [j] , dp[i-1] [j - ] + ) 也就是说，当前的dp值由装和不装入第i个物品来决定的。不装入第i个是：dp[i-1] [j] ，装入的话 j 要减去这个物品的重量也就是：
dp[i-1] [j - ] + 。
1.2.例题与代码
01背包问题
有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
第 i 件物品的体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。
接下来有 N 行，每行两个整数 vi , wi 用空格隔开，分别表示第 i 件物品的体积和价值。
输出格式
输出一个整数，表示最大价值。
数据范围
0 输入样例 输出样例： 题解： 优化： 其实可以用dp[] 来替代 dp[][]以节省空间，因为i只跟上一行有关系，跟更前面的没关系，所以用新的一行覆盖上一行就ok了。 完全背包和0/1背包只有一个区别，那就是0/1背包的物品数量只有1，只可以被装1次，而完全背包的物品数量无数，可以装多次。 在代码上，我们只需要将0/1背包的j循环换一下方向就行了： 完全背包问题 有 N种物品和一个容量是 V 的背包，每种物品都有无限件可用。 第 i种物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输入格式 第一行两个整数，N，V 用空格隔开，分别表示物品种数和背包容积。 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i种物品的体积和价值。 输出格式 输出一个整数，表示最大价值。 数据范围 0 输入样例 输出样例： 题解： 多重背包和完全背包、0/1背包只有一点区别，那就是多重背包设置了物品的数量了，（完全背包的物品有无数个，0/1背包的有一个）因此，我们需要在0/1背包的基础上加上数量的循环判断装与不装。而且它存在优化，我们在后面的优化会说到。 多重背包问题 I 有 N种物品和一个容量是 V 的背包。 第 i种物品最多有 si件，每件体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。 输入格式 第一行两个整数，N，V 用空格隔开，分别表示物品种数和背包容积。 接下来有 N 行，每行三个整数 vi,wi,si 用空格隔开，分别表示第 i 种物品的体积、价值和数量。 输出格式 输出一个整数，表示最大价值。 数据范围 0 输入样例 输出样例： 这个题的数量级只有100，不需要优化 优化： 对于多重背包，上面的做法是三重循环，复杂度肯定太高了啊，我们尝试把他变成0/1背包，怎么变成0/1背包呢？ 我们看：dp[j] = Math.max(dp[j],dp[j - k*weight[i]] + k*value[i]);这里的公式贼像0/1背包啊，我们尝试把count个物品用二进制表示： 假设：8个物品：二进制表示为 1000 ，对于装这个物品的使用情况会有：1 、2、3、4、5、6、7、8这8种情况，其实这些数字 可以由1 2 4 这三个数字组合成，对于n可以被分解成1,2,4,…,2^(k-1),n-2^k+1。然后把他们保存起来：进行0/1背包计算最大值就ok! 混合背包，所谓混合，就是包含了0/1背包、完全背包和多重背包，我们可以直接使用多重背包的二进制优化进行写。把01背包看作是数量为1的多重别抱，完全背包看成是数量为无数的多重背包就好了。 混合背包问题 有 N 种物品和一个容量是 V 的背包。 物品一共有三类： 每种体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。 输入格式 第一行两个整数，N，V ，用空格隔开，分别表示物品种数和背包容积。 接下来有 N 行，每行三个整数 vi,wi,si 用空格隔开，分别表示第 i 种物品的体积、价值和数量。 输出格式 输出一个整数，表示最大价值。 数据范围 0< N,V ≤1000 输入样例 输出样例： 二位费用背包其实就是在01背包的基础上再加上一个条件限制，比如在背包中加上体积、重量这两个限制，也就是变成二维了。我们需要把dp数组变成二维的，用来代表体积、重量的背包。 二维费用的背包问题 有 N 件物品和一个容量是 V 的背包，背包能承受的最大重量是 M。 每件物品只能用一次。体积是 vi，重量是 mi，价值是 wi。 求解将哪些物品装入背包，可使物品总体积不超过背包容量，总重量不超过背包可承受的最大重量，且价值总和最大。 输入格式 第一行三个整数，N,V,M，用空格隔开，分别表示物品件数、背包容积和背包可承受的最大重量。 接下来有 N 行，每行三个整数 vi,mi,wi，用空格隔开，分别表示第 i 件物品的体积、重量和价值。 输出格式 输出一个整数，表示最大价值。 数据范围 0 输入样例 输出样例： 分组背包和01背包的区别就是，给定的物品是有分组的，每一组的物品最多只可以用一种。我们可以循环遍历一下每一组物品，进行01背包的操作。 分组背包问题 有 N 组物品和一个容量是 V 的背包。 每组物品有若干个，同一组内的物品最多只能选一个。 求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行有两个整数 N，V，用空格隔开，分别表示物品组数和背包容量。 接下来有 N 组数据： 输出格式 输出一个整数，表示最大价值。 数据范围 0 输入样例 输出样例： 有依赖的背包问题 有 N 个物品和一个容量是 V 的背包。 物品之间具有依赖关系，且依赖关系组成一棵树的形状。如果选择一个物品，则必须选择它的父节点。 如下图所示： 如果选择物品5，则必须选择物品1和2。这是因为2是5的父节点，1是2的父节点。 每件物品的编号是 i ，体积是 vi，价值是 wi ，依赖的父节点编号是 pi 。物品的下标范围是 1…N1。 求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行有两个整数 N，V，用空格隔开，分别表示物品个数和背包容量。 接下来有 N 行数据，每行数据表示一个物品。 输出格式 输出一个整数，表示最大价值。 数据范围 1≤N,V≤100 父节点编号范围： 输入样例 输出样例： 挑战模式 在01背包的基础上，使用一个数组用来保存方案数，如果最大价值相同，那么加上方案数量 背包问题求方案数 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi ，价值是 wi 。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出 最优选法的方案数。注意答案可能很大，请输出答案模 109+7 的结果。 输入格式 第一行两个整数，N，V ，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每行两个整数 vi,wi 用空格隔开，分别表示第 i 件物品的体积和价值。 输出格式 输出一个整数，表示 方案数 模 109+7109+7 的结果。 数据范围 0 输入样例 输出样例： 背包问题求具体方案4 5
1 2
2 4
3 4
4 5
8import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Scanner;
/**
* @Author: stukk
* @Description: TODO
* @DateTime: 2023-04-12 0:19
**/
public class Main {
private static BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
private static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
public static void main(String[] args) {
int n,v;//物品数量、容积
int value[] = new int[1001];
int weight[] = new int[1001];
Scanner cin = new Scanner(System.in);
n = cin.nextInt();
v = cin.nextInt();
int dp[][] = new int[n+1][v+1];
for(int i = 1;i<=n;i++) {
weight[i] = cin.nextInt();
value[i] = cin.nextInt();
}
//输入完毕。
for(int i = 1;i<=n;i++) {
for(int j = 0;j<=v;j++){
if(j < weight[i]){
dp[i][j] = dp[i-1][j];
}
else{
dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j-weight[i]] + value[i]);
}
}
}
System.out.println(dp[n][v]);
}
}import java.util.*;
import java.math.*;
public class Main {
public static void main(String[] args) {
// TODO 自动生成的方法存根
int n,v;//物品数量、容积
int value[] = new int[10001];
int weight[] = new int[10001];
int dp[] = new int[10001];
Scanner cin = new Scanner(System.in);
n = cin.nextInt();
v = cin.nextInt();
for(int i = 1;i<=n;i++) {
weight[i] = cin.nextInt();
value[i] = cin.nextInt();
}
//输入完毕。
for(int i = 1;i<=n;i++) {
for(int j =v;j>=weight[i];j--) {
dp[j] = Math.max(dp[j],(dp[j-weight[i]]+value[i]));
}
}
System.out.println(dp[v]);
}
}2.完全背包
2.1.算法思路
2.2.例题与题解
输出最大价值。4 5
1 2
2 4
3 4
4 5
10import java.util.Scanner;
/**
* @Author: stukk
* @Description: TODO
* @DateTime: 2023-04-12 0:40
**/
public class Main {
public static void main(String[] args) {
Scanner cin =new Scanner(System.in);
int n = cin.nextInt();
int v = cin.nextInt();
int weight[] = new int[n+1];
int value[] = new int[n+1];
int dp[] = new int[v+1];
for(int i = 1;i <= n;i++){
weight[i] = cin.nextInt();
value[i] = cin.nextInt();
}
for(int i = 1;i<=n;i++){
for(int j = weight[i]; j<=v;j++){
dp[j] = Math.max(dp[j],dp[j-weight[i]] + value[i]);
}
}
System.out.println(dp[v]);
}
}3.多重背包
3.1.算法思想
3.2.例题与题解
输出最大价值。4 5
1 2 3
2 4 1
3 4 3
4 5 2
10import java.util.Scanner;
/**
* @Author: stukk
* @Description: TODO
* @DateTime: 2023-04-12 0:54
**/
public class Main {
public static void main(String[] args) {
Scanner cin =new Scanner(System.in);
int n = cin.nextInt();
int v = cin.nextInt();
int weight[] = new int[n+1];
int value[] = new int[n+1];
int count[] = new int[n+1];
int dp[] = new int[v+1];
for(int i = 1;i<=n;i++){
weight[i] = cin.nextInt();
value[i] = cin.nextInt();
count[i] = cin.nextInt();
}
for(int i = 1;i<=n;i++){
for(int j = v;j>=0;j--){
for(int k = 0;k<=count[i] && j >= k*weight[i] ;k++){
dp[j] = Math.max(dp[j],dp[j - k*weight[i]] + k*value[i]);
}
}
}
System.out.println(dp[v]);
}
}import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
/**
* @Author: stukk
* @Description: TODO
* @DateTime: 2023-04-12 1:14
**/
public class Main {
private static class stu{
int weight;
int value;
public stu(int weight, int value) {
this.weight = weight;
this.value = value;
}
}
public static void main(String[] args) {
Scanner cin =new Scanner(System.in);
int n = cin.nextInt();
int v = cin.nextInt();
int dp[] = new int[v+1];
List4.混合背包
4.1.算法思想
4.2.例题与题解
输出最大价值。
0< vi,wi ≤1000
−1≤ si ≤10004 5
1 2 -1
2 4 1
3 4 0
4 5 2
8import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
/**
* @Author: stukk
* @Description: TODO
* @DateTime: 2023-04-12 10:10
**/
public class Main {
private static class stu{
int weight;
int value;
public stu(int weight, int value) {
this.weight = weight;
this.value = value;
}
}
public static void main(String[] args) {
Scanner cin = new Scanner(System.in);
int n = cin.nextInt();
int v = cin.nextInt();
int dp[] = new int[v+1];
List5.二位费用背包
5.1.算法思想
5.2.例题与题解
输出最大价值。4 5 6
1 2 3
2 4 4
3 4 5
4 5 6
8
import java.util.Scanner;
/**
* @Author: stukk
* @Description: TODO
* @DateTime: 2023-04-12 10:56
**/
public class Main {
public static void main(String[] args) {
Scanner cin =new Scanner(System.in);
int n = cin.nextInt();
int v = cin.nextInt();
int m = cin.nextInt();
int vi[] = new int[n+1];
int weight[] = new int[n+1];
int value[] = new int[n+1];
for(int i = 1;i<=n;i++){
vi[i] = cin.nextInt();
weight[i] = cin.nextInt();
value[i] = cin.nextInt();
}
int dp[][] = new int[v+1][m+1];
for(int i = 1;i<=n;i++){
for(int j = v;j>=vi[i];j--){
for(int k = m;k>= weight[i];k--){
dp[j][k] = Math.max(dp[j][k],dp[j-vi[i]][k - weight[i]] + value[i]);
}
}
}
System.out.println(dp[v][m]);
}
}
6.分组背包
6.1.算法思想
6.2.例题与题解
每件物品的体积是 vij ，价值是 wij ，其中 i 是组号，j 是组内编号。
3 5
2
1 2
2 4
1
3 4
1
4 5
8import java.util.Scanner;
/**
* @Author: stukk
* @Description: TODO
* @DateTime: 2023-04-12 11:15
**/
public class Main {
public static void main(String[] args) {
Scanner cin =new Scanner(System.in);
int n = cin.nextInt();
int v = cin.nextInt();
int weight[][] = new int[101][101];
int value[][] = new int[101][101];
int s[] = new int[101];
int dp[][] = new int[101][101];
for(int i = 1;i<=n;i++){
s[i] = cin.nextInt();
for(int j = 1;j<=s[i];j++){
weight[i][j] = cin.nextInt();
value[i][j] = cin.nextInt();
}
}
for(int i = 1;i <= n;i++){
for(int j = 0;j<=v;j++){
dp[i][j] = dp[i-1][j];
for(int k = 1;k<=s[i];k++){
if(j >= weight[i][k]){
dp[i][j] = Math.max(dp[i][j],dp[i-1][j - weight[i][k]] + value[i][k]);
}
}
}
// for(int j = 1;j<=s[i];j++){
// for(int k = weight[i][j];k<= v;k++){
// dp[i][k] = Math.max(dp[i][k],dp[i-1][k-weight[i][j]] + value[i][j]);
// }
// }
}
System.out.println(dp[n][v]);
}
}
7.依赖背包
第 i 行有三个整数 vi,wi,pi ，用空格隔开，分别表示物品的体积、价值和依赖的物品编号。
如果 pi=−1，表示根节点。 数据保证所有物品构成一棵树。
1≤vi,wi≤100
5 7
2 3 -1
2 2 1
3 5 1
4 7 2
3 6 2
11
难度：困难
时/空限制：1s / 64MB
总通过数：15113
总尝试数：24316
来源：背包九讲
算法标签
import java.util.*;
/**
* @Author: stukk
* @Description: TODO
* @DateTime: 2023-04-12 20:48
**/
public class Main {
private static int weight[],value[],root,dp[][],n,v;
private static List8.背包方案数
4 5
1 2
2 4
3 4
4 6
2package 背包;
import java.util.Arrays;
import java.util.Scanner;
/**
* @Author: stukk
* @Description: TODO
* @DateTime: 2023-04-17 20:50
**/
public class 背包方案 {
public static void main(String[] args) {
Scanner cin =new Scanner(System.in);
int n = cin.nextInt();
int m = cin.nextInt();
int mod = 1000000007;
int weight[] = new int[n+1];
int value[] = new int[n+1];
for(int i = 1;i<=n;i++){
weight[i] = cin.nextInt();
value[i] = cin.nextInt();
}
int dp[] = new int[m+1];
long num[] = new long[m+1];
Arrays.fill(num,1);
for(int i = 1;i<=n;i++){
for(int j = m;j >= weight[i]; j--){
int pi = Math.max(dp[j],dp[j-weight[i]] + value[i]);
long cnt = 0;
if(pi == dp[j]){
cnt = (cnt %mod + num[j]%mod)%mod;
}
if(pi == (dp[j-weight[i]] + value[i])) {
cnt = (cnt%mod + num[j-weight[i]]%mod)%mod;
}
num[j] = cnt%mod;
dp[j] = pi;
}
}
System.out.println(num[m]);
}
}
9.求背包具体方案
import java.util.Arrays;
import java.util.Scanner;
/**
* @Author: stukk
* @Description: TODO
* @DateTime: 2023-04-17 21:26
**/
public class Main {
public static void main(String[] args) {
Scanner cin =new Scanner(System.in);
int n = cin.nextInt();
int m = cin.nextInt();
int weight[] = new int[n+1];
int value[] = new int[n+1];
for(int i = 1;i<=n;i++){
weight[i] = cin.nextInt();
value[i] = cin.nextInt();
}
int dp[][] = new int[n+2][m+2];
for(int i = n;i >= 1;i--){
for(int j = 0;j <= m; j++){
dp[i][j] = dp[i+1][j];
if(j >= weight[i])
dp[i][j] = Math.max(dp[i][j],dp[i+1][j-weight[i]] + value[i]);
}
}
int ans = m;
for(int i = 1;i<=n;i++){
if(ans >= weight[i] && dp[i][ans] == dp[i+1][ans - weight[i]] + value[i]){
ans -= weight[i];
System.out.print(i+" ");
}
}
}
}