青岛科技大学算法设计与分析实验报告算法实训背包问题.docx

青岛科技大学算法设计与分析实验报告算法实训背包问题.docx

《青岛科技大学算法设计与分析实验报告算法实训背包问题.docx》由会员分享，可在线阅读，更多相关《青岛科技大学算法设计与分析实验报告算法实训背包问题.docx（13页珍藏版）》请在冰豆网上搜索。

青岛科技大学算法设计与分析实验报告算法实训背包问题

数据结构与算法分析2

课程设计报告书

班级

学号

姓名

指导教师庞志永

课程设计项目名称：

背包问题的多项式时间近似方案

1.问题描述：

背包问题可描述为如下的整数规划形式，其中M为背包的容量，P为物体的价值，W为物体的体积。

2.基本要求：

（1）在给定参数K的条件下，设计背包问题的满足近似性能比不大于1+1/（k+1）的多项式时间近似方案，并选择适当的编程语言在计算机上实现。

（2）程序能够正常运行，计算结果正确，满足设计要求。

3.算法描述：

将装入背包的物体进行多次尝试，其方法是：

取K为确定的非负整数，考虑背包问题的实例I中的n个物体的合的K元素子集C，|C|=K。

（1）尝试将每个K元素子集C中的物体优先装入背包；

（2）利用解答背包问题的贪心算法A将（n-K）个物体尝试装入背包。

合并先装入的K个物体和用算法A装入的剩余物体作为算法的最终解。

过程如下：

Procedure-APPROX（P,W,M,n,K）

（1）PMAX=0;

（2）ForallcombinationsCofsize=K&weight≤Mdo

（3）PC=i∈CPi

（4）PMAX=max{PMAX,PC+L（I,P,W,M,n）};

（5）Endfor

（6）End-APPROX

ProcedureL（I,P,W,M,n）

（1）S1=0;T=M－i∈CWi;

（2）Fori=1tondo

（3）IfiCandWi≤Tthen

（4）S1=S1+Pi,T=T–Wi

（5）Endif

（6）Endfor

（7）S=max{S1,max{Pi|iC}};

（8）Return（S）

（9）EndL

4.模块划分（仅供参考）：

（1）输入及存储原始数据模块

（2）-APPROX（P,W,M,n,K）模块

（3）L（I,P,W,M,n）模块

（4）存储及输出结果模块

5.本课程设计中遇到的关键问题及其解决方法：

背包使用面向对象方法：

packageknapsack;

publicclassKnapsack{

/**背包重量*/

privateintweight;

/**背包物品价值*/

privateintvalue;

/***

*构造器

*/

publicKnapsack（intweight,intvalue）{

this.value=value;

this.weight=weight;

}

publicintgetWeight（）{

returnweight;

}

publicintgetValue（）{

returnvalue;

}

publicStringtoString（）{

return"[weight:

"+weight+"\t"+"value:

"+value+"]";

}

}

获取最优解：

packageknapsack;

importjava.util.ArrayList;

importjava.util.List;

importjavax.swing.JOptionPane;

importalgorithm.dynamicplan.Knapsack;

/**

*背包

*首先将最多k件物品放人背包，

*如果这k件物品重量大于c，则放弃它。

*否则，剩余的重量用来考虑将剩余物品按价值重量比递减的顺序装入。

*通过考虑最多为k件物品的所有可能的子集来得到最优解。

*

*@author

*

*/

publicclassKSMethod{

/**

*输入及存储原始数据模块

*@paramn

*@returnP

*/

staticListInputData（intn）{

Stringweight=JOptionPane.showInputDialog（"InputW（空格隔开）:

"）;

Stringvalue=JOptionPane.showInputDialog（"InputP（空格隔开）:

"）;

String[]values=value.split（""）;

String[]weights=weight.split（""）;

ListP=newArrayList（）;

for（inti=0;i

P.add（newKnapsack（Integer.valueOf（weights[i]）,Integer

.valueOf（values[i]）））;

}

System.out.println（"原始数据：

"）;

printlist（P）;

returnP;

}

/**

*e-APPROX（P,W,M,n,K）模块

*

*@parambags1

*@paramM

*@paramn

*@paramK

*@return解

*/

staticintSolve（Knapsack[]bags1,intM,intn,intK）{

List>allSubLists=getSubLists（bags1）;

ListP=newArrayList（）;

for（Knapsackknapsack:

bags1）{

P.add（knapsack）;

}

intPmax=0;

for（ListI:

allSubLists）{

intweight=0;

for（Knapsackknapsack:

I）{

weight=weight+knapsack.getWeight（）;

}

if（（I.size（）<=K）&&weight<=M）{

intPi=0;

for（Knapsackknapsack:

P）{

//i++;

if（I.contains（knapsack））{

Pi=Pi+knapsack.getValue（）;

}

}

Pmax=max（Pmax,Pi+L（I,P,M,n））;

}

}//endfor

returnPmax;

}

/**

*L（I,P,W,M,n）模块

*

*@paramI

*@paramP

*@paramM

*@paramn

*@return

*/

staticintL（ListI,ListP,intM,intn）{

intS=0,S1=0;

intSumWi=0;

for（Knapsackknapsack:

I）{

SumWi=SumWi+knapsack.getWeight（）;

}

intT=M-SumWi;

for（Knapsackknapsack:

P）{

intWi=knapsack.getWeight（）;

intPi=knapsack.getValue（）;

if（（!

I.contains（knapsack））&&Wi<=T）{

S1=S1+Pi;

T=T-Wi;

}

}

int[]t=max（P,I）;

if（t[1]+SumWi

S=max（S1,t[0]）;

}

returnS;

}

/**

*遍历集合

*

*@paramlist

*/

staticvoidprintlist（Listlist）{

for（Knapsackknapsack:

list）{

System.out.println（knapsack）;

}

}

/**

*最大值

*

*@parama

*@paramb

*@returnmax

*/

staticintmax（inta,intb）{

returna>b?

a:

b;

}

/**

*计算max{Pi|i不属于I}

*

*@paramP

*@paramI

*@returnmax

*/

staticint[]max（ListP,ListI）{

intmax=0;

intw=0;

for（Knapsackknapsack:

P）{

if（I.contains（knapsack））{

continue;

}

inttemp=knapsack.getValue（）;

if（max>temp）{

max=temp;

w=knapsack.getWeight（）;

}

}

returnnewint[]{max,w};

}

/**

*得到所有子集

*

*@paramarray

*@return

*/

staticList>getSubLists（Knapsack[]array）{

List>allsubLists=newArrayList>（）;

intmax=1<

for（inti=0;i

ListsubList=newArrayList（）;

intk=i;

intindex=0;

while（k>0）{

if（（k&1）>0）{

subList.add（array[index]）;

}

k>>=1;

index++;

}

allsubLists.add（subList）;

}

returnallsubLists;

}

}

程序入口：

packageknapsack;

importjava.util.ArrayList;

importjava.util.List;

importjavax.swing.JOptionPane;

importalgorithm.dynamicplan.Knapsack;

publicclassK7_4{

publicstaticvoidmain（String[]args）{

intn=Integer.valueOf（JOptionPane.showInputDialog（"InputN:

"））;

intm=Integer.valueOf（JOptionPane.showInputDialog（"InputM:

"））;

System.out.println（"背包容量：

"+m）;

ListP=newArrayList（）;

P=KSMethod.InputData（n）;

intk=Integer.valueOf（JOptionPane.showInputDialog（"InputK:

"））;

Knapsack[]bags=P.toArray（newKnapsack[0]）;

Stringres=null;

for（inti=0;i

res="最优解（价值总和）：

"+KSMethod.Solve（bags,m,n,i）;

System.out.println（"当k="+i+":

"+res）;

}

}

}

6.运行结果及其相关描述：

要求实例中物体的数量在20—100之间。

背包容量：

50

原始数据：

[weight:

1value:

5]

[weight:

2value:

5]

[weight:

3value:

5]

[weight:

4value:

5]

[weight:

5value:

5]

[weight:

6value:

7]

[weight:

7value:

7]

[weight:

8value:

8]

[weight:

9value:

9]

[weight:

10value:

10]

[weight:

11value:

11]

[weight:

12value:

12]

[weight:

13value:

13]

[weight:

14value:

14]

[weight:

15value:

15]

[weight:

16value:

16]

[weight:

17value:

17]

[weight:

18value:

18]

[weight:

19value:

19]

[weight:

20value:

20]

当k=0:

最优解（价值总和）：

56

当k=1:

最优解（价值总和）：

61

当k=2:

最优解（价值总和）：

61

当k=3:

最优解（价值总和）：

61

当k=4:

最优解（价值总和）：

61

当k=5:

最优解（价值总和）：

61

当k=6:

最优解（价值总和）：

61

当k=7:

最优解（价值总和）：

61

当k=8:

最优解（价值总和）：

61

当k=9:

最优解（价值总和）：

61

7.课程设计总结：

通过这次实验，深刻体会到算法的无限魅力。