java技术09级02班30齐贝贝.docx
《java技术09级02班30齐贝贝.docx》由会员分享，可在线阅读，更多相关《java技术09级02班30齐贝贝.docx（41页珍藏版）》请在冰豆网上搜索。
java技术09级02班30齐贝贝
算法设计与分析实验报告
专业：
软件工程（java技术0902）
学号：
540913100230
姓名：
齐贝贝
指导老师：
宋胜利李璞
实验一：
递归与分治 棋盘覆盖
一实验目的与要求
1、理解递归与分治策略算法
2、利用递归与分治策略算法求解期盼覆盖问题
二实验题：
问题描述：
用4种不同形态的L型骨牌覆盖一个给定的特殊棋盘上除特殊方格以外的所有方格,且任何2个L型骨牌不得重叠覆盖。
输入数据由程序运行后的界面中的编辑框中输入游戏规模,特殊方格的位置。
将覆盖的结果在窗口中显示出来。
三实验代码
packagechess;
importjava.awt.Color;
importjava.awt.Container;
importjava.awt.GridLayout;
importjava.util.Random;
importjavax.swing.JFrame;
importjavax.swing.JPanel;
importjavax.swing.JScrollPane;
importjavax.swing.border.Border;
publicclassNewChessextendsJFrame
{
JPanelpanel[];
intnum=4;//保存是X*X的棋盘
introw=0;//保存特殊方格所在的行
intcol=0;//保存特殊方格所在的列
publicNewChess（）
{
super（"棋盘覆盖"）;
Containercontainer=this.getContentPane（）;
container.setLayout（newGridLayout（4,4））;
panel=newJPanel[num*num];
//产生一个随机数，让其中任意一个与其他的颜色不一样
Randomrandom=newRandom（）;
intn=random.nextInt（）;
n=Math.abs（n%（num*num））;
while（n>（num*num））{
n=n%（num*num）;
}
//计算得到特殊方格所在的行和列
col=n%num;
row=n/num;
//产生所有的方格，包括特殊方格
for（inti=0;i<（num*num）;i++）{
panel[i]=newJPanel（）;
container.add（newJScrollPane（panel[i]））;
}
panel[n].setBackground（Color.black）;
this.setVisible（true）;
this.setSize（500,500）;
this.setResizable（false）;
chessBord（0,0,row,col,num）;
}
publicvoidchessBord（inttr,inttc,intdr,intdc,intsize）
{
if（size==1）{
return;
}
ints=size/2;
//通过线程来控制出现的时间，看清楚覆盖的过程
try{
Thread.sleep（1000）;
}catch（InterruptedExceptione）{
e.printStackTrace（）;
}
//覆盖左上角子棋盘
if（drchessBord（tr,tc,dr,dc,s）;
}
else{
//用红色覆盖右下角
intcolor=（int）（（tr+s-1）*num+tc+s-1）;
//System.out.println（"===="+color）;
panel[color].setBackground（Color.RED）;
chessBord（tr,tc,tr+s-1,tc+s-1,s）;
}
//覆盖右上角棋盘
if（dr=tc+s）{
chessBord（tr,tc+s,dr,dc,s）;
}
else{
//用红色覆盖右下角
intcolor=（int）（（tr+s-1）*num+tc+s）;
//System.out.println（"+++++"+color）;
panel[color].setBackground（Color.RED）;
chessBord（tr,tc+s,tr+s-1,tc+s,s）;
}
//覆盖左下角棋盘
if（dr>=tr+s&&dcchessBord（tr+s,tc,dr,dc,s）;
}
else{
//用红色覆盖右下角
intcolor=（int）（（tr+s）*num+tc+s-1）;
//System.out.println（"....."+size+"+++++"+tr+"----"+color）;
panel[color].setBackground（Color.RED）;
chessBord（tr+s,tc,tr+s,tc+s-1,s）;
}
//覆盖右下角棋盘
if（dr>=tr+s&&dc>=tc+s）{
chessBord（tr+s,tc+s,dr,dc,s）;
}
else{
//用红色覆盖右下角
intcolor=（int）（（tr+s）*num+tc+s）;
//System.out.println（"*******"+color）;
panel[color].setBackground（Color.RED）;
chessBord（tr+s,tc+s,tr+s,tc+s,s）;
}
}
publicstaticvoidmain（Stringargs[]）
{
newNewChess（）;
}
}
四实验结果
实验二：
动态规划 矩阵连乘问题
一实验目的与要求
1、掌握动态规划算法
2、掌握用动态规划算法求解矩阵连乘问题
二实验题：
问题描述：
给定n个矩阵｛A1,A2,...,An｝，其中Ai与Ai+1是可乘的，i=1，2...，n-1。
确定计算矩阵连乘积的计算次序，使得依此次序计算矩阵连乘积需要的数乘次数最少。
输入数据为矩阵个数和每个矩阵规模，输出结果为计算矩阵连乘积的计算次序和最少数乘次数
三实验代码
#include
#include
#include
#defineN6//6个矩阵A1到A6
intp[N+1]={30,35,15,5,10,20,25};
intm[N+1][N+1];//为了方便,m[0][x]这一行与m[x][0]这一列不使用,m[i][j]表示矩阵Ai到矩阵Aj的最少（即最优）连乘次数,m[1][6]即为所求
ints[N+1][N+1];//最优断开位置的数组
voidMatrixChain（int*p,intn,intm[][N+1],ints[][N+1]）;//计算m[i][j]数组
voidOutput（int（*m）[N+1],int（*s）[N+1],intn）;//输出m[][]数组
voidAddBrackets（int（*s）[N+1],intbegin,intend）;//输出加括号的方案
intmain（）
{
MatrixChain（p,N,m,s）;
Output（m,s,N）;
printf（"TheBestTimes:
%d\n",m[1][N]）;
printf（"TheBestLocations:
"）;
printf（"AddBrackets:
\n"）;
AddBrackets（s,1,N）;
return0;
}
//计算m[i][j]数组
voidMatrixChain（int*p,intn,intm[][N+1],ints[][N+1]）
{
intloop,i,j,k,tmp,d=0;//d为步长
for（loop=n-1;loop>=1;--loop）
{
++d;
for（i=1;i<=loop;++i）
{
j=i+d;
m[i][j]=INT_MAX;
for（k=i;k{
tmp=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
if（tmp{
m[i][j]=tmp;
s[i][j]=k;
}
}
}
}
}
voidOutput（int（*m）[N+1],int（*s）[N+1],intn）//输出m[][]数组
{
inti,j;
for（i=1;i<=n;++i）
{
for（j=1;j<=n;++j）
{
printf（"m[%d][%d]=%d",i,j,m[i][j]）;
}
printf（"\n"）;
}
printf（"\n"）;
for（i=1;i<=n;++i）
{
for（j=1;j<=n;++j）
{
printf（"s[%d][%d]=%d",i,j,s[i][j]）;
}
printf（"\n"）;
}
}
voidAddBrackets（int（*s）[N+1],intbegin,intend）//输出加括号的方案
{
intk=s[begin][end];
printf（"AddBracketsforA%dandA%d,andforA%dandA%d\n",begin,k,k+1,end）;
if（k-begin>1）
AddBrackets（s,begin,k）;
if（end-（k+1）>1）
AddBrackets（s,k+1,end）;
}
四实验结果
实验三：
贪心法 求解背包问题
一实验目的与要求
1、掌握背包问题的算法
2、初步掌握贪心算法
二实验题：
问题描述：
与0-1背包问题相似，给定n种物品和一个背包。
物品i的重量是wi，其价值为vi，背包的容量为c。
与0-1背包问题不同的是，在选择物品i装入背包时，背包问题的解决可以选择物品i的一部分，而不一定要全部装入背包，1三、实验代码
importjava.awt.*;
importjava.awt.event.*;
importjavax.swing.*;
publicclasserextendsJFrame{
privatestaticfinallongserialVersionUID=-1508220487443708466L;
privatestaticfinalintwidth=360;//面板的宽度
privatestaticfinalintheight=300;//面板的高度
publicintM;
publicint[]w;
publicint[]p;
publicintlength;
er（）{
//初始Frame参数设置
this.setTitle（"贪心算法"）;
setDefaultCloseOperation（EXIT_ON_CLOSE）;
setSize（width,height）;
Containerc=getContentPane（）;
c.setLayout（newBoxLayout（c,BoxLayout.Y_AXIS））;
setLocation（350,150）;
//声明一些字体样式
FonttopF1=newFont（"宋体",Font.BOLD,28）;
Fontblack15=newFont（"宋体",Font.PLAIN,20）;
Fontbold10=newFont（"宋体",Font.BOLD,15）;
//声明工具栏及属性设置
JPanelbarPanel=newJPanel（）;
JMenuBartopBar=newJMenuBar（）;
topBar.setLocation（1,1）;
barPanel.add（topBar）;
//面板1和顶部标签属性设置
JPanelp1=newJPanel（）;
JLabeltopLabel=newJLabel（"背包问题"）;
topLabel.setForeground（Color.blue）;
topLabel.setFont（topF1）;
p1.add（topLabel）;
//中间面板和标签及输入框属性设置
JPanelp2=newJPanel（）;
p2.setLayout（newBoxLayout（p2,BoxLayout.Y_AXIS））;
JLabelwLabel=newJLabel（"请输入重量:
"）;
JLabelpLabel=newJLabel（"请输入效益:
"）;
wLabel.setFont（black15）;
pLabel.setFont（black15）;
//
finalJTextFieldwText=newJTextField（8）;
finalJTextFieldpText=newJTextField（8）;
//wText.setText（"10,8,7,5,9,6"）;
//pText.setText（"15,14,7,10,17,7"）;
p2.add（wLabel）;
p2.add（wText）;
p2.add（pLabel）;
p2.add（pText）;
//
//中下部面板和标签属性设置
JPanelp3=newJPanel（）;
JLabelbottomLabel=newJLabel（
"注意：
数据输入时请添加分割符','"）;
bottomLabel.setFont（bold10）;
bottomLabel.setForeground（Color.red）;
bottomLabel.setHorizontalAlignment（SwingConstants.RIGHT）;
p3.add（bottomLabel）;
//
JPanelp5=newJPanel（）;
p5.setLayout（newBoxLayout（p5,BoxLayout.Y_AXIS））;
JLabelmLabel=newJLabel（"请输入背包总重量:
"）;
mLabel.setFont（black15）;
finalJTextFieldmText=newJTextField（8）;
p5.add（mLabel）;
p5.add（mText）;
//面板和按钮的设置
JPanelp4=newJPanel（）;
JButtonsubmit=newJButton（"确定"）;
submit.addActionListener（newActionListener（）{
publicvoidactionPerformed（ActionEvente）{
Strings1=pText.getText（）;//效益
Strings2=wText.getText（）;//重量
Strings3=mText.getText（）;//背包
System.out.println（s1）;
System.out.println（s2）;
System.out.println（s3）;
Strings1Copy,s2Copy,s3Copy;
s1Copy=s1;
s2Copy=s2;
s3Copy=s3;
s1Copy=s1Copy.replaceAll（",",""）;
s2Copy=s2Copy.replaceAll（",",""）;
s3Copy=s3Copy.replaceAll（",",""）;
System.out.println（s1Copy）;
System.out.println（s2Copy）;
System.out.println（s3Copy）;
try{
String[]temp=s1.split（","）;//按照','分割字符串
p=newint[temp.length];
for（inti=0;ip[i]=Integer.parseInt（temp[i]）;//
temp=s2.split（","）;
w=newint[temp.length];
for（inti=0;iif（w.length==p.length）
{
length=w.length;
}
else{
JOptionPane.showMessageDialog（null,"长度不等,请检查后重新输入!
"）;
}
M=Integer.parseInt（s3）;
}catch（NumberFormatExceptione2）{
e2.printStackTrace（）;
try{
if（s2.equals（""））{
JOptionPane.showMessageDialog（null,"重量不能为空!
"）;
return;
}
else{
if（s1.equals（""））{
JOptionPane.showMessageDialog（null,"效益值不能为空!
"）;
return;
}else
{
if（s3.equals（""））
JOptionPane.showMessageDialog（null,"总重量不能为空!
"）;
return;
}
}
}catch（Exceptione3）{
//TODO:
handleexception
}
}
//可以执行贪心算法了
int[]wCopy=newint[w.length];
int[]pCopy=newint[w.length];
floattemp2;
inttemp1;
floattotalx=0;
float[]x=newfloat[w.length];//效益和重量的比值
float[]n=newfloat[w.length];//记录个数
float[]nCopy=newfloat[w.length];
for（inti=0;i{
wCopy[i]=w[i];
pCopy[i]=p[i];
}
for（inti=0;ix[i]=（float）（（p[i]*1.0）/w[i]）;
for（inti=0;ifor（intj=i+1;j{
if（x[i]{
temp2=x[j];
x[j]=x[i];
x[i]=temp2;
temp1=p[j];
p[j]=p[i];
p[i]=temp1;
temp1=w[j];
w[j]=w[i];
w[i]=temp1;
}
}//效益重量比值排序
Backpackb=newBackpack（M,w,p,n）;
for（inti=0;ifor（intj=0;j{
if（wCopy[i]==w[j]&&pCopy[i]==p[j]）
{
nCopy[i]=b.n[i];
}
}
for（intj=0;jtotalx=totalx+n[j]*p[j];
ShowResults=newShowResult（p,w,length,n,totalx）;
}//actionPerformed
}）;
p4.add（submit）;
//p4.add（eButton）;
//
JPaneltopPanel=newJPanel（）;
topPanel.setLayout（newBoxLayout（topPanel,BoxLayout.Y_AXIS））;
topPanel.add（p1）;
topPanel.add（p2）;
topPanel.add（p5）;
topPanel.add（p3）;
topPanel.add（p4）;
c.add（barPanel）;
c.add（topPanel）;
setVisible（true）;
}//构造方法
publicstaticvoidmain（String[]args）{
erg=newer（）;
}//endmain
}
classBackpack{
privateintcapacity;
intlength;//数组元素个数
float[]n;
publicBackpack（intM,int[]w,int[]p,float[]n）{
t
升级会员 