[算法]背包问题（Java版）

最新推荐文章于 2023-04-17 21:57:51 发布

虚拟土壤

最新推荐文章于 2023-04-17 21:57:51 发布

阅读量584

点赞数 1

分类专栏：算法

本文链接：https://blog.csdn.net/weixin_42228338/article/details/96892887

版权

算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

参考博客：背包问题之回溯法，贪婪算法解法
参考博客：背包问题动态规划解法的讲解
参考博客：背包问题模板解法

背包问题的分类

一个背包总容量为V, 现在有N个物品, 第i个物品容量为weight[i], 价值为value[i], 现在往背包里面装东西, 怎样装才能使背包内物品总价值最大.主要分为3类：

0-1背包, 每个物品只能取0个,或者1个.
完全背包, 每个物品可以取无限次.
多重背包, 每种物品都有个数限制, 第i个物品最多可以为num[i]个.

背包问题之回溯法，贪婪算法解法(Java版)

（1）经典的0-1背包问题（无物品的价值）：

假设有一个能装入容量为C的背包和n件重量分别为w1,w2,,...,wn的物品，能否从n件物品中挑选若干件恰好装满背包,要求找出所有满足上述条件的解。当C=10,各件物品重量为{1,8,4,3,5,2}时，可以找到下列4组解：(1,4,3,2)、(1,4,5)、(8,2)和(3,5,2)。

根据这个问题的一个变形是：

已知一个数为C，一个长度为n的无序的数组，分别是数w1,w2,...,wn，能否从这n个数中找到若干个数使其和等于数C,要求找出所有满足上述条件的解。

解决思路:

本文采用的是回溯思想，利用栈的“后进先出”的特性，首先将物品排成一列，然后顺序选取物品装入背包，假设已选取了前i件物品之后背包还没装满，则继续选取第i+1件物品，若选该件物品的重量太大不能装入，则放弃而继续选取下一件，直至背包装满为止。但是如果在剩余物品中找不到合适的物品以填满背包，则说明“刚刚”装入背包的那件物品“不合适”，应该将它取出，再继续从它之后的物品中选取，如此重复，直至求得满足要求的解，或者无解为止。因为回溯的规则也是“后进先出”，所以采用栈这个数据结构。

/**
* 利用栈实现的回溯法
* @param data 物品重量
* @param value 背包的称重量
*/
private static void novalue(int[] data, int value){
    //利用栈实现回溯
    Stack<Integer> stack = new Stack<>();
    //物品的数量
    int n = data.length;
    int k = 0;
    do{
    while (value > 0 && k < n){
        //栈中保存数组的下标
        stack.push(k);
        //更新value的值
        value -= data[k];
        k++;
    }
    if (value == 0){
        stack.forEach((index)-> System.out.print(data[index]+" "));
        System.out.println();
    }
    //取得栈顶元素
    k = stack.peek();
    value += data[k];
    stack.pop();
    //从下一个数开始判断
    k++;
    }while (!(stack.isEmpty()&&k==n));
}

相似问题：给定一个仅包含正整数的非空数组，确定该数组是否可以分成两部分，要求两部分的和相等

思路：求数组元素的和sum,在数组中找到和为sum/2的数组子集，则剩下的数组元素和也为sum/2,如果sum%2不为0，直接放回false。

（2）经典的0-1背包问题（有物品的价值）：

给定n种物品和一个背包。物品i的重量是wi，其价值为vi，背包的容量为C。应该如何选择装入背包中的物品，使得装入背包中物品的总价值最大？

上面的两个问题都是0-1背包问题，因为隐含的信息是：对每种物品只有两种选择，即装入背包或者不装入背包。不能将物品装入多次，也不能只装入部分的物品。

解题思路：

其实可以采用问题（1）的解法，因为要使价值最大化，肯定也是尽可能多的往背包里装物品。只是此时不要求装满背包，而是在过程中不断比较每种情况的总价值，并找到总价值最大的选择方式。

/**
* @param data 物品的重量
* @param cost 物品的价值
* @param value 背包的承重量
*/
@SuppressWarnings("unchecked")
public static void solution(int [] data,int [] cost,int value){
    Stack<Integer> stack = new Stack<>();
    //纪录最大价值栈
    Stack<Integer> result = new Stack<>();
    int k = 0;
    int tempMaxValue = 0;
    int maxValue = Integer.MIN_VALUE;
    do {
        while (value > 0 && k < data.length){
            stack.push(k);
            value -= data[k];
            tempMaxValue += cost[k];
            k ++;
        }
        if (value == 0 && tempMaxValue > maxValue){
            //记录最大值
            maxValue = tempMaxValue;
            result = (Stack<Integer>) stack.clone();
        }
        //回溯
        k = stack.pop();
        value += data[k];
        tempMaxValue -= cost[k];
        if (tempMaxValue > maxValue){
            maxValue = tempMaxValue;
            result = (Stack<Integer>) stack.clone();
        }
        k ++;
    }while (!stack.isEmpty()||k<data.length);
    //输出结果
    System.out.println("最大值:"+maxValue);
    result.forEach((v)->{
        System.out.print(data[v]+" ");
    });
}

(3)完全背包, 每个物品可以取无限次.

这种背包问题可以用贪心算法求解，先计算每种物品单位重量的价值vi/wi;然后根据贪心策略，将可能多得单位重量价值最高的物品装入背包；依次使用这种策略，直至装满背包为止。

/**
* 完全背包问题
* 这种背包问题可以用贪心算法求解，先计算每种物品单位重量的价值vi/wi;然后根据贪心策略，将可能多得单位重量价值最高的物品装入背包；
* 依次使用这种策略，直至装满背包为止。
* @param data 物品重量
* @param value 背包承重量
* @param cost 物品价值
*/
private static void numberNoLimit(int [] data ,int value,int []cost){
    double[] unit = new double[data.length];
    //记录是否已经装入背包，以便找到下一个最大值
    boolean [] isPack = new boolean[data.length];
    for (int i = 0 ; i < data.length;i++){
        //这里乘以1.0解决类型转换问题
        unit[i] = cost[i]*1.0/data[i];
    }
    double maxUnit;
    int maxUnitIndex = -1;
    int maxCost = 0;
    while (value > 0) {
        maxUnit = -1;
        //找到最大的单位价值物品的下标
        for (int j = 0; j < data.length; j++) {
            if (!isPack[j] && (unit[j] > maxUnit)) {
                maxUnit = unit[j];
                maxUnitIndex = j;
            }
        }
        isPack[maxUnitIndex] = true;
        //尽量将此物品装入背包
        while (value >= data[maxUnitIndex]){
            maxCost += cost[maxUnitIndex];
            //更新价值
            value -= data[maxUnitIndex];
        }
    }
    System.out.println("最大价值为："+maxCost);
}

(4)多重背包

多重背包问题限定了一种物品的个数，解决多重背包问题，只需要把它转化为0-1背包问题即可。比如，有2件价值为5，重量为2的同一物品，我们就可以分为物品a和物品b，a和b的价值都为5，重量都为2，但我们把它们视作不同的物品。

/**
* 多重背包问题限定了一种物品的个数，解决多重背包问题，只需要把它转化为0-1背包问题即可。比如，有2件价值为5，重量为2的同一物品，
* 我们就可以分为物品a和物品b，a和b的价值都为5，重量都为2，但我们把它们视作不同的物品。
* @param data 物品的重量
* @param value 背包的承重量
* @param cost 物品的价值
* @param number 物品的个数
*/
private static void numberLimit(int [] data,int value,int [] cost,int [] number){
    //总物品数
    int sum = 0;
    for (int n:number){
        sum += n;
    }


    int [] dataNew = new int[sum];
    int [] valueNew = new int[sum];


    int start = 0;
    //重新构建物品重量，价值数组
    for (int r = 0 ; r < number.length;r++){
        for (int s = start;s < start+number[r]; s++){
            dataNew[s] = data[r];
            valueNew[s] = cost[r];
        }
        start += number[r];
    }


    for (int aDataNew : dataNew) {
        System.out.print(aDataNew + " ");
    }
    System.out.println();
    for (int aValueNew : valueNew) {
        System.out.print(aValueNew+ " ");
    }


    //利用0-1背包问题解决
    valueLimit(dataNew,value,valueNew);
}

背包问题的动态规划解法详解

背包问题是动态规划类求解的一个典型问题，我们要先找到该问题的局部解然后扩展到全局解。这里讲解的是0-1背包。先看一下情景，假如一个小偷携带者一个可以放10kg重的背包，潜入一户人家行窃，家里有4个物品，每个物品只有1个。即价值v[] = {10, 40, 30, 50}，重量w[] = {5, 4, 6, 3}。如果超出这个重量背包就会断，就没法带出，但是家里面有很多物品，他们对应着不同的重量和不同的价值，有的可能很轻但价值很高（比如珠宝），有的很重但价值不高，要在背包重量有限的情况下收益最大，这种问题直接看和思考，在数量不多的情况下可以找到最佳的组合，但是代码该如何实现呢？先构建一个二维数组V[N][W]，行代表当前重量，列代表前?个物品，填充的数值即此时的价值，而且是当前情况下的最大价值。

	1	2	3	4	5	6	7	8	9	10
item0	0	0	0	0	0	0	0	0	0	0
item1
item2
item3
item4

如表，此时行列均为0，即第0列代表重量为0时的情况，第0行代表放0个物品的时候的情况。然后我们从第1行开始继续填值，第一行代表前1个物品的情况，也就是只有第一个物品，第一个物品重5，则当前背包容量>=5时候才能放入，即第1行第1，2，3，4列价值均为0，因为此时背包无法容纳物品1。而第6列时，除了物品1还剩余1kg，但是此时是第1列，只考虑前1个物品，因此没有其余物品能放入，后面均为10。

	1	2	3	4	5	6	7	8	9	10
item0	0	0	0	0	0	0	0	0	0	0
item1	0	0	0	0	10	10	10	10	10	10
item2
item3
item4

按照这种规则继续放入第2行，此时有2个物品，重量分别为5和4，价值为10和40，在第2行的第1，2，3列中，背包容量小于这2个物品，因此无法放入，价值为0。在第4列中，出现问题了，我们现在多了一个重量为4的物品，可以放入，但是到底该不该放入呢？这时候就是解决问题的关键，我们要考虑局部最优解，在背包为4的时候，如果放入，价值是40，不放入，那么物品1也放不进去，价值为0，即与他的相同列前一行进行比较，所以这时候需要放入物品2。第5列的时候，代表当前背包能容纳5kg，已放入4kg，另一个物品重5kg，因此在4+5=9kg之前，都只能放入物品2，最大价值为40。第9列时可以放入物品1，此时背包最大价值为当前已放入价值+可容纳剩余容量的价值=50，大于其前一行的最大价值10，因此，填充如下：

	1	2	3	4	5	6	7	8	9	10
item0	0	0	0	0	0	0	0	0	0	0
item1	0	0	0	0	10	10	10	10	10	10
item2	0	0	0	40	40	40	40	40	50	50
item3
item4

依次类推，可补充完全如下，注意第3行第9列与第10列，第9列情形和上一行类似，此时有3个物品，但是在背包容量为9时，只能放入物品1（5kg）和物品2（4kg），这就是此时的最优解。但是第10列时，此时背包容量为10，在没有物品3的时候最优解是50，可是此时，最优解是物品2和物品3放入，因为他们的价值大于50，因此第10列为70。

	1	2	3	4	5	6	7	8	9	10
item0	0	0	0	0	0	0	0	0	0	0
item1	0	0	0	0	10	10	10	10	10	10
item2	0	0	0	40	40	40	40	40	50	50
item3	0	0	0	40	40	40	40	40	50	70
item4	0	0	50	50	50	50	90	90	90	90

第4行第10列即我们想要的全局最优解，此时将局部扩大到全部。返回它即得到最优解。

背包问题解法模板（Java实现）

简单背包：

package beibao;
 
import java.util.Scanner;
/*
* 有n件物品和容量为m的背包 给出i件物品的重量以及价值 求解让装入背包的物品重量不超过背包容量 且价值最大
特点  但它的特点是每个物品只能选用一次
* */
 
public class situation01 {
    //01背包
    public static void main(String args[]){
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();//物品的总数量
        int m = scanner.nextInt();//背包的重量
        int a[] = new int[50001];//重量
        int b[] = new int[50001];//价值
        for (int i=1;i<=n;i++){
            a[i] = scanner.nextInt();
            b[i] = scanner.nextInt();
        }
        int f[] = new int[50001];
        for (int i=1; i<=n; i++){
            for (int j=m; j>=a[i]; j--){//完全背包只修改了这一句的顺序，其余不变for(int j=a[i]; j<=m; j++)
                if (f[j-a[i]]+b[i]>f[j])//多重背包就是在a[i]和b[i]前面加了数量
                    f[j] = f[j-a[i]]+b[i];
            }
        }
        System.out.println(f[m]);
    }
}

完全背包：

package beibao;
 
import java.util.Scanner;
 
/*
* 有n件物品和容量为m的背包 给出i件物品的重量以及价值 求解让装入背包的物品重量不超过背包容量 且价值最大
特点 题干看似与01一样 但它的特点是每个物品可以无限选用
* */
public class situation02 {
     public static void main(String args[]){
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();//物品的数量
        int m = scanner.nextInt();//背包的重量
        int a[] = new int[50001];
        int b[] = new int[50001];
        for (int i=1;i<=n;i++){
            a[i] = scanner.nextInt();
            b[i] = scanner.nextInt();
        }
        int f[] = new int[50001];
        for (int i=1; i<=n; i++){
            for (int j=a[i]; j<=m; j++){//完全背包只修改了这一句的顺序，其余不变for(int j=a[i]; j<=m; j++)
                if (f[j-a[i]]+b[i]>f[j])
                    f[j] = f[j-a[i]]+b[i];
            }
        }
        System.out.println(f[m]);
    }
}

多重背包：

package beibao;
 
import java.util.Scanner;
 
import static sun.swing.MenuItemLayoutHelper.max;
 
public class situation03 {
    /*
    * 多重背包
    * 每件物品可以选择有限的次数
    * */
    public static void main(String args[]){
        Scanner scanner = new Scanner(System.in);
        int m = scanner.nextInt();//背包的重量
        int n = scanner.nextInt();//物品的总数量
        int[] a = new int[10001];//重量
        int[] b = new int[10001];//价值
        int[] c = new int[10001];//数量
        for (int i=0; i<n; i++){
            a[i] = scanner.nextInt();
            b[i] = scanner.nextInt();
            c[i] = scanner.nextInt();
        }
        int f[] = new int[10001];
        for (int i=1; i<=n; i++){
            for (int j=m; j>=0; j--){
                for (int k=0; k<=c[i]; k++){
                    if (j-k*a[i]<0) break;
                    f[j]= max(f[j],f[j-k*a[i]]+k*b[i]);
                }
            }
        }
        System.out.println(f[m]);
    }
}

虚拟土壤

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
[算法]背包问题（Java版）

参考博客：背包问题之回溯法，贪婪算法解法参考博客：背包问题动态规划解法的讲解参考博客：背包问题模板解法背包问题的分类一个背包总容量为V, 现在有N个物品, 第i个物品容量为weight[i], 价值为value[i], 现在往背包里面装东西, 怎样装才能使背包内物品总价值最大.主要分为3类：0-1背包, 每个物品只能取0个,或者1个. 完全背包, 每个物品可以取无限次. 多重背...
复制链接

扫一扫

专栏目录