回溯法~0-1背包的实现

  1 package 背包;


import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class 背包 {
/*
 * 非递归回溯**********************************
 * 1.单位性价比，按高到第放入。
 * 2.需要变量~固有变量 ~背包容量，物品大小，物品价值，  （物品大小数组，物品价值数组）
 * 3.需要变量~判断变量~当前背包容量，当前背包价值，当前最优价值，剩余价值（性价比）
 * 4.根据性价比排列物品，降序排序物品。
 * 5.hashmap 用于确定物品id。并用于排序
 * 6.输出放入的物品时，应将id转化为原数组位置。
 * */
    static double c; //背包容量
    static int n;   //物品数量
    static double []p;//  物品价值
    static double []p1;// 重新排列的 物品价值
    static double []w;//物品大小
    static double []w1;//重新排列的物品大小
    static double cw; //当前容量
    static double cp; //当前价值
    static double bestp;//当前最优解
    static double []q; //性价比
    static double sp; //物品剩余价值
    static int[]x; //x[0:i-1]为当前路径
    static int[]bestx;//当前最优路径
    public static void main(String[] args) {
    
    
     Scanner sc = new Scanner(System.in);

        System.out.println("背包容量");
        c=sc.nextInt();
        System.out.println("物品数量");
        n=sc.nextInt();
        double w[]=new double[n];
        double p[]=new double[n];

        //初始化其他变量
         bestp=0;
         cw=0;
         cp=0;     
         
    
        
        System.out.println("物品大小");
        for(int i = 0 ; i<n;i++)
        {
            w[i]=sc.nextDouble();
        }
        System.out.println("物品价值");
        {
            for(int i = 0 ; i<n;i++)
            {
                p[i]=sc.nextDouble();
                        
            }
        }
        //初始化剩余价值    
        for(int i =0;i<n;i++)
        {
            sp+=p[i];
        }
        
        sc.close();

         xjb(p,w,n);
     
         
     

    }

    //初始化,判断性价比,按降序排列
    @SuppressWarnings("unchecked")
    public static void xjb (double []p,double[]w,int n)
    {
        //初始化 ,并降序排序,获得物品的id排序（用来判断物品的优先放入）
                double []q =new double[n];
            
                for(int i = 0 ; i<n;i++)
                {
                    q[i]=p[i]/w[i];            
                }
    
       final Map<Integer,Double> map = new HashMap<Integer,Double>();
       for(int i = 0;i<n;i++)
       {
           map.put(i,q[i]);           
       }
       @SuppressWarnings("rawtypes")
    ArrayList keys = new ArrayList(map.keySet());//得到key集合  
       
       //把keys排序，但是呢，要按照后面这个比较的规则
             Collections.sort(keys,new Comparator<Object>(){
        
                   public int compare(Object o1,Object o2){
                      
           //按照value的值降序排列，若要升序，则这里小于号换成大于号
                       if(Double.parseDouble(map.get(o1).toString())<Double.parseDouble(map.get(o2).toString()))
                           return 1;
                      
                       else if(Double.parseDouble(map.get(o1).toString())==Double.parseDouble(map.get(o2).toString()))
                           return 0;
                     
                       else
                           return -1;
                       }
                   }
             );
               System.out.println("***按照性价比排列物品,由大到小排列***"+keys);                 
    

            double w1[]=new double[n];
               double p1[]=new double[n];
        //根绝性价比重新排列物品大小数组。
         for(int j =0;j<n;j++)
         {
             
            w1[j]=w[(Integer) keys.get(j)];
         }
   
       //根绝性价比重新排列物品价值数组     
         for(int j =0;j<n;j++)
         {
            p1[j]=p[(Integer) keys.get(j)];
         }
         System.out.println(beibao01(w1,p1,keys));
    
    }
    

    @SuppressWarnings("rawtypes")
    public static double beibao01(double[]w1,double[]p1,ArrayList keys )
    {
    
        int i =0;
        int[]x=new int[n]; 
        int[]bestx=new int[n];
        
      while(true){
       
        while(i<n&&cw+w1[i]<=c) 
        {//当前空间+此次空间 <=背包容量
         
            //进入左子树
            x[i]=1;
            cw+=w1[i];
            cp+=p1[i];
            sp-=p1[i];
            i++;
        
          }
        if(i==n)   //到达叶子节点         ||c==cp 当背包满的时候退出~~
        {
            if(cp>bestp){   // 这里居然写反了...！！
            for(int j =0;j<n;j++)
            {                
                bestx[j]=x[j];    
                    
            }
            bestp = cp;                    
            }
        }
        else
        {  //既然怒右子树
            x[i]=0;
            sp-=w1[i];
            i++;    
        
        }
      
      
        while(cp+sp<=bestp)//当前价值+剩余价值>=当前最优解
        {
            i--;
        
            while(i>=0 && x[i]==0) //返回时，若不是第一层且 上一层没有放入载重品。
            {
                //从右子树返回
                sp+=w1[i];     //剩余载重恢复上一层数据
                i--;   //再次返回更上一层
                
            }
            if(i<0)  
            {//若返回至第一层。则，最优解即为bestw。
                
                
                for(int j =0;j<n;j++)
                {
                    if(bestx[j]==1)
                      System.out.println("***放入***"+"w["+keys.get(j)+"]");        
                }
                return bestp; 
            }
         
            x[i]=0; 
            cw-=w1[i];  //卸下载重
            cp-=p1[i]; //减少价值
            i++;  //进入循环， 判断是否 进入左子树
        
            //进入右子树   ，当返回至 x[i]=1时，既放入载重品，进入右子树，因为左子树已经判断不会有大于当前最优解的方法。
            
        }
       
        
    }
        
    }
}