用贪心算法实现的背包问题（java语言）

最新推荐文章于 2023-08-03 19:45:00 发布
最新推荐文章于 2023-08-03 19:45:00 发布
阅读量2.5k 收藏 3
点赞数
CC 4.0 BY-SA版权
分类专栏： J2SE基础 文章标签： 算法 java string ini 语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/snowflychen/article/details/2479399
本文介绍了一个背包问题的求解算法，通过实现物品类、背包类和冒泡排序类，完成从用户输入到最大价值计算的过程。

算法设计与分析课老师留的题目，分享出来希望能给和我一样是菜鸟的朋友当个参考，并期盼如果有高手看到能给些指点 ^_^b

源程序（最初的版本）

---------------------------------------------------------------------------------------------------------------------------------------------------


public class BagProblem {

    public static void main(String[] args) {
        Thing[] things = new Thing[3];
        things[0] = new Thing(10, 60);
        things[1] = new Thing(20, 100);
        things[2] = new Thing(30, 120);
        Bag bag = new Bag(50);
        System.out.println(bag.getsMaxValue(things));
    }

}


//背包类
class Bag {
    //maxWeight:背包的最大容量
    double maxWeight;
    
    Bag(double mw) {
        maxWeight = mw;
    }
    
    public double getsMaxValue(Thing[] things) {
        int n = things.length;
        double[] weights = new double[n];
        double[] values = new double[n];
        double[] parts = new double[n];
        
        for(int i = 0; i < n; i++) {
            weights[i] = things[i].weight;
            values[i] = things[i].value;
            parts[i] = things[i].part;
        }
        
        Thing[] thingsBeenSorted = new Thing[n];
        for(int i = 0; i < n; i++) {
            thingsBeenSorted[i] = new Thing(weights[i], values[i]);
        }
        BubbleSort.bubbleSort(thingsBeenSorted);
        
        double maxValue = 0;
        int i;
        for(i = 0 ; i < n; i++) {
            if(thingsBeenSorted[i].weight > maxWeight) {break;}
            thingsBeenSorted[i].part = 1;
            maxValue += thingsBeenSorted[i].value;
            maxWeight -= thingsBeenSorted[i].weight;
        }
        if(i < n) {
            thingsBeenSorted[i].part = maxWeight/thingsBeenSorted[i].weight;
            return maxValue += thingsBeenSorted[i].part * thingsBeenSorted[i].value;
        }
        return -1;
    }
    
}


//物品类
class Thing implements Comparable {
    //weight:物品的重量, value:物品的价值, 
    //part:物品被装入背包的部分占自身总体部分的百分比, vPerw:value与weight的比值
    double weight, value, part, vPerw;
    
    Thing(double w, double v) {
        weight = w;
        value = v;
        part = 0;
        vPerw = v/w;
    }

    public int compareTo(Object o) {
        if(vPerw > ((Thing)o).vPerw) {return 1;}
        if(vPerw < ((Thing)o).vPerw) {return -1;}
        return 0;
    }
    
}


//冒泡排序类(注意这里是按vPerw的大小降序排列的)
class BubbleSort {
    static void bubbleSort(Thing[] things) {
        Thing temp;
        for(int i = things.length - 1; i >= 1; i --) {
            for(int j = 0; j <= i - 1; j ++)    {
                if(things[j].compareTo(things[j+1]) < 0) {
                    temp = things[j];
                    things[j] = things[j+1];
                    things[j+1] = temp;
                }    
            }
        }    
    }
}

---------------------------------------------------------------------------------------------------------------------------------------------------

 

 

 

源程序（实现了由键盘输入背包和物品信息的版本）

---------------------------------------------------------------------------------------------------------------------------------------------------

import java.util.Scanner;


public class BagProblem {

    public static void main(String[] args) {
        
        Scanner input = new Scanner(System.in);
        int n = 0;
        System.out.println("please input the maxweight of bag");
        
        //定义背包的最大容量maxWeight
        Bag bag = null;
        if(input.hasNextInt()) {
            n = input.nextInt();
            bag = new Bag(n);
            System.out.println("please input the number of things");
        }
        
        //定义物品的数量num
        Thing[] things = null;
        int thingsNum = 0;
        if(input.hasNextInt()) {
            n = input.nextInt();
            thingsNum = n;
            things = new Thing[n];
            System.out.println("please input weight and value of thing " + 1);
        }
        
        //定义每个物品的重量weight, 价值value
        int i = 0;
        while(input.hasNextInt()) {
            int[] temp = new int[2];
            for(int j = 0; j < 2; j++){
                n = input.nextInt();
                temp[j] = n;
            }
            things[i] = new Thing(temp[0], temp[1]); 
            
            if(i < thingsNum - 1) {
                System.out.println("please input weight and value of thing " + (++i +1));
            }
            else break;
        }
        
        System.out.println(bag.getsMaxValue(things));
    
    }

}


//背包类
class Bag {
    //maxWeight:背包的最大容量
    double maxWeight;
    
    Bag(double mw) {
        maxWeight = mw;
    }
    
    public double getsMaxValue(Thing[] things) {
        int num = things.length;
        double[] weights = new double[num];
        double[] values = new double[num];
        
        for(int i = 0; i < num; i++) {
            weights[i] = things[i].weight;
            values[i] = things[i].value;
        }
        
        Thing[] thingsBeenSorted = new Thing[num];
        for(int i = 0; i < num; i++) {
            thingsBeenSorted[i] = new Thing(weights[i], values[i]); 
        }
        BubbleSort.bubbleSort(thingsBeenSorted);
        
        double maxValue = 0;
        int i;
        for(i = 0 ; i < num; i++) {
            if(thingsBeenSorted[i].weight > maxWeight) {break;}
            thingsBeenSorted[i].part = 1;
            maxValue += thingsBeenSorted[i].value;
            maxWeight -= thingsBeenSorted[i].weight;
        }
        if(i < num) {
            thingsBeenSorted[i].part = maxWeight/thingsBeenSorted[i].weight;
            return maxValue += thingsBeenSorted[i].part * thingsBeenSorted[i].value;
        }
        return -1;
    }
    
}


//物品类
class Thing implements Comparable {
    //weight:物品的重量, value:物品的价值, 
    //part:物品被装入背包的部分占自身总体部分的百分比, vPerw:value与weight的比值
    double weight, value, part, vPerw;
    
    Thing(double w, double v) { //, double p
        weight = w;
        value = v;
        part = 0;
        vPerw = v/w;
    }

    public int compareTo(Object o) {
        if(vPerw > ((Thing)o).vPerw) {return 1;}
        if(vPerw < ((Thing)o).vPerw) {return -1;}
        return 0;
    }
    
}


//冒泡排序类(注意这里是按vPerw的大小降序排列的)
class BubbleSort {
    static void bubbleSort(Thing[] things) {
        Thing temp;
        for(int i = things.length - 1; i >= 1; i --) {
            for(int j = 0; j <= i - 1; j ++)    {
                if(things[j].compareTo(things[j+1]) < 0) {
                    temp = things[j];
                    things[j] = things[j+1];
                    things[j+1] = temp;
                }    
            }
        }    
    }
}
P2240 【深基12.例1】部分背包问题【贪心】
ln2037的博客
09-05 1520
题目描述 阿里巴巴走进了装满宝藏的藏宝洞。藏宝洞里面有 N(N≤100)N(N \le 100)N(N≤100) 堆金币，第 iii 堆金币的总重量和总价值分别是 mi,vi(1≤mi,vi≤100)m_i,v_i(1\le m_i,v_i \le 100)mi​,vi​(1≤mi​,vi​≤100)。阿里巴巴有一个承重量为 T(T≤1000)T(T \le 1000)T(T≤1000) 的背包，但并不一定有办法将全部的金币都装进去。他想装走尽可能多价值的金币。所有金币都可以随意分割，分割完的金币重量价值比
Java、Android背包问题（一）——贪心算法
https://github.com/W4ited
11-26 1392
文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不
用贪心算法实现背包问题
11-04
算法分析与设计 用贪心算法实现背包问题的java实现
探究-贪心算法解决背包问题（Java实现）
10-10
探究-贪心算法解决背包问题（Java实现）
用贪心算法解背包问题Java实现
用贪心算法解背包问题时对单位重量物品价值排序Java实现
04-23 3803
用贪心算法解背包问题,给出的物体是无序的,需要我们按照物体的单位重量的价值进行排序.
贪心算法：如何用Java解决背包问题
我滴小博客
03-05 1384
这时候就需要一个背包来存放我们需要带的物品，而背包有一定的容量限制，我们需要在容量限制的情况下选择一些物品装进背包中。对于一般情况下的背包问题，该算法是相对高效的，因为它的时间复杂度与物品数量呈对数关系，而不是指数关系。但是，在某些特殊情况下，如物品数量非常多或物品的重量和价值非常接近，该算法的效率可能会受到影响。上述代码中，我们定义了一个包含5个物品的物品数组，每个物品有对应的重量和价值。我们还定义了一个容量为12的背包。从价值最高的物品开始选取，如果该物品可以放入背包，则将其放入背包，并计算剩余空间；
【趣学算法】Day3 贪心算法——背包问题
周小末天天开心的博客
10-28 4213
贪心算法——背包问题
java算法 0-1 背包问题贪心算法解决 netbeans
06-11
用贪心算法解决背包问题，用netbeans做的。百分百下载就可以直接运行。JAVA 源文件。
贪心算法_01背包问题_Java实现
weixin_30639719的博客
04-08 752
原文地址：http://blog.csdn.net/ljmingcom304/article/details/50310789 本文出自：【梁敬明的博客】 1.贪心算法 　　什么是贪心算法？是指在对问题进行求解时，总是做出当前看来是最好的选择。也就是说，不从整体最优上加以考虑，所得出的结果仅仅是某种意义上的局部最优解。因此贪心算法不会对所有问...
背包问题 贪心算法实现
06-27
背包问题的贪心算法实现，简单易懂，初学者可参考
贪心算法解决背包问题
04-05
已知有n种物品和一个可容纳M重量的背包，每种物品i的重量为 。假定将物品i的一部分 放入背包就会得到 的效益，这里， , 。显然，由于背包容量是M，因此，要求所有选中要装入背包的物品总重量不得超过M.。如果这n件物品的总重量不超过M，则把所有物品装入背包自然获得最大效益。现需解决的问题是，这些物品重量的和大于M，该如何装包。
java实现贪心算法，解决背包问题
寒风的博客
03-07 1313
背包问题是指有一个固定大小的背包，需要在一系列物品中选择一些放入背包中，以使得物品的总价值最大。每个物品有一个重量和一个价值，背包有一个最大容量，不能超过这个容量。
背包问题 贪心算法 java_JS基于贪心算法解决背包问题示例
weixin_32349711的博客
02-12 289
本文实例讲述了JS基于贪心算法解决背包问题。分享给大家供大家参考，具体如下：贪心算法：在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。寻找最优解的过程，目的是得到当前最优解部分背包问题：固定容积的背包能放入物品的总最大价值物品 A B C D价格 50 220 60 60尺寸 5 20 10 12比率 10 11 6 5按比...
Java描述贪心算法解决背包问题
u013803262的专栏
02-16 4208
思路: 首先将物品根据性价比排好序在一个集合里,性价比=价格/重量... 然后根据性价比从大到小依次依次放入背包,如果没办法放入这个物品的全部,就放入一部分,如果可以放入全量物品,就放入全量物品。 Main.java的代码 import java.util.ArrayList; import java.util.Collections; import java.util.Compar
部分背包的贪婪算法 java_使用JAVA实现算法——贪心算法解决背包问题
weixin_33788465的博客
02-24 643
packageBasePart;importjava.io.BufferedReader;importjava.io.FileInputStream;importjava.io.IOException;importjava.io.InputStreamReader;/*** 使用贪心算法解决背包问题* 背包问题：* 旅行者有背包容量m公斤* 现在有重量W1,W2,W...
用贪心算法实现的背包问题
思索的蜗牛的专栏
06-22 1330
Java code <!--Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->import java.util.Scanner;//用贪心算法实现的背包问题public class BagProblem
贪心算法 背包问题 java_贪心算法解背包问题
weixin_29055699的博客
02-12 1759
背包问题：与0-1背包问题类似，所不同的是在选择物品i装入背包时，可以选择物品i的一部分，而不一定要全部装入背包，1 <= i <= n。这2类问题都具有最优子结构性质，极为相似，但背包问题可以用贪心算法求解，而0-1背包问题却不能用贪心算法求解。基本步骤：1、算每种物品单位重量的价值Vi/Wi2、依贪心选择策略，将尽可能多的单位重量价值最高的物品装入背包3、若将这种物品全部装入背包后...
贪心算法求解背包问题
weixin_45817985的博客
08-03 912
在这里我们用贪心法来解决可切割物品的背包问题，首先选择贪心属性，比较所有物品的单价；将单价第一高的物品尽可能全部装入背包，如果背包容量还有剩余，则继续将单价第二高的物品尽可能装进背包…以此类推，就可以求出背包问题的最优解。贪心算法，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，算法得到的是在某种意义上的局部最优解。在这个问题中，可以使用结构体来储存物品及其价格与单价的信息，在这里使用选择排序按照单价对结构体成员进行排序。4.把子问题的局部最优解合成原来问题的一个解。
Java贪心算法在背包问题中的应用解析
- Java实现贪心算法：上述代码展示了如何使用Java语言实现贪心算法来解决分数背包问题，并计算背包能够获取的最大价值。 通过上述知识点的学习和代码示例，我们可以更深入地理解贪心算法在解决分数背包问题时的应用...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值