数据结构之贪心算法（背包问题的思考）

来源：互联网发布：matlab2014b mac 编辑：程序博客网时间：2024/06/06 14:24
package com.lip.datastructure;  
/** 
 *贪心算法：装箱问题的思考 
 * @author Lip 
 *装箱问题可以是时间调问题的延伸，当一个箱子没有容积限制，那么就是时间调度问题 
 *在时间调度问题中：存在两个可以讨论的问题。1.平均最短时间 2.总的最短时间 
 *这两个问题都和装箱问题中问题如此类似。 
 */  
/* 
 * 上面是我理解的装箱问题，本来是想说背包问题的 
 * 背包问题的描述：有N件物品和一个容量为V的背包。第i件物品的重量是w[i]，价值是v[i]。 
 * 求解将哪些物品装入背包可使这些物品的重量总和不超过背包容量，且价值总和最大。 
 */  
/* 
 * 贪心算法可以解决装箱问题，也可以解决背包问题，但是由贪心算法求出的解的可能不是最优解。 
 * 如：事实上，作为一个理性人，我们都是贪心的。当你面对一堆金银珠宝的时候，你有一个背包，你的选择肯定会是优先选择性价比最高的珠宝。 
 * 那么，从这个角度来说，我们可以用贪心算法来解决背包问题，即使不是问题的最优解。但是，这个解却是一个理人人的通常选择的贪心 策略。 
 */  
public class Pack  
    {  
  
        public static void main(String[] args)  
            {  
                /***********************装箱问题********************************/  
                int []weight={8,7,5,4,4,3,3,2,2,2,1};  
                int []box={12,12,12,10};  
                int []result=loadInBox(Type.OFFLINE, box, weight);  
                  
                for(int i=0;i<box.length;i++)  
                    {  
                        System.out.println("第"+(i+1)+"号箱子货物：");  
                        print(weight, result, i+1);  
                        System.out.println();  
                    }  
//              /***********0-1背包问题**************/  
//              int []weight={2,3,4,6,2,5,4,3,8,1};  
//              int []value={7,8,13,20,17,9,12,15,5,5};  
//              int c=20;  
//              int []position=loadInPack(c, value, weight);  
//              int sum=0;  
//              int sumW=0;  
//              for(int i=0;i<position.length;i++)  
//                  {  
//                      if(position[i]!=0)  
//                          {  
//                            sumW+=weight[position[i]-1];  
//                            sum+=value[position[i]-1];  
//                            System.out.println(position[i]+"->("+weight[position[i]-1]+","+value[position[i]-1]+")");  
//                          }  
//                      else break;  
//                  }  
//              System.out.println("最大的收益为："+sum);  
//              System.out.println("有多少空间没有利用："+(c-sumW));  
                
  
            }  
        /***********************装箱问题********************************/  
        /** 
         * @param type  
         * @param box 箱子 
         * @param weight 货物重量 
         * @return 
         */  
        public static int[]loadInBox(Type type,int box[],int []weight)  
        {  
            int []result=new int[weight.length];  
            Sort.quickSort(weight);  
            int sum=0;  
            for(int i=0;i<weight.length;i++)  
                sum+=weight[i];  
            int sum2=0;//箱子总容积  
            for(int i=0;i<box.length;i++)  
                sum2+=box[i];  
            if(sum>sum2)//艹，箱子不够  
                return null;  
            if(type==Type.OFFLINE)//给每个箱子都分配一个最大的货物  
                {  
                    for(int i=weight.length-1,j=0;i>-1;i--)  
                        {  
                            int find=box.length;  
                            while(weight[i]>box[j])//不可以装  
                                {  
                                    j=(j+1)%box.length;  
                                    find--;  
                                    if(find==0)//箱子不够  
                                        {  
                                        System.out.println("------背包不够---------");  
                                          return null;  
                                        }  
                                }  
                            result[i]=j+1;  
                            box[j]-=weight[i];  
                            j=(j+1)%box.length;  
                        }  
                }  
            else if(type==Type.ONLINE)//先装一个箱子  
                {  
                   for(int i=0;i<box.length;i++)  
                       {  
                          //box[i] 箱子的当前剩余，也就是还可以装的货物  
                           for(int j=weight.length-1;j>-1;j--)//一直装，直到装满  
                              {  
                                  if(box[i]==0)//该箱子装满了  
                                      break;  
                                  if(result[j]==0&&weight[j]<=box[i])//该货物没有被装  
                                      {  
                                          box[i]-=weight[j];  
                                          result[j]=i+1;  
                                      }  
                              }  
                       }  
                }  
            return result;  
        }  
        public static void print(int []weight,int []result,int k)  
        {  
            for(int i=0;i<result.length;i++)  
                if(result[i]==k)  
                    System.out.print(weight[i]+" ");  
        }  
        /** 
         *  
         * @author Lip 
         * 解决装箱问题有两种方式，一种是联机，一种是脱机。 
         * 所谓联机就是将一个箱子完全放满货物后，再开始处理下一个箱子 
         * 脱机就是将所有的货物都读取进来，按照从大到小的顺序将货物分配给箱子，直到各个箱子都被装满 
         */  
        public enum Type  
        {  
            ONLINE,OFFLINE;  
        };  
        /**************************0-1背包问题（贪心算法）************************************/  
        /** 
         *  
         * @param c 背包容量 
         * @param value 每个物品的价值 
         * @param weight 每个物品的容积 
         */  
        /* 
         * 当使用贪心算法解决背包问题时，那么考虑到贪心策略，就是要保证当前选择是最好的。 
         * 那么另外一个参考量“性价比”就被引用，p=value/weight 
         * 一直选择性价比最高的物品放入到背包中，直至背包被放满 
         */  
        public static int[] loadInPack(int c,int[]value,int []weight)  
        {  
  
            double []price=new double[value.length];//性价比  
            int []position=new int[value.length];  
            int p=0;  
            for(int i=0;i<value.length;i++)  
                price[i]=(double)value[i]/weight[i];  
            //开始装了  
            while(c>0)  
                {  
                    double max=-1;  
                    int pos=-1;  
                    for(int i=0;i<price.length;i++)//找性价比最高的，且没有被装到背包中的  
                        {  
                            if(price[i]!=-1&&price[i]!=0&&max<price[i])  
                                {  
                                    max=price[i];  
                                    pos=i;  
                                }  
                        }  
                    if(pos==-1)//虽然剩下空间，但是再也找不到合适的了  
                        break;  
                    if(c>=weight[pos])  
                        {  
                            c-=weight[pos];  
                            price[pos]=-1;//已经装过  
                            position[p]=pos+1;  
                            p++;  
                        }  
                    else   
                        {  
                            price[pos]=0;//装不下，但是可以装比这个更小的  
                        }  
                }  
              
            return position;  
              
        }  
    }  
贪婪算法运行效果：
脱机装箱：
联机装箱：
贪心算法解决0-1背包问题：
阅读全文
0 0