算法 0-1背包问题

一、实验目的与要求

掌握回溯法、分支限界法的原理，并能够按其原理编程实现解决0-1背包问题，以加深对回溯法、分支限界法的理解。

1．要求分别用回溯法和分支限界法求解0-1背包问题；

2．要求交互输入背包容量，物品重量数组，物品价值数组；

3．要求显示结果。

二、实验方案

在选择装入背包的物品时，对每种物品i只有2种选择，即装入背包或不装入背包。不能将物品i装入背包多次，也不能只装入部分的物品i。

三、实验结果和数据处理

1．用回溯法解决0-1背包问题：

代码：

import java.util.*;

public class Knapsack

{

private double[] p,w;//分别代表价值和重量

private int n;

private double c,bestp,cp,cw;

private int x[]; //记录可选的物品

private int[] cx;

public Knapsack (double pp[],double ww[],double cc)

{

this.p=pp;this.w=ww;this.n=pp.length-1;

this.c=cc;this.cp=0;this.cw=0;

this.bestp=0;

x=new int[ww.length];

cx=new int[pp.length];

}

void Knapsack()

{

backtrack(0);

}

void backtrack(int i)

{

if(i>n)

{ //判断是否到达了叶子节点

if(cp>bestp)

{

for(int j=0;j

x[j]=cx[j];

bestp=cp;

}

return;

}

if(cw+w[i]<=c)

{//搜索右子树

cx[i]=1;

cw+=w[i];

cp+=p[i];

backtrack(i+1);

cw-=w[i];

cp-=p[i];

}

cx[i]=0;

backtrack(i+1); //检查左子树

}

void printResult()

{

System.out.println("回溯法");

System.out.println("物品个数：n=4");

System.out.println("背包容量：c=7");

System.out.println("物品重量数组：w= {3,5,2,1}");

System.out.println("物品价值数组：p= {9,10,7,4}");

System.out.println("最优值：="+bestp);

System.out.println("选中的物品是:");

for(int i=0;i

{

System.out.print(x[i]+" ");

}

}

public static void main(String[] args)

{

double p[]={9,10,7,4};

double w[]={3,5,2,1};

int maxweight=7;

Knapsack ks=new Knapsack(p,w,maxweight);

ks.Knapsack(); //回溯搜索

ks.printResult();

}

}

运行结果：

2．用优先队列式分支限界法解决0-1背包问题：

代码：

public class Knapsack

{

static double c;

static int n;

static double w[];

static double p[];

static double cw;

static double cp;

static int bestX[];

static MaxHeap heap;

//上界函数bound计算结点所相应价值的上界

private static double bound(int i)

{

double cleft=c-cw;

double b=cp;

while(i<=n&&w[i]<=cleft)

{

cleft=cleft-w[i];

b=b+p[i];

i++;

}

//装填剩余容量装满背包

if(i<=n)

b=b+p[i]/w[i]*cleft;

return b;

}

//addLiveNode将一个新的活结点插入到子集树和优先队列中

private static void addLiveNode(double up,double pp,double ww,int lev,BBnode par,boolean ch) {

//将一个新的活结点插入到子集树和最大堆中

BBnode b=new BBnode(par,ch);

HeapNode node =new HeapNode(b,up,pp,ww,lev);

heap.put(node);

}

private static double MaxKnapsack()

{

//优先队列式分支限界法，返回最大价值，bestx返回最优解

BBnode enode=null;

int i=1;

double bestp=0;//当前最优值

double up=bound(1);//当前上界

while(i!=n+1){//非叶子结点

//检查当前扩展结点的左儿子子结点

double wt=cw+w[i];

if(wt<=c){

if(cp+p[i]>bestp)

bestp=cp+p[i];

addLiveNode(up,cp+p[i],cw+w[i],i+1,enode,true);

}

up=bound(i+1);

if(up>=bestp)

addLiveNode(up,cp,cw,i+1,enode,false);

HeapNode node =(HeapNode)heap.removeMax();

enode=node.liveNode;

cw=node.weight;

cp=node.profit;

up=node.upperProfit;

i=node.level;

}

for(int j=n;j>0;j--)

{

bestX[j]=(enode.leftChild)?1:0;

enode=enode.parent;

}

return cp;

}