回溯法 揹包問題

給定n種物品和一個容量爲C的揹包，物品i的重量是wi，其價值爲vi，揹包問題是如何選擇裝入揹包的物品，使得裝入揹包中物品的總價值最大?

貪心算法描述：

1.改變數組w和v的排列順序，使其按單位重量價值v[i]/w[i]降序排列；

     2.將數組x[n]初始化爲0； //初始化向量

     3.   i=1;

     4.循環直到（w[i]>C);

         4.1    x[i]=1;

         4.2    C=C-w[i];

         4.3     i++;

    5.   x[i]=C/w[i];

KnapSack1.java                                  //貪心算法

import java.util.*;

public class KnapSack1
{
 public static void main(String[] args)
 {
  Scanner in=new Scanner(System.in);
  System.out.println("Please enter the number of objects(請輸入物品的數量):");
  int n=in.nextInt();
  int[] w=new int[n];
  int[] v=new int[n];
  System.out.println("Now,please enter the weight of these objects(現在請輸入這些物品的重量):");
  for(int i=0;i<n;i++)
  {
   w[i]=in.nextInt();
  }
  System.out.println("Now,please enter the value of these objects(現在請輸入這些物品的價值):");
  for(int i=0;i<n;i++)
  {
   v[i]=in.nextInt();
  }
  System.out.println("Now,please enter the capacity of the pack(現在請輸入揹包的容量):");
     int c=in.nextInt();
     /**
      *按單位重量價值r[i]=v[i]/w[i]降序排列
      */
     double startTime=System.currentTimeMillis();
  double[] r=new double[n];
  int[] index=new int[n];
  for(int i=0;i<n;i++)
  {
   r[i]=(double)v[i]/(double)w[i];
   index[i]=i;
  }
  double temp=0;
  for(int i=0;i<n-1;i++)
  {
   for(int j=i+1;j<n;j++)
   {
    if(r[i]<r[j])
    {
     temp=r[i];
     r[i]=r[j];
     r[j]=temp;
     int x=index[i];
     index[i]=index[j];
     index[j]=x;
    }
   }
  }
  /**
   *排序後的重量和價值分別存到w1[]和v1[]中
   */
  int[] w1=new int[n];
  int[] v1=new int[n];
  for(int i=0;i<n;i++)
  {
   w1[i]=w[index[i]];
   v1[i]=v[index[i]];
  }
  System.out.println (Arrays.toString(w1));
  System.out.println (Arrays.toString(v1));
  /**
   *初始化解向量x[n]
   */
  int[] x=new int[n];
  for(int i=0;i<n;i++)
  {
   x[i]=0;
  }
  /**
   *求解並打印解向量
   */
  for(int i=0;i<n;i++)
  {
   if(w1[i]<c)
   {
    x[i]=1;
    c=c-w1[i];
   }
  }
  System.out.println("The solution vector is(解向量是):"+Arrays.toString(x));
  /**
   *根據解向量求出揹包中存放物品的最大價值並打印
   */
  int maxValue=0;
  for(int i=0;i<n;i++)
  {
   if(x[i]==1)
    maxValue+=v1[i];
  }
  double endTime=System.currentTimeMillis();
  System.out.println("Now,the largest values of objects in the pack is(揹包中物品的最大價值爲):"+maxValue);
  System.out.println("Basic Statements take(基本語句用時) "+(endTime-startTime)+" milliseconds!");
 }
}

***********************************************************************************************

回溯算法描述：

1.將各物品按單位重量價值從大到小排序；

     2.bestP=0;

     3.BackTrack(1);

     4.輸出揹包的最大值bestP;

     BackTrack(int i)

       1.   if(i>n){

                     if(bestP<cp) bestP=cp;

                     return;

               }

       2.若（cw+w[i]<=C,則       //進入左子樹            

             2 .1   cw=cw+w[i];

             2.2    cp=cp+p[i];

             2.3    BackTrack(i+1);

             2.4     cw=cw-w[i]; cp=cp-p[i];

KnapSack2.java                                                   // 回溯算法

import java.util.*;

public class KnapSack2
{
 public static void main(String[] args)
 {
  Scanner in=new Scanner(System.in);
  System.out.println("Please enter the number of objects(請輸入物品的數量):");
  int n=in.nextInt();
  int[] w=new int[n];
  int[] v=new int[n];
  System.out.println("Now,please enter the weight of these objects(現在請輸入這些物品的重量):");
  for(int i=0;i<n;i++)
  {
   w[i]=in.nextInt();
  }
  System.out.println("Now,please enter the value of these objects(現在請輸入這些物品的價值):");
  for(int i=0;i<n;i++)
  {
   v[i]=in.nextInt();
  }
  System.out.println("Now,please enter the capacity of the pack(現在請輸入揹包的容量):");
     int c=in.nextInt();
     /**
      *按單位重量價值r[i]=v[i]/w[i]降序排列
      */
     double startTime=System.currentTimeMillis();
  double[] r=new double[n];
  int[] index=new int[n];
  for(int i=0;i<n;i++)
  {
   r[i]=(double)v[i]/(double)w[i];
   index[i]=i;
  }
  double temp=0;
  for(int i=0;i<n-1;i++)
  {
   for(int j=i+1;j<n;j++)
   {
    if(r[i]<r[j])
    {
     temp=r[i];
     r[i]=r[j];
     r[j]=temp;
     int x=index[i];
     index[i]=index[j];
     index[j]=x;
    }
   }
  }
  /**
   *排序後的重量和價值分別存到w1[]和v1[]中
   */
  int[] w1=new int[n];
  int[] v1=new int[n];
  for(int i=0;i<n;i++)
  {
   w1[i]=w[index[i]];
   v1[i]=v[index[i]];
  }
  System.out.println (Arrays.toString(w1));
  System.out.println (Arrays.toString(v1));
  /**
   *調用函數KnapSackBackTrack()，輸出打印裝完物品以後的最大價值
   */
  KnapSackBackTrack(w1,v1,w1.length,c);
  double endTime=System.currentTimeMillis();
  System.out.println("Basic Statements take(基本語句用時) "+(endTime-startTime)+" milliseconds!"); 
 }
 /**
  *用回溯法求0、1揹包最大價值的函數定義
  */
 public static void KnapSackBackTrack(int[] w,int[] v,int n,int c)
 {
  int CurrentWeight=0;
  int CurrentValue=0;
  int maxValue=0;
  int i=0;
  while(i>=0)
  {
   if(CurrentWeight+w[i]<=c)
   {
    CurrentWeight+=w[i];
    CurrentValue+=v[i];
    i++;
   }
   else
    break;  
  }
  if(i<n)
  {
   maxValue=CurrentValue;
   System.out.println("Now,the largest values of objects in the pack is(揹包中物品的最大價值爲):"+maxValue);
   return;
  }
  System.out.println("Now,the largest values of objects in the pack is(揹包中物品的最大價值爲):"+maxValue);
  return;
 }
}