背包问题
- 0-1背包问题 ：每个物品只有1件
- 完全背包问题：每个物品有无数件
- 多重背包问题：每个物品有不超过多少件的限制
- 混合背包问题：物品有的是1件，有的无数件，有的不超过多少件
1、0-1背包问题
题目描述：
有N件物品和一个容量是bagV的背包，每件物品只能使用一次。第 i件物品的体积是 v[i]，价值是 w[i]。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。
思路：
对于每一个物品，有两种结果：能装下或者不能装下。
- 如果不能装下，这时的最大价值和前i-1个物品的最大价值是一样的；
- 如果能装下，装了不一定大于当前相同体积的最优价值，所以要对装该商品与不装该商品得到的最大价值进行比较，取最大的那个。
设f[i][j]表示：背包容量为j时，前i个物品所能达到的最大价值。0<=j<=V
第i个商品体积为vi，价值为wi，则状态转移方程：
- j<vi， f[i][j] = f[i-1][j] //背包装不下此物品，最大价值不变，还是为前i-1的最大价值
- j>=vi，f[i][j] = max{f[i-1][j],f[i-1][j-vi]+wi} // 背包装得下，最大价值取装与不装该物品时同样达到该体积的最大价值
/** * 利用二维数组 * @param N N个物品 * @param bagV 背包体积为bagV * @param v 物品体积（v[i]表示第i个物品体积，v[0]=0） * @param w 物品价值（w[i]表示第i个物品价值，w[0]=0） */ public static int bag0_1(int N, int bagV, int[] v, int[] w) { //f[i][j]表示背包容量为j时前i个商品的最大价值 int[][] f = new int[N+1][bagV+1]; for(int i = 1; i <= N; i++) { for(int j = 0; j <= bagV; j++) { if(j < v[i]) f[i][j] = f[i-1][j]; else f[i][j] = Math.max(f[i-1][j], f[i-1][j-v[i]]+w[i]); } } return f[N][bagV]; }
用一维数组的话，设f[j]表示背包容量为j时的最大价值，状态转移方程：f[j] = max[f[j]，f[j-vi]+wi}
/** * 利用一维数组实现 * @param N N个物品 * @param bagV 背包体积为bagV * @param v 物品体积（v[i]表示第i个物品体积，v[0]=0） * @param w 物品价值（w[i]表示第i个物品价值，w[0]=0） */ public static int bag0_1(int N, int bagV, int[] v, int[] w) { //f[j]表示背包体积为j时最大价值 int[] f = new int[bagV + 1]; for(int i = 1; i <= N; i++) { for(int j = bagV; j >= v[i]; j--) f[j] = Math.max(f[j], f[j-v[i]]+w[i]); } return f[bagV]; }
注：如果要求恰好装满背包：
求法相同，不过初始化是除了f[1]初始化为0（背包容量为1时的最大价值为0），其他都初始化为负无穷
/** * 在恰好装满背包的情况下最多获取多少价值？ * 初始化时，除了f[i][1]为0外（第一列），其他全为负无穷 */ public static int fullBag0_1(int N, int bagV, int[] v, int[] w) { int[] f = new int[bagV+1]; //除了f[i][1]其他都为负无穷 for(int j = 2; j < bagV; j++) { f[j] = Integer.MIN_VALUE;//其他全为负无穷 } for(int i = 1; i <= N; i++) { for (int j = bagV; j >= v[i]; j--) f[j] = Math.max(f[j], f[j - v[i]] + w[i]); } int res = f[bagV]; if(res < 0) res = -1; return res; }
2、完全背包问题
题目描述：
有 N 种物品和一个容量是 bagV 的背包，每种物品都有无限件可用。第 i 种物品的体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。
思路：
设f[i][j]表示背包容量为j时，前i个物品所能达到的最大价值。0<=j<=bagV
第i个商品体积为vi，价值为wi，则状态转移方程：
- j<vi，f[i][j] = f[i-1][j] //背包装不下此物品，最大价值不变，还是为前i-1的最大价值
- j>=vi，f[i][j] = max{f[i-1][j],f[i-1][j-k*vi]+k*wi} //背包装得下，最大价值取装与不装该物品时同样达到该体积的最大价值，与0-1不同的是,可以装k个。
/** * 利用二维数组实现 * @param N N个物品 * @param bagV 背包体积为bagV * @param v 物品体积（v[i]表示第i个物品体积，v[0]=0） * @param w 物品价值（w[i]表示第i个物品价值，w[0]=0） */ public static int competeBag(int N, int bagV, int[] v, int[] w) { //f[i][j]表示背包容量为j时前i个商品的最大价值 int[][] f = new int[N+1][bagV+1]; for(int i = 1; i <= N; i++) { for(int j = 0; j <= bagV; j++) { if(j < v[i]){ f[i][j] = f[i-1][j]; }else{ for(int k = 1; k*v[i] <= j; k++) f[i][j] = Math.max(f[i-1][j], f[i-1][j-k*v[i]]+k*w[i]); } } } return f[N][bagV]; }
利用一维数组的话，设f[j]表示背包容量为j时的最大价值，状态转移方程：f[j] = max[f[j]，f[j-k*vi]+k*wi}
/** * 利用一维数组实现 * @param N N个物品 * @param bagV 背包体积为bagV * @param v 物品体积（v[i]表示第i个物品体积，v[0]=0） * @param w 物品价值（w[i]表示第i个物品价值，w[0]=0） */ public static int competeBag(int N, int bagV, int[] v, int[] w) { //f[j]表示背包容量为j时商品的最大价值 int[] f = new int[bagV+1]; for(int i = 1; i <= N; i++) { for(int j = 0; j <= bagV; j++) { for(int k = 1; k * v[i] <= j; k++) { f[j] = Math.max(f[j], f[j-k*v[i]]+k*w[i]); } } } return f[bagV]; }
优化代码：与0-1背包不同的是第二层循环j从小到大顺序遍历（0-1背包是从大到小逆序遍历）：
/** * 利用一维数组实现 * @param N N个物品 * @param bagV 背包体积为bagV * @param v 物品体积（v[i]表示第i个物品体积，v[0]=0） * @param w 物品价值（w[i]表示第i个物品价值，w[0]=0） */ public static int competeBag(int N, int bagV, int[] v, int[] w) { //f[j]表示背包容量为j时商品的最大价值 int[] f = new int[bagV+1]; for(int i = 1; i <= N; i++) { for(int j = v[i]; j <= bagV; j++) f[j] = Math.max(f[j], f[j-v[i]]+w[i]); } return f[bagV]; }
3、多重背包问题
题目描述：
有 N 种物品和一个容量是 bagV 的背包。第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。输出最大价值。
思路：
和完全背包类似，不同的是第二层循环j时多了一个对物品个数的限制。
/** * 利用一维数组实现 * @param N N个物品 * @param bagV 背包体积为bagV * @param v 物品体积（v[i]表示第i个物品体积，v[0]=0） * @param w 物品价值（w[i]表示第i个物品价值，w[0]=0） * @param s s[i]表示第i个物品最多有多少个 ，s[0]=0 */ public static int multipleBag(int N, int bagV, int[] v, int[] w, int[] s) { //f[j]表示背包容量为j时商品的最大价值 int[] f = new int[bagV+1]; for(int i = 1; i <= N; i++) { for(int j = 0; j <= bagV; j++) { for(int k = 1; k <= s[i] && k * v[i] <= j; k++) { f[j] = Math.max(f[j], f[j-k*v[i]]+k*w[i]); } } } return f[bagV]; }
利用二进制优化，转化为0-1背包问题：
一个数a，我们可以按照二进制来分解为 a=1+2+4+8……+2^n+剩下的数，我们把a拆成这么多项，可以证明，这么多项可以组合出1~a的每一个数。
不管最优策略选择几件第i种物品，总可以表示成若干件物品的和。利用二进制拆分将a拆成若干数字的和，假设拆成M个数字，则这样把原问题转化为物品数量为M的0-1背包问题
//先定义一个类来存放新商品 class Goods { int v; //体积 int w; //价值 public Goods(int v, int w) { this.v = v; this.w = w; } } ----------------------------------------------- /** * 二进制优化，转为0-1背包问题来实现 * @param N N个物品 * @param bagV 背包体积为bagV * @param v 物品体积（v[i]表示第i个物品体积，v[0]=0） * @param w 物品价值（w[i]表示第i个物品价值，w[0]=0） * @param s s[i]表示第i个物品最多有多少个 ，s[0]=0 */ public static int multipleBag(int N, int bagV, int[] v, int[] w, int[] s) { //存放新商品的体积、价值 ArrayList<Goods> list = new ArrayList<Goods>(); //s[i]拆为一些数的和，重新存放商品，二进制转换为0-1背包问题 for(int i = 1; i <= N; i++) { int ss = s[i]; for(int k = 1; k <= ss; k *= 2) { ss -= k; list.add(new Goods(k*v[i], k*w[i])); } //剩下的数 if(ss > 0) list.add(new Goods(ss*v[i], ss*w[i])); } //按照0-1背包问题求解 int[] f = new int[bagV+1]; for(Goods good : list) { for(int j = bagV; j >= good.v; j--) { f[j] = Math.max(f[j], f[j-good.v]+good.w); } } return f[bagV]; }
4、混合背包问题
有 N种物品和一个容量是 bagV的背包。物品一共有三类：
- 第一类物品只能用1次（01背包）；
- 第二类物品可以用无限次（完全背包）；
- 第三类物品最多只能用 si 次（多重背包）；
每种体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。输出最大价值。
这里我们给出输入输出格式：
输入格式:
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。
接下来有 N行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i种物品的体积、价值和数量。
si=−1 表示第 i种物品只能用1次；
si=0 表示第 i种物品可以用无限次；
si>0 表示第 i种物品可以使用 si 次；
输出格式:
输出一个整数，表示最大价值。输入样例:
4 5
1 2 -1
2 4 1
3 4 0
4 5 2
输出样例：8
思路：
将多重背包转换为0-1背包进行处理，所以最后只需要处理两种背包：0-1背包与完全背包。
//定义一个Goods类 class Goods { int v; //体积 int w; //价值 int s; //物品类型：-1、0、>0 public Goods(int v, int w, int s) { this.v = v; this.w = w; this.s = s; } } public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int N = sc.nextInt(); //N个物品 int bagV = sc.nextInt(); //背包容积为bagV //存储物品的体积和价值 int[] v = new int[N+1]; //体积 int[] w = new int[N+1]; //价值 int[] s = new int[N+1]; //物品类型：-1--只有1件、0--有无数件、>0--有这些件 for(int i = 1; i <= N; i++) { v[i] = sc.nextInt(); w[i] = sc.nextInt(); s[i] = sc.nextInt(); } System.out.println(mixtureBag(N, bagV, v, w, s)); } /* * s[i]=-1: 0-1背包 * s[i]=0 :完全背包 * s[i]>0 :多重背包 * 多重背包可以转换为0-1背包进行处理 */ public static int mixtureBag(int N, int bagV, int[] v, int[] w, int[] s) { //存放商品的 体积、价值、类型 ArrayList<Goods> list = new ArrayList<Goods2>(); for(int i = 1; i <= N; i++){ if(s[i] == -1 || s[i] == 0) list.add(new Goods(v[i], w[i], s[i])); else { //多重背包二进制优化转为0-1背包问题 int ss = s[i]; for(int k = 1; k <= s[i]; k *= 2) { ss -= k; list.add(new Goods(k*v[i], k*w[i], -1)); } if(ss > 0) list.add(new Goods(ss*v[i], ss*w[i], -1)); } } int[] f = new int[bagV+1]; for(Goods good : list) { //0-1背包 if(good.s == -1){ for(int j = bagV; j >= good.v; j--) f[j] = Math.max(f[j], f[j-good.v]+good.w); } //完全背包 else{ for(int j = good.v; j <= bagV; j++) f[j] = Math.max(f[j], f[j-good.v]+good.w); } } return f[bagV]; } }
5、二维费用的背包问题
题目描述：
有 N 件物品和一个容量是 V 的背包，背包能承受的最大重量是 M。每件物品只能用一次。体积是 vi，重量是 mi，价值是 wi。
求解将哪些物品装入背包，可使物品总体积不超过背包容量，总重量不超过背包可承受的最大重量，且价值总和最大。输出最大价值。
输入格式：
第一行两个整数，N，V，M，用空格隔开，分别表示物品件数、背包容积和背包可承受的最大重量。
接下来有 N 行，每行三个整数 vi，mi，wi，用空格隔开，分别表示第 i 件物品的体积、重量和价值。
输出格式
输出一个整数，表示最大价值。
输入样例
4 5 6 1 2 3 2 4 4 3 4 5 4 5 6输出样例：
8
public static void main(String[] args) { Scanner sc = new Scanner(System.in); int N = sc.nextInt(); //物品数 int bagV = sc.nextInt(); //背包体积 int bagM = sc.nextInt(); //背包重量 int[] v = new int[N+1]; int[] m = new int[N+1]; int[] w = new int[N+1]; for(int i = 1; i <= N; i++) { v[i] = sc.nextInt(); m[i] = sc.nextInt(); w[i] = sc.nextInt(); } System.out.println(bag2D(N, bagV, bagM, v, m, w)); }
public static int bag2D(int N, int bagV, int bagM, int[] v, int[] m, int[] w) { //f[i][j]表示背包容量为i、重量为j时的最大价值 int[][] f = new int[bagV+1][bagM+1]; for(int k = 1; k <= N; k++) //第k个物品 //都要倒序 for(int i = bagV; i >= v[k]; i--) for(int j = bagM; j >= m[k]; j--) f[i][j] = Math.max(f[i][j], f[i-v[k]][j-m[k]]+w[k]); return f[bagV][bagM]; }
6、分组背包问题
题目描述：
有 N 组物品和一个容量是 V 的背包。每组物品有若干个，同一组内的物品最多只能选一个。每件物品的体积是 vij，价值是 wij，其中 i是组号，j 是组内编号。
求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。输出最大价值。
输入格式
第一行有两个整数 N，VN，V，用空格隔开，分别表示物品组数和背包容量。
接下来有 NN 组数据：
- 每组数据第一行有一个整数 SiSi，表示第 ii 个物品组的物品数量；
- 每组数据接下来有 SiSi 行，每行有两个整数 vij,wijvij,wij，用空格隔开，分别表示第 ii 个物品组的第 jj 个物品的体积和价值；
输出格式
输出一个整数，表示最大价值。
输入样例
3 5 2 1 2 2 4 1 3 4 1 4 5输出样例：
8
public static void main(String[] args) { Scanner sc = new Scanner(System.in); //N组物品 int N = sc.nextInt(); //背包体积 int bagV = sc.nextInt(); //s[i]表示第i组有多少件商品 int[] s = new int[N+1]; //v[i][j]表示第i组第j件商品的体积 int[][] v = new int[N+1][]; //w[i][j]表示第i组第j件商品的价值 int[][] w = new int[N+1][]; for(int i = 1; i <= N; i++) {//第i组商品 s[i] = sc.nextInt(); v[i] = new int[s[i]+1]; w[i] = new int[s[i]+1]; for(int j = 1; j <= s[i]; j++) { v[i][j] = sc.nextInt(); w[i][j] = sc.nextInt(); } } System.out.println(groupBag(N, bagV, s, v, w)); }
//一组商品只能选一个，相当于0-1背包问题 public static int groupBag(int N, int bagV, int[] s, int[][] v, int[][] w) { //f[j]表示背包容量为j时的最大价值 int[] f = new int[bagV+1]; for(int i = 1; i <= N; i++){ for(int j = bagV; j >=0; j--) { //选第i组物品的第k件商品 for(int k = 1; k <= s[i]; k++) { if(j >= v[i][k]) f[j] = Math.max(f[j], f[j-v[i][k]]+w[i][k]); } } } return f[bagV]; }
7、背包问题求方案数
问题描述：
有 N件物品和一个容量是 V的背包。每件物品只能使用一次。第 i 件物品的体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最优选法的方案数。注意答案可能很大，请输出答案模 109+7 的结果。
输入格式：
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。
接下来有 N行，每行两个整数 vi,wi，用空格隔开，分别表示第 i件物品的体积和价值。输出格式：
输出一个整数，表示 方案数 模 109+7 的结果。输入样例:
4 5
1 2
2 4
3 4
4 6
输出样例：2
public static void main(String[] args) { Scanner sc = new Scanner(System.in); int N = sc.nextInt(); //N个物品 int bagV = sc.nextInt(); //背包容积为bagV //存储物品的体积和价值 int[] v = new int[N+1]; //体积 int[] w = new int[N+1]; //价值 for(int i = 1; i <= N; i++) { v[i] = sc.nextInt(); w[i] = sc.nextInt(); } System.out.println(numsOfBag(N, bagV, v, w)); } /**最优方案总数,指物品总价值最大的方案数。*/ public static int numsOfBag(int N, int bagV, int[] v, int[] w) { //f[j]表示背包容量为j时的最大价值 int[] f = new int[bagV+1]; //num[j]表示背包容量为j时的最大方案数 int[] num = new int[bagV+1]; Arrays.fill(num, 1);//f[]都初始化为1 final int mod = 10000007; for(int i = 1; i <= N; i++) { for(int j = bagV; j >= v[i]; j--) { //如果加入该商品价值更大，必然加入该商品，因为是必然，所以这样的方案数量不变 if(f[j] < f[j-v[i]]+w[i]){ num[j] = num[j-v[i]]; num[j] %= mod; } //如果加入该商品与不加的价值相等，那么加或不加都可以，都是一种方案，所以方案数相加 else if(f[j] == f[j-v[i]]+w[i]){ num[j] += num[j-v[i]]; num[j] %= mod; } //如果加入该商品价值更小，那么肯定不加，方案数保持num[i-1][j]即可 //统一更新f[j] f[j] = Math.max(f[j], f[j-v[i]]+w[i]); } } return num[bagV]; }
8、背包问题求具体方案
题目描述：
有 N件物品和一个容量是 V 的背包。每件物品只能使用一次。第 i 件物品的体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出字典序最小的方案。这里的字典序是指：所选物品的编号所构成的序列。物品的编号范围是 1…N。输入格式：
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。
接下来有 N行，每行两个整数 vi,wi，用空格隔开，分别表示第 i件物品的体积和价值。
输出格式：
输出一行，包含若干个用空格隔开的整数，表示最优解中所选物品的编号序列，且该编号序列的字典序最小。物品编号范围是 1…N。输入样例:
4 5
1 2
2 4
3 4
4 6
输出样例：1 4
public static void main(String[] args) { Scanner sc = new Scanner(System.in); int N = sc.nextInt(); //N个物品 int bagV = sc.nextInt(); //背包容积为bagV //存储物品的体积和价值 int[] v = new int[N+1]; //体积 int[] w = new int[N+1]; //价值 ///////因为要求字典序最小,我们把输入逆序，然后提供一个记录物品序号的数组index int[] index = new int[N+1]; int indexTemp = 0; ////输入逆序 for(int i = N; i >= 1; i--) { v[i] = sc.nextInt(); w[i] = sc.nextInt(); ///////// index[i] = ++indexTemp; } List<Integer> list = progectOfBag(N, bagV, v, w,index); for(Integer item : list) System.out.print(item + " "); } public static List<Integer> progectOfBag(int N, int bagV, int[] v, int[] w, int[] index) { //首先按0-1背包问题求最大价值，这里二维实现，f[i][j]表示背包容量为j时前i-1个物品的最大价值 int[][] f = new int[N+1][bagV+1]; for(int i = 1; i <= N; i++) { for(int j = 0; j <= bagV; j++) { if(j >= v[i]) f[i][j] = Math.max(f[i-1][j], f[i-1][j-v[i]]+w[i]); else f[i][j] = f[i-1][j]; } } //存方案 List<Integer> list = new ArrayList<Integer>(); //反推方案 int vol = bagV; //从最后一个往前推 for(int i = N; i >= 1; i--) { if(vol >= v[i] && f[i][vol] == f[i-1][vol-v[i]]+w[i]){ //说明选择了当前物品 list.add(index[i]); vol -= v[i]; } if(vol <= 0) break; } return list; }
9、一个类似背包问题的问题，求无价值的所有方案
题目描述：
假设有一个能装入总体积为bagV的背包和 N件体积分别为v1,v2 , … , vn的物品，能否从N件物品中挑选若干件恰好装满背包，即使v1+v2+…+vn=bagV，要求找出所有满足上述条件的解。
输入格式:
第一行两个整数，N,bagV，用空格隔开，分别表示物品数量和背包容积。
接下来一行有N个整数，用空格隔开，分别表示第 i件物品的体积vi。
输出格式:
输出具体方案输入示例：
6 10
1 8 4 3 5 2
输出：
1 4 3 2
1 4 5
8 2
3 5 2
注意：这个做法只适合N<32的情况，因为1<<32对int型变量会溢出。 1L<<x的话x的最大值为63
public static void main(String[] args) { Scanner sc = new Scanner(System.in); //物品个数 int N = sc.nextInt(); //背包体积 int bagV = sc.nextInt(); //物品体积 int[] v = new int[N]; for(int i = 0; i < N; i++) v[i] = sc.nextInt(); fill(v, N, bagV); } /* 用1到2^N的二进制来求解，若二进制数该位置是1,则将其取出求和: 1表示成选取状态， 0表示成未选取状态。 标记中有几个 1就是代表选取了几个数，然后再去遍历这些 1所有可能存在的排列方式，最后做一个判断，这个判断就是： 每一种排列方式，都代表着数组中不同位置的被选中的数的组合，所以这里就是将选中的这些数字进行求和运算，然后判断求出的和是不是等于bagV 。 */ public static void fill(int[] v, int N, int bagV) { //从1循环到2^N,相当于对v从00...01一直循环到11...11 for(int i = 1; i <= 1 << N; i++){ int sum = 0; String temp = ""; for(int j = 0; j < N; j++) { //用i与2^j进行位与运算，若结果不为0，则表示第j位不为0，从数组中取出第j个数 if((i & 1 << j) != 0) { sum += v[j]; temp += v[j] + " "; } } if(sum == bagV) System.out.println(temp); } }
参考：dd大牛的《背包九讲》
