精华内容
下载资源
问答
  • c语言贪心问题 背包算法,希望对大家有所帮助。
  • #include<stdio.h> #define N 100 typedef struct bao{ int num; float w; float v; }; typedef struct avg{ int num; float val; float w; float v; }; struct bao b[N]; struct avg d[N];... void So
  • 贪心算法 背包问题 c语言 绝对无误 运行成功
  • c语言贪心算法

    2014-02-21 10:22:44
    c语言贪心算法,有背包问题等,附源代码,一份实验报告
  • 与0-1背包问题类似,所不同的是在选择物品i装入背包时,可以选择物品i的一部分,而不一定要全部装入背包,1≤i≤n。
  • 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();
        }
    } 
    
    
    展开全文
  • 贪心算法求解背包问题 #include<stdio.h> #define maxnumber 20 typedef struct node { float w; float v; int i; }Object; float find(Object wp[],int n,float M) { float x[maxnumber]; int i; float maxprice=0;...
  • 圣诞前夜讲点比较具有圣诞感觉的算法,背包问题算法,这里我写了经典算法和贪心算法两种解决方法,因为时间不多,所以给出的数组是已经排序的,因为贪心算法可能要用得到,经典算法因为是一个一个比较,因此排序也就...
    圣诞前夜讲点比较具有圣诞感觉的算法,背包问题算法,这里我写了经典算法和贪心算法两种解决方法,因为时间不多,所以给出的数组是已经排序的,因为贪心算法可能要用得到,经典算法因为是一个一个比较,因此排序也就没有那么重要了,可能两种算法的最终运行效果一样的,朋友们调试的时候记得修改我给出的测试数组,今天实在太忙了,贪心使用的排序算法没有写,留着以后给大家讲排序算法的时候使用吧,圣诞快乐,诸位朋友们。



    背包问题:就是现在有一个容量为PSIZE的背包,同时又有N件item,现在要求将这些item放入这个背包里面去,要求尽量放一定要求的item(比如按照大小的顺序),又要求放最多的item或者放的item权值之和要最大





    问题讲完,算法如下,C语言实现,另外回溯、动态规划的算法,有时间也会写上,今天

    实在太忙了,诸位朋友继续期待吧:



    /*背包问题之经典解法和贪心算法

    *code cg

    *2008 12 24

    *调试环境TC ,devC++

    */

    #include "stdio.h"

    #include "stdlib.h"

    #include "conio.h"

    #define N 5 /*定义需要放的物件数量*/

    #define PSIZE 150/*定义背包大小*/



    long item[N]={15,40,50,60,90};/*初始化物件数组,贪心算法要求大小已排序*/

    int freespace[N]={0};



    int classic() {/*经典算法*/

    long size = PSIZE;

    long used = 0;

    int i;

    for(i = N - 1 ; i >= 0 ; i--){

    if((size - used) >= item[i]){/*大小可以放入吗?*/

    used += item[i]; /*放入背包 已使用数加新物件的大小*/

    freespace[i] = 1;

    }

    else { /*大小太大*/

    freespace[i] = 0;

    }

    }/*for*/

    return 1;

    }



    int greedy(){/*贪婪算法*/

    int i;

    long size = PSIZE;

    long used = 0;

    for(i = N - 1 ; i >= 0 ; i--){/*先放大的物体,再考虑小的物体*/

    if( (used + item[i]) < sizebr>
    freespace[i] = 1;/*1表示放入*/

    used += item[i];/*背包剩余容量减少*/

    }

    else{

    freespace[i]=0;

    }

    }/*for*/

    if(size == used)/*返回*/

    return 1;

    else

    return 0;

    }



    void main()

    {

    int i;/*计数器*/

    for(i = 0 ; i < N ibr>
    if(i % 5 == 0 )

    printf("n");

    printf("%10ld" , item[i]);/*首先输入原始数据*/

    }/*for*/

    printf("nClassicn");

    if(classic()==1){/*经典算法*/

    printf("Result:n");

    for(i=0;i

    if(freespace[i] == 1){

    if(i % 5 == 0)

    printf("n");

    printf("%10ld" , item[i]);

    }/*if*/

    }/*for*/

    }/*if*/

    else {

    printf("nNo Resultn");

    }

    for(i = 0 ; i < N ibr>
    freespace[i]=0 ; /*清空freespace数组*/



    printf("nGreedyn");

    if(classic()==1){/*经典算法*/

    printf("Result:n");

    for(i=0;i

    if(freespace[i] == 1){

    if(i % 5 == 0)

    printf("n");

    printf("%10ld" , item[i]);

    }/*if*/

    }/*for*/

    }/*if*/

    else{

    printf("nNo Resultn");

    }

    system("PAUSE");

    }




    --------------------------------------------------------------------------------------
    - 版权声明:
    - 如在本页面内无特别说明,本文内容均为[李大仁博客]原创,本文版权归[李大仁博客]所有。
    - 欢迎转载,转载请务必在文章页面明显位置提供原文链接并注明出处。欢迎您在转载本文时保留本段声明。
    - 文章标题:背包问题贪心、回溯、动态规划、经典解法的两个经典解法
    - 独立博客:李大仁博客
    - 永久链接:http://www.lidaren.com/archives/263
    --------------------------------------------------------------------------------------
    以上内容由博客自动发布工具自动发布,最终显示内容和效果会与原文内容有所偏差,敬请谅解。
    展开全文
  • 所谓贪心算法是指,在对问题求解时,总是做出在当前看来是最好的选择。也就是说,不从整体最优上加以考虑,所做出的仅是在某种意义上的局部最优解。 贪心算法不是对所有问题都能得到整体最优解,但对范围相当广泛的...
    所谓贪心算法是指,在对问题求解时,总是做出在当前看来是最好的选择。也就是说,不从整体最优上加以考虑,所做出的仅是在某种意义上的局部最优解。
    贪心算法不是对所有问题都能得到整体最优解,但对范围相当广泛的许多问题他能产生整体最优解或者是整体最优解的近似解。
    贪心算法的基本思路如下:
    1.建立数学模型来描述问题。
    2.把求解的问题分成若干个子问题。
    3.对每一子问题求解,得到子问题的局部最优解。
    4.把子问题的解局部最优解合成原来解问题的一个解。
     部分背包问题:
         给定一个最大载重量为M的卡车和N种食品,有食盐,白糖,大米等。已知第 i 种食品的最多拥有Wi 公斤,其商品价值为Vi元/公斤,编程确定一个装货方案,使得装入卡车中的所有物品总价值最大。
        分析:因为每一个物品都可以分割成单位块,单位块的利益越大显然总收益越大,所以它局部最优满足全局最优,可以用贪心法解答。方法如下:
    (1)先将单位块收益按从大到小进行排序;
    (2)初始化背包的剩余体积和当前价值;
    (3)从前到后考虑所有物品:a.如果可以完全放入,当前价值加上物品总价值,剩余体积减去物品总体积;b.如果可以部分放进,当前价值加上物品价值*剩余体积,使剩余体积为0. 
    利用贪心策略解题,需要解决两个问题:
    一、确定问题是否能用贪心策略求解;一般来说,适用于贪心策略求解的问题具有以下特点:
    ① 可通过局部的贪心选择来达到问题的全局最优解。运用贪心策略解题,一般来说需要一步步的进行多次的贪心选择。在经过一次贪心选择之后,原问题将变成一个相似的,但规模更小的问题,而后的每一步都是当前看似最佳的选择,且每一个选择都仅做一次。
    ② 原问题的最优解包含子问题的最优解,即问题具有最优子结构的性质。在背包问题中,第一次选择单位质量最大的货物,它是第一个子问题的最优解,第二次选择剩下的货物中单位重量价值最大的货物,同样是第二个子问题的最优解,依次类推。
    二、如何选择一个贪心标准?正确的贪心标准可以得到问题的最优解,在确定采用贪心策略解决问题时,不能随意的判断贪心标准是否正确,尤其不要被表面上看似正确的贪心标准所迷惑。在得出贪心标准之后应给予严格的数学证明。
    贪心一般都伴随着使用排序
    C语言算法:
    #include <stdio.h>
    #include<stdlib.h>
    #define MAXSIZE 100 //假设物体总数
    #define M 20 //背包的载荷能力

    //算法核心,贪心算法
    void GREEDY(float w[], float x[], int sortResult[], int n)
    {
    float cu = M;
    int i = 0;
    int temp = 0;

    for (i = 0; i < n; i++)//准备输出结果
    {
    x[i] = 0;
    }

    for (i = 0; i < n; i++)
    {
    temp = sortResult[i];//得到取物体的顺序
    if (w[temp] > cu)
    {
    break;
    }

    x[temp] = 1;//若合适则取出
    cu -= w[temp];//将容量相应的改变
    }

    if (i <= n)//使背包充满
    {
    x[temp] = cu / w[temp];
    }

    return;
    }

    void sort(float tempArray[], int sortResult[], int n)
    {
    int i = 0, j = 0;
    int index = 0, k = 0;

    for (i = 0; i < n; i++)//对映射数组赋初值0
    {
    sortResult[i] = 0;
    }

    for (i = 0; i < n; i++)
    {
    float temp = tempArray[i];

    index = i;

    //找到最大的效益并保存此时的下标
    for (j = 0; j < n; j++)
    {
    if ((temp < tempArray[j]) && (sortResult[j] == 0))
    {
    temp = tempArray[j];
    index = j;
    }
    }

    //对w[i]作标记排序
    if (sortResult[index] == 0)
    {
    sortResult[index] = ++k;
    }
    }

    //修改效益最低的sortResult[i]标记
    for (i = 0; i < n; i++)
    {
    if (sortResult[i] == 0)
    {
    sortResult[i] = ++k;
    }
    }

    return;
    }

    //得到本算法的所有输入信息
    void getData(float p[], float w[], int *n)
    {
    int i = 0;

    printf("please input the total count of object: ");
    scanf("%d", n);

    printf("Please input array of p :\n");
    for (i = 0; i < (*n); i++)
    {
    scanf("%f", &p[i]);
    }

    printf("Now please input array of w :\n");
    for (i = 0; i < (*n); i++)
    {
    scanf("%f", &w[i]);
    }

    return;
    }

    void output(float x[], int n)
    {
    int i;

    printf("\n\nafter arithmetic data: advise method\n");
    for (i = 0; i < n; i++)
    {
    printf("x[%d]\t", i);
    }

    printf("\n");
    for (i = 0; i < n; i++)
    {
    printf("%2.3f\t", x[i]);
    }

    return;
    }

    int main()
    {
    float p[MAXSIZE], w[MAXSIZE], x[MAXSIZE];
    int i = 0, n = 0;
    int sortResult[MAXSIZE];

    getData(p, w, &n);

    for (i = 0; i < n; i++)
    {
    x[i] = p[i] / w[i];
    }

    sort(x, sortResult, n);

    GREEDY(w, x, sortResult, n);

    output(x, n);
    system("pause");

    }

    ======Ruby代码
    def sort_pw(count, p, w)
      s=Hash.new
      count.times do |i|
        s.store(i,p[i]/w[i].to_f)
      end
      seq=s.keys
      1.upto(seq.length-1) do |i|
        (seq.length-i).times do |j|
          if s[seq[j]]<s[seq[j+1]]
            seq[j],seq[j+1] = seq[j+1],seq[j]
          end
        end
      end
      seq
    end

    def greedy(max_weight, seq, w)
      rest=max_weight
      result=[]
      0.upto(seq.length-1) do |i|
        if rest>w[seq[i]]
          result[seq[i]]=rest/w[seq[i]]
          rest=rest%w[seq[i]]
        elsif rest<w[seq[i]]
          result[seq[i]]=rest/w[seq[i]].to_f
          rest=0
          break
        end
      end
          return result
    end

    def calculate_benifits(result,p)
      total_benifits=0
      0.upto(p.length-1) do |i|
        if result[i]==nil
          result[i]=0
        end
        total_benifits+=result[i]*p[i]
      end
      total_benifits
    end



    puts "please input the total count of object:"
    count=gets.chomp.to_i
    puts "#{count}"
    p=Array.new
    w=Array.new
    puts "Please input array of p:"
    count.times do |i| 
      p[i]=gets.chomp.to_i
    end
    puts "Now please input array of w :"
    count.times do |i|
      w[i]=gets.chomp.to_i
    end
    puts "Please input bearing capacity of the bag: "
    max_weight=gets.chomp.to_i
    seq=sort_pw(count, p, w)
    result= greedy(max_weight,seq, w)

    total_benefits=calculate_benifits(result,p)

    puts "In the following, we have #{count} kinds of items, 1 through #{count}.
    Each kind of item j has a value pj and a weight wj."
    0.upto(p.length-1) { |i| puts "p#{i+1}=#{p[i]}" }
    puts "-----------------------------------------"
    0.upto(w.length-1) { |i| puts "w#{i+1}=#{w[i]}" }
    puts "The maximum weight that we can carry in the bag is #{max_weight}. "

    puts "optimal solution is:"

    0.upto(result.length-1) { |i| puts "result#{i+1}=#{result[i]}" }
    puts "Total benifits is #{total_benefits}"




    本文转自 fsjoy1983 51CTO博客,原文链接:http://blog.51cto.com/fsjoy/169700,如需转载请自行联系原作者
    展开全文
  • 贪心算法 贪心算法求解当下的最优解,不从整体最优上加以考虑,他所做出的是在某种意义上的局部最优解。 问题描述 给定5种物品和容量为10的背包 物品的重量是w={2,2,6,5,4}, 其价值为v={6,3,5,4,6}, 用...

    算法思路

    贪心算法
    • 贪心算法求解当下的最优解,不从整体最优上加以考虑,他所做出的是在某种意义上的局部最优解。

    问题描述

    给定5种物品和容量为10的背包
    物品的重量是w={2,2,6,5,4},
    其价值为v={6,3,5,4,6},
    用贪心思想编程实现求解使得装入背包中物品的总价值最大的装包方案以及最终的最大价值。

    代码思路

    1. 定义及初始化相关变量

    #define BAG_SIZE 10 //背包容量
    #define THING_NUMBER 5 //物品数量
    
    struct thing  //结构体(单个物品)
    {
    	int value;			//此物品的价值
    	int weight;			//此物品的重量
    	double b = 1.0 * value / weight;//此物品的重量价值比
    }T[THING_NUMBER], temp;	//一个完整物品包T,一个临时变量
    
    int c_w = 0;			//当前的总重量,初始为0
    double max_value = 0;	//最大价值,初始为0
    
    //初始化题目物品
    T[0] = { 6,2 };
    T[1] = { 3,2 };
    T[2] = { 5,6 };
    T[3] = { 4,5 };
    T[4] = { 6,4 };
    

    2. 按照重量价值比排序

    for (int i = 0; i < THING_NUMBER; i++)
    		for (int j = 0; j < THING_NUMBER; j++)
    			if (T[i].b > T[j].b) {
    				temp = T[i];
    				T[i] = T[j];
    				T[j] = temp;
    			}
    

    3. 装物品

    • 装物品分为装整件和装散件
      • 整件:只要下一物品质量装入后小于背包容量,即可装入
      • 散件:当下一物品质量装入后大于背包容量,则装散件。
        • 装入质量:背包容量 - 当前背包容量
        • 新增价值:当前价值 + 新增价值
          • =当前价值 + 下一物品价值 / 装入的重量比
          • =当前价值 + 下一物品价值 / (下一物品质量 / (背包容量 - 当前背包容量))
    for(int i = 0;i< THING_NUMBER;i++)
    		if (c_w + T[i].weight < BAG_SIZE) {//装完整物品
    			c_w += T[i].weight; 
    			max_value += T[i].value;
    			printf("选择重量为:%d 价值为:%d 的物品\n", T[i].weight, T[i].value);
    		}else{								//装散件
    			max_value += T[i].value / (T[i].weight / (BAG_SIZE - c_w) * 1.0);
    			printf("选择重量为:%d  价值为:%d 拆分成重量为:%d,价值为:%f的物品\n\n",
    			T[i].weight, T[i].value,(BAG_SIZE - c_w), 
    			T[i].value / (T[i].weight / (BAG_SIZE - c_w) * 1.0));
    			
    			printf("最大价值为:%f\n", max_value);
    			break;
    		}
    

    总结

    将物品按 (质量价值比) 排序→装完整物品→装散件

    完整代码

    C语言代码

    #include<stdio.h>
    #define BAG_SIZE 10 //背包容量
    #define THING_NUMBER 5
    
    struct thing
    {
    	int value;
    	int weight;
    	double b = 1.0 * value / weight;
    }T[THING_NUMBER], temp;
    int main() {
    	int c_w = 0;
    	double max_value = 0;	
    
    	T[0] = { 6,2 };
    	T[1] = { 3,2 };
    	T[2] = { 5,6 };
    	T[3] = { 4,5 };
    	T[4] = { 6,4 };
    
    	printf("最佳的装包方案是:\n");
    	for (int i = 0; i < THING_NUMBER; i++)
    		for (int j = 0; j < THING_NUMBER; j++)
    			if (T[i].b > T[j].b) {
    				temp = T[i];
    				T[i] = T[j];
    				T[j] = temp;
    			}
    			;
    	for(int i = 0;i< THING_NUMBER;i++)
    		if (c_w + T[i].weight < BAG_SIZE) {
    			c_w += T[i].weight;
    			max_value += T[i].value;
    			printf("选择重量为:%d价值为:%d 的物品\n", T[i].weight, T[i].value);
    		}
    		else {
    			max_value += T[i].value / (T[i].weight / (BAG_SIZE - c_w) * 1.0);
    			printf("选择重量为:%d,价值为:%d 拆分成重量为:%d,价值为:%f 的物品\n", 
    			T[i].weight, T[i].value,(BAG_SIZE - c_w), 
    			T[i].value / (T[i].weight / (BAG_SIZE - c_w) * 1.0));
    
    			printf("最大价值为:%f\n", max_value);
    			break;
    		}
    	return 0;
    }
    

    运行结果

    在这里插入图片描述

    展开全文
  • #include "stdio.h"//参数:n表示是背包可以存放物品的种类//参数:指针p指向的数组是存放物品价值的数组//参数:指针q指向的数组是存放物品重量的数组static void sort(int n,float *p,float *q){ int i; int j; ...
  • 0-1背包问题贪心算法C语言源程序. 物品名称、物品效益、物品重量、物品的效益重量比等定义了物品的结构体。
  • 通过贪心算法和结构体,用价值率求解小数背包问题
  • 计算机算法 背包问题 贪心算法 c++ c语言编写
  • 贪心算法-背包问题2

    2016-10-10 21:48:04
    // 贪心算法-背包问题-解向量.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include using namespace std; #define N 3int flag = 0;//装进物品的总数标记typedef struct { int w;
  • 1.题目描述:——背包问题 有若干物品,每种物品的价值和重量各不相同,将物品装入一个容量有限的背包,如何选择装入的物品,使背包的价值最大。 2.题目分析: 要是背包中的物品价值最大,则需要在有限的重量中尽...
  • 问题描述:  给定n种物品和一个背包。物品i的重量为w[i],其价值为v[i],背包的容量为c。应如何选择装入 背包的物品,使得装入背包中的物品的总价值最大。... 背包问题:对于要装入背包中的物品,可以选择装
  • 贪心算法编写的01背包问题c语言编写 附上实验结果及代码

空空如也

空空如也

1 2 3
收藏数 48
精华内容 19
关键字:

c语言贪心算法背包问题

c语言 订阅