精华内容
下载资源
问答
  • 背包问题贪心算法实现,简单易懂,初学者可参考
  • 0-1背包问题贪心算法

    2015-06-07 12:51:15
    算法课程的0-1背包问题贪心算法代码,含截图,经测试可用
  • 主要介绍了Python基于贪心算法解决背包问题,简单描述了贪心算法的概念、原理并结合实例形式分析了Python使用贪心算法解决背包问题的具体操作技巧,需要的朋友可以参考下
  • 贪心算法背包问题

    2018-10-31 17:03:09
    贪心问题中有很多典型的例子,此次背包问题,助大家理解该算法
  • 物品课分割的装载问题称为背包问题,物品不可分割的装载问题称为0-1背包问题。 #include #include using namespace std; //按性价比贪心策略 typedef struct three { double w; //重量 double v; //价值 double p...
  • 背包问题贪心算法求解

    万次阅读 多人点赞 2019-10-06 22:14:11
    题目 有一个背包背包容量是M=150。有7个物品,物品可以分割成任意大小。...这2类问题都具有最优子结构性质,极为相似,但背包问题可以用贪心算法求解,而0-1背包问题却不能用贪心算法求解。 求解步骤 用...

    题目

    有一个背包,背包容量是M=150。有7个物品,物品可以分割成任意大小。
    要求尽可能让装入背包中的物品总价值最大,但不能超过总容量。
    在这里插入图片描述

    思路

    具有最优子结构性质和贪心选择性质。只要是所有物品的总重量大于背包容纳量,那么背包一定能装满。注意背包问题与0-1背包问题的区别。
    这2类问题都具有最优子结构性质,极为相似,但背包问题可以用贪心算法求解,而0-1背包问题却不能用贪心算法求解。

    求解步骤

    用贪心算法解背包问题的基本步骤:首先计算每种物品单位重量的价值v[i]/w[i],然后,依贪心选择策略,将尽可能多的单位重量价值最高的物品装入背包。若将这种物品全部装入背包后,背包内的物品总重量未超过C,则选择单位重量价值次高的物品并尽可能多地装入背包。依此策略一直地进行下去,直到背包装满为止。

    代码实现

    #include <iostream>
    using namespace std;
    //按照单位重量的价值量大小降序排列
    void Sort(int n,float *w,float *v)
    {
        int i,j;
        float temp1,temp2;
        for(i=1;i<=n;i++)
        for(j=1;j<=n-i;j++)//冒泡排序
        {
            temp1=v[j]/w[j];
            temp2=v[j+1]/w[j+1];
            if(temp1<temp2)
            {
                swap(w[j],w[j+1]);
                swap(v[j],v[j+1]);
            }
        }
    }
    int main()
    {
        float w[101];//用来表示每个物品的重量
        float v[101];//用来表示每个物品的价值量
        float x[101];//表示最后放入背包的比例
        int n;//物品数
        float M;//背包最大容纳重量
        cin>>n>>M;
        //依次输入每件物品的重量和价值量
        for(int i=1;i<=n;i++)
            cin>>w[i]>>v[i];
        //按照单位重量的价值量大小降序排列
        Sort(n,w,v);
        int i;
        for(i=1;i<=n;i++)
            x[i]=0;//初始值,未装入背包,x[i]=0
        float c=M;//更新背包容纳量
        for(i=1;i<=n;i++)
        {
            if(c<w[i])  break;//不能完全装下
            x[i]=1;
            c=c-w[i];
        }
        if(i<=n)
            x[i]=c/w[i];
        //输出
        for(int i=1;i<=n;i++)
            cout<<"重量为"<<w[i]<<"价值量为"<<v[i]<<"的物品"<<"放入的比例为"<<x[i]<<endl;
        return 0;
    }
    
    

    在这里插入图片描述

    算的主要计算时间在于将各种物品依其单位重量的价值从大到小排序。因此,算法的计算时间上界为O(nlogn)。
    为了证明算法的正确性,还必须证明背包问题具有贪心选择性质。

    对于0-1背包问题,贪心选择之所以不能得到最优解是因为在这种情况下,它无法保证最终能将背包装满,部分闲置的背包空间使每公斤背包空间的价值降低了。事实上,在考虑0-1背包问题时,应比较选择该物品和不选择该物品所导致的最终方案,然后再作出最好选择。由此就导出许多互相重叠的子问题。这正是该问题可用动态规划算法求解的另一重要特征。
    实际上也是如此,动态规划算法的确可以有效地解0-1背包问题。

    展开全文
  • 使用贪心算法解决多重背包问题(物体可拆分)的具体C++代码
  • c语言-背包问题贪心算法

    千次阅读 2020-12-03 15:15:14
    //表示该号物品放在多少背包里 int order[MAX];//表示物品的序号,相当其名字 }Solution; Solution X; int m=15;//背包容量 int n=7;//物品数量 int p[]={10,5,15,7,6,18,3}; int w[]={2,3,5,7,1,4,1}; void ...
    
    #include<stdio.h>
    #define MAX 200
    
    typedef struct Solution
    {
        float x[MAX]; //表示该号物品放在多少背包里
        int order[MAX];//表示物品的序号,相当其名字
    
    }Solution;
    
    Solution X;
    int m=15;//背包容量
    int n=7;//物品数量
    int p[]={10,5,15,7,6,18,3};
    int w[]={2,3,5,7,1,4,1};
    
    
    void GreedyKnapsack(int weight[]){
        float cu;
        int i;
        cu=float(m);
        
        for(i=0;i<n;i++){
            if(weight[i]>cu)
                break;
            X.x[i]=1;
            cu=cu-weight[i];
        }
        if(i<n){
            X.x[i]=cu/weight[i];
        }
    }
    //按价值排序
    bool compare1(int i,int j){
        if((p[i]<p[j]))
            return true;
        else return false;
    }
    //按重量排序
    bool compare2(int i,int j){
        if((w[i]>w[j]))
            return true;
        else return false;
    }
    
    // 按价值/重量排序
    bool compare3(int i,int j){
        if((float)(p[i]/w[i]<p[i]/w[j]))
            return true;
        else return false;
    }
    void swap(int &a,int &b){
        int t=a;
        a=b;
        b=t;
    }
    
    void sort(int type){
        
        int i,j;
        for(i=0;i<n-1;i++){
            int k=i;
            for(j=i+1;j<n;j++){
                if(type==1){
                    if(compare1(k,j))
                        k=j;
                }
                else if(type==2){
                    if(compare2(k,j))
                        k=j;
                }
                else
                {
                    if (compare3(k,j))
                        k=j;   
                }
                if(k!=i){
                    swap(p[i],p[k]);
                    swap(w[i],w[k]);
                    swap(X.order[i],X.order[k]);
                }
                
            }
        }
    }
    
    void init(){
        for(int i=0;i<n;i++){
            X.order[i]=i;
            X.x[i]=0;
        }
    }
    
    void show()
    {
        float total=0,weight=0;
        for(int i=0;i<n;i++)
        {
        total+=p[i]*X.x[i];
        weight+=w[i]*X.x[i];
        printf("装入的包的序号:%d 装入的份量%.6f\n",X.order[i],X.x[i]);
        printf("\n 背包的总价值 fp:%.2f,背包的总质量 fw:%.2f\n",total,weight);
    
        }
    }
    void main()
    {
        for(int i=1;i<=3;i++)
        {
        printf("\t\t 策略%d:\n",i);
        printf("解向量 x%d:\n",i);
        init();
        sort(i);
        GreedyKnapsack(w);
        show();
        }
    } 
    
    
    展开全文
  • 实验三 0-1 背包问题贪心算法 实验代码 #include<stdio.h> int max(int a,int b) { if(a>b) return a; else return b; } void Knapsack(int *v,int *w,int *x,int c,int n, int m[8][100]) { int i,j; for(j=0;j;j+...
  • 贪心算法解决背包问题,用netbeans做的。百分百下载就可以直接运行。JAVA 源文件。
  • 一个贪心算法的比较简单的程序,经运行是可以使用的
  • 课程的随堂作业,C语言的,用dev就能运行,萌新代码,勿喷,仅仅帮助不想写作业的朋友方便一下,反正老师也不会仔细检查的
  • 贪心算法 背包问题 c语言 绝对无误 运行成功
  • 01背包问题贪心算法,详细解析,令你很快懂的01背包问题中的贪心算法思想
  • 贪心算法背包问题

    2014-08-18 15:56:11
    利用贪心算法,计算出一个背包里面最多能装下多少东西,
  • 已知有n种物品和一个可容纳M重量的背包,每种物品i的重量为 。假定将物品i的一部分 放入背包就会得到 的效益,这里, , 。显然,由于背包容量是M,因此,要求...现需解决的问题是,这些物品重量的和大于M,该如何装包。
  • 这是一个应用贪心算法解决背包问题的完整的程序,供大家参考!
  • 主要介绍了JS基于贪心算法解决背包问题,简单说明了贪心算法的概念、原理,并结合具体实例形式分析了JS使用贪心算法解决部分背包问题的具体操作技巧,需要的朋友可以参考下
  • 背包问题贪心算法

    2021-10-26 21:28:53
    经典的背包问题有两种: 1. 01背包问题-->01背包-动态规划_KING素清风的博客-CSDN博客 【01背包问题这里就不详细介绍了,感兴趣的可以看我的另一篇博客】 2.部分背包问题-->有一个背包,容量是C,有若干...

    经典的背包问题有两种:

            1. 01背包问题-->01背包-动态规划_KING素清风的博客-CSDN博客

                    【01背包问题这里就不详细介绍了,感兴趣的可以看我的另一篇博客】

            2.部分背包问题-->有一个背包,容量是C,有若干个物品,价值各不相同,

                                              重量也各不相同。接下来请你选择一部分物品装入背包,

                                              要保证不超过背包的容量的前提下,使背包中物体的总价值最大。

                                              允许选择一件物品的一部分。【与01背包的不同之处】

                    2.1  贪心算法:每次都做出对于目前情况最好的选择,注意这里说的使对于目前情况。

                                              也就是说寻求问题对于决策时刻的局部最有解。而不是对于整个问题。

                                              所以贪心算法往往只能得到最优解的近似解,对于有些问题使用贪心算                                            法就不太合适了。

                            贪心:哈哈,喜欢占小便宜。笑死

     贪心详解:贪心法通常一自顶而下的方式进行,分阶段工作,以迭代的作出相继的贪心选择。每做一次贪心选择就将所求问题简化为规模更小的子问题。在每一个阶段总是选择认为当前最好的方案,然后从小的方案推广到大的方案解决问题。

    解题步骤:

                    循环求解--->求出可行解的一个解元素-->由所有解元素组合成问题的一个可行解

    问题模拟:

            物品1-->价值:9  重量:4    

            物品2-->价值:3  重量:6

            物品3-->价值:1  重量:3

            物品4-->价值:6  重量:2

            物品5-->价值:5  重量:5

            假设背包的容量为:10

            一:计算性价比

                    物品1:2.55   

                    物品2:0.5

                    物品3:0.33

                    物品4:3

                    物品5:1

            二:将性价比最高的 物品 4 放入背包

                     C = 10 - 2 = 8

                     v  = 0 + 6 = 6

             三:将物品1放入背包

                        C = 8 -  4 = 4

                           V = 6 + 9 = 15

            四:将物品5的部分放入背包中

                        4 = 5x  -- >     x = 0.8

                         C = 4 - 5*0.8 = 0

                    V = 15+5*0.8 =  19

             

    展开全文
  • 【算法】贪心算法 背包问题 python

    千次阅读 2020-05-03 22:55:06
    贪心算法是一个只关注眼前利益的算法,看起来比较短视,没有长远眼光,但在某些时候会取得比较好的收益。 1 直接上代码 因为python中list自带排序算法,因此博主并没有写排序算法,看起来比较短 m = eval...

    博主自己手撸代码,若有错误,感谢指出  直接上代码

    目录

    0 贪心算法 

    1 代码

    2 结果分析


    0 贪心算法 

    贪心算法是一个只关注眼前利益的算法,看起来比较短视,没有长远眼光,但在某些时候会取得比较好的收益。

    1 代码

    因为python中list自带排序算法,因此博主并没有写排序算法,看起来比较短

    m = eval(input('可承载的最大重量:'))
    h = eval(input('宝物重量:'))
    v = eval(input('宝物价值:'))
    
    # 计算权重, 整合得到一个数组
    arr = [(i,v[i]/h[i], h[i], v[i]) for i in range(len(h))]
    
    # 按照list中的权重,从大到小排序
    arr.sort(key=lambda x:x[1], reverse=True)  # list.sort() list排序函数
    
    bagVal = 0
    bagList = []
    for i,w,h,v in arr:
        # 1 如果能放的下宝物,那就把宝物全放进去
        if w <= m:
            m -= h
            bagVal += v
            bagList.append(i)
        
        # 2 如果宝物不能完全放下,考虑放入部分宝物
        else:
            bagVal += m * w
            bagList.append(i)
            break
    
    print('\n排序后:',arr)
    print('能运走的最大价值:%.2f'%bagVal,'此时承载的宝物有:',bagList)
    """
    毛驴可承载的最大重量:10
    宝物重量:2,3,4,7
    宝物价值:1,3,5,9
    
    排序后: [(4, 1.2857142857142858, 7, 9), (3, 1.25, 4, 5), (2, 1.0, 3, 3), (1, 0.5, 2, 1)]
    能运走的最大价值:12.75 此时承载的宝物有: [4, 3]
    """

    2 结果分析

    指路博主的文 《【算法】动态规划 背包问题 python》

    同一个背包问题,对比两篇博文的结果,可以发现结果不一样。在动态规划中,选择的是4号和2号物品,最大价值为12。

    原因在于,动态规划中我们宝物不能切割,因此要选择重量加起来正正好的4号和2号物品。

    展开全文
  • 背包问题 贪心算法

    2009-05-11 18:10:07
    给定n种物品和一个背包。物品i的重量是Wi,其价值为Vi,背包的容量为C。应如何选择装入背包的物品,使得装入背包中物品的总价值最大?在选择物品i装入背包时,可以选择物品i的一部分,而不一定要全部装入背包,1≤i≤...
  • 算法分析与设计 用贪心算法实现背包问题的java实现
  • 证明贪心算法的结构 第一步:符合贪心选择的特性(Greedy Choice Property) 我们需要证明我们的第一个选择(贪心选择 Greedy Choice,First Choice)包含在某些最优解中 第二步:符合归纳法结构(Inductive ...
  • 0-1背包问题贪心算法)C语言源程序. 物品名称、物品效益、物品重量、物品的效益重量比等定义了物品的结构体。
  • 目录贪心算法与0-1背包问题贪心算法0-1背包问题解决策略算法实现初始化函数三种策略贪心算法比较函数主函数脚本文件运行结语致谢 贪心算法与0-1背包问题贪心算法解决0-1背包问题是算法界较为经典的一个问题,笔者...
  • 贪心算法贪心算法贪心算法贪心算 背包问题背包问题背包问题
  • 贪心算法编写的01背包问题 用c语言编写 附上实验结果及代码
  • 背包问题贪心算法

    万次阅读 2018-11-21 17:24:38
    贪心算法(又称贪婪算法)是指,在对问题求解时,总是做出在当前看来是最好的选择。也就是说,不从整体最优上加以考虑,他所做出的是在某种意义上的局部最优解。 贪心算法还是比较好理解的一个算法,以前我也是这样...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,816
精华内容 5,526
关键字:

背包问题贪心算法