算法实验软件.docx

算法实验软件.docx

《算法实验软件.docx》由会员分享，可在线阅读，更多相关《算法实验软件.docx（19页珍藏版）》请在冰豆网上搜索。

算法实验软件

算法设计与分析实验报告

专业/班级软件02

学号

学生姓名

提交日期2013-6-25

目录

1.实验题目A3

2.实验内容3

3.实验结果5

4.实验题目B6

5.实验内容6

6.实验结果8

7.实验题目C8

8.实验内容8

9.实验结果9

10.实验题目D9

11.实验内容10

12.实验结果13

13.实验题目E13

14.实验内容14

15.实验结果17

1.实验题目A

1.设有n个运动员要进行网球循环赛。

设计一个满足以下条件的循环赛日程表：

1每个选手必须与其他n-1个选手各赛一次。

2每个选手一天只能赛一次。

3当n是偶数时，循环赛进行n-1天，当n是奇数时，循环赛进行n天。

2.实验内容

publicclassA{

privateint[][]a=newint[11][11];

privateint[]b=newint[20];

privateintr=9;

publicvoidtourna（intn）{

if（n==1）{a[1][1]=1;return;}

tourna（n/2）;

copy（n）;

}

privatevoidcopy（intn）{

intm=n/2;

for（inti=1;i<=m;i++）{

for（intj=1;j<=m;j++）{

a[i][j+m]=a[i][j]+m;

a[i+m][j]=a[i][j+m];

a[i+m][j+m]=a[i][j];

}

}

}

privatevoidmakecopy（intn）{

if（（n/2）>1&&odd（n/2））{

copyodd（n）;

}elsecopy（n）;

}

privatevoidcopyodd（intn）{

intm=n/2;

for（inti=1;i<=m;i++）{

b[i]=m+i;

b[m+i]=b[i];

}

for（inti=1;i<=m;i++）{

for（intj=1;j<=m;j++）{

if（a[i][j]>m）{a[i][j]=b[i];a[m+i][j]=（b[i]+m）%n;}

else{a[m+i][j]=a[i][j]+m;}

}

for（intj=2;j<=m;j++）{

a[i][m+j]=b[i+j-1];

a[b[i+j-1]][m+j]=i;

}

}

for（inti=1;i<11;i++）{

if（a[i][6]==0）a[i][m+1]=a[i-5][m+1]+m;

}

}

privatebooleanodd（intn）{

if（n%2!

=0）returntrue;

elsereturnfalse;

}

privatevoidconstruct（intn）{

if（n==1）return;

intm=odd（n）?

n:

n-1;

a[n][1]=n;

for（inti=1;i<=m;i++）{

a[i][1]=i;

b[i]=i+1;

b[m+i]=i+1;

}

for（inti=1;i<=m;i++）{

a[1][i+1]=b[i];

a[b[i]][i+1]=1;

for（intj=1;j<=m/2;j++）{

intk=b[i+j];

r=b[i+m-j];

a[k][i+1]=r;

a[r][i+1]=k;

}

}

}

publicstaticvoidmain（String[]args）{

Atest=newA（）;

test.construct（10）;

for（inti=1;i<11;i++）{

for（intj=1;j<11;j++）{

System.out.println（i+""+j+""+test.a[i][j]）;

}

}

}

3.实验结果

4.实验题目B

最优合并问题：

问题描述：

给定k个排序好的序列，用二路合并算法将这k个序列合并成一个序列。

假设所采用的二路合并算法合并两个长度分别为m和n的序列需要m+n-1次比较。

试设计一个算法确定合并这个序列的最优合并顺序，使所需的总比较次数最少。

为了进行比较，还需要确定合并这个序的最差合并顺序，使所需的总比较次数最多。

算法设计：

对于给定的k个待合并序列，计算最多比较次数和最少比较次数合并方案。

数据输入：

由文件input.txt给出输入数据。

第一行有一个正整数k，表示有k个待合并序列。

接下来的一行有k个正整数，表示k个待合并序列的长度。

结果输出：

将计算的最多比较次数和最小比较次数输出到文件output.txt。

输入文件示例

Input.txt

4

512112

输出文件示例

7852

5.实验内容

iimportjava.io.BufferedReader;

importjava.io.FileInputStream;

importjava.io.FileNotFoundException;

importjava.io.InputStreamReader;

importjava.io.UnsupportedEncodingException;

publicclassB{

privateStringfile;

privateint[]deal;

privateintmax=0;

privateintmin=0;

publicB（）{

file="C:

\\Users\\Ryan\\Desktop\\input.txt";

try{

BufferedReaderin=newBufferedReader（newInputStreamReader（newFileInputStream（file）,"GB2312"））;

inttemp=Integer.valueOf（in.readLine（））;

deal=newint[temp];

Stringtt=in.readLine（）;

String[]dealtemp=tt.split（"\\s+"）;

for（inti=0;i

deal[i]=Integer.valueOf（dealtemp[i]）;

}

for（inti=0;i

intk=i;

for（intj=i;j

if（deal[k]>deal[j]）{

k=j;

}

}

if（k!

=i）{

inttempx=deal[i];

deal[i]=deal[k];

deal[k]=tempx;

}

}

for（inti=0;i

min+=deal[i]+deal[i+1]-1;

deal[i+1]=deal[i]+deal[i+1];

}

System.out.println（"Min:

"+min）;

for（inti=0;i

deal[i]=Integer.valueOf（dealtemp[i]）;

}

for（inti=0;i

intk=i;

for（intj=i;j

if（deal[k]

k=j;

}

}

if（k!

=i）{

inttempx=deal[i];

deal[i]=deal[k];

deal[k]=tempx;

}

}

for（inti=0;i

max+=deal[i]+deal[i+1]-1;

deal[i+1]=deal[i]+deal[i+1];

}

System.out.println（"Max:

"+max）;

}catch（UnsupportedEncodingExceptione）{

e.printStackTrace（）;

}catch（Exceptione）{

e.printStackTrace（）;

}

}

publicstaticvoidmain（String[]args）{

Btest=newB（）;

}

}

6.实验结果

7.实验题目C

最优装载

问题描述：

有一批集装箱要装上一艘载重量为c的轮船。

其中集装箱i的重量为。

最优装载问题需要求在装载体积不受限制的情况下，将尽可能多的集装箱装上轮船

8.实验内容

publicclassC{

privateintc=50;//第一艘轮船载重量

privateintw[]={20,40,10,60};//集装箱重量数组

privateintcw=0;//当前载重量

privateintr=130;//剩余集装箱重量

privateintbestw=0;

privateintn=3;//集装箱数

publicC（）

{

maxLoading（0）;

System.out.println（bestw）;

}

privatevoidmaxLoading（inti）{

if（i>n）{bestw=cw;return;}

r-=w[i];

if（cw+w[i]<=c）{cw+=w[i];maxLoading（i+1）;cw-=w[i];}

if（cw+r>bestw）{maxLoading（i+1）;}

r+=w[i];

}

publicstaticvoidmain（String[]args）{

//TODOAuto-generatedmethodstub

Ctest=newC（）;

}

}

9.实验结果

10.实验题目D

皇后控制问题

问题描述：

在n*n个方格组成的棋盘上的任意方格中放置一个皇后，该皇后可以控制所在的行，列以及对角线上的所有方格，对于给定的自然数n，在n*n个方格组成的棋盘上至少要放置多少个皇后才能控制所有的格子，皇后之间不能攻击。

算法设计：

设计一个拉斯维加斯算法，于给定的自然数n，在n*n个方格组成的棋盘上至少要放置多少个皇后才能控制所有的格子，皇后之间不能攻击。

数据输入：

8

结果输出：

11.实验内容

importjava.util.Arrays;

importjava.util.Random;

publicclassD{//p236

privateintn;

privateintflag=0;

privateintmin[]=newint[25];

privateStringmins[]=newString[25];

privateintx[]=newint[n+1];

privateinty[]=newint[n+1];

privateintyy[][]=newint[n+1][n+1];

publicbooleanPlace（intk）{

if（x[k]>0）

for（intj=0;j

if（x[j]>0&&（Math.abs（k-j）==Math.abs（x[j]-x[k]）||x[j]==x[k]））returnfalse;

returntrue;

}

publicintQLV（intm,intstopVegas）{

Randomrnd=newRandom（）;

while（true）{

intk=1;

while（k<=stopVegas）{

intcount=0;

for（inti=0;i<=n;i++）{

x[k]=i;

if（Place（k））y[count++]=i;

}

x[k++]=y[rnd.nextInt（count）];

}

intpla=placed（stopVegas）;

if（pla<=m）returnpla;

elsereturn0;

}

}

publicintplaced（intk）{

//TODOAuto-generatedmethodstub

intnum=0;

for（intj=1;j<=k;j++）if（x[j]>0）num++;

returnnum;

}

publicbooleanQueensLV（intstopVegas）{

intm=stopVegas,count=0,cont=10000;

while（true）{

intret=QLV（m,stopVegas）;

if（ret>0）{m=ret-1;count=0;}

elsecount++;

if（count>cont）{while（QLV（m+1,stopVegas）==0）;break;}

}

returntrue;

}

publicbooleanbacktrack（intt）{

if（t>n）{

if（ctrl（n））returntrue;

elsereturnfalse;

}

for（inti=0;i<=n;i++）{

x[t]=i;

if（Place（t）&&backtrack（t+1））returntrue;

}

returnfalse;

}

publicbooleannQueen（intn）{

this.n=n;

intstop=3;

Stringtt="";

int[]p=newint[n+1];

int[]q=newint[n+1];

int[][]r=newint[n+1][n+1];

for（inti=0;i<=n;i++）{p[i]=0;}

this.x=p;

this.y=q;

this.yy=r;

if（n>15）stop=n-15;

booleanfound=false;

while（!

this.QueensLV（stop））;

if（this.backtrack（stop+1））{

min[flag]=this.placed（n）;

for（inti=1;i<=n;i++）tt=tt+Integer.toString（p[i]）+"";

mins[flag]=tt;

flag++;

found=true;

}

returnfound;

}

publicvoidmin（）{

Stringtemp="";

this.selectionSort（min）;

System.out.println（min[0]）;

//System.out.println（mins[0]）;

int[][]tt=newint[9][9];

String[]ttt=mins[0].split（""）;

for（inti=0;i<8;i++）{

tt[i+1][Integer.valueOf（ttt[i]）]=1;

}

for（inti=0;i<8;i++）{

for（intj=0;j<8;j++）{

temp=temp+""+tt[i+1][j+1];

}

System.out.println（temp）;

temp="";

}

}

publicvoidselectionSort（int[]elements）{

for（inti=0;i

intk=i;

for（intj=i;j

if（elements[k]>elements[j]）{

k=j;

}

}

if（k!

=i）{//交换元素

inttemp=elements[i];

elements[i]=elements[k];

elements[k]=temp;

Stringss=mins[i];

mins[i]=mins[k];

mins[k]=ss;

}

}

}

publicbooleanctrl（intnn）{

intt1,t2,i,j,cont=0;

intxmin=0;

for（i=1;i<=nn;i++）

for（j=1;j<=nn;j++）yy[i][j]=0;

for（i=1;i<=nn;i++）{

if（x[i]>0）{

xmin=xmin+1;

for（j=1;j<=nn;j++）{yy[i][j]=1;yy[j][x[i]]=1;}

for（t1=i,t2=x[i];t1>=1&&t2>=1;t1--,t2--）yy[t1][t2]=1;

for（t1=i,t2=x[i];t1<=nn&&t2<=nn;t1++,t2++）yy[t1][t2]=1;

for（t1=i,t2=x[i];t1>=1&&t2<=nn;t1--,t2++）yy[t1][t2]=1;

for（t1=i,t2=x[i];t1<=nn&&t2>=1;t1++,t2--）yy[t1][t2]=1;

}

}

for（i=0;i<=nn;i++）

for（j=1;j<=nn;j++）cont+=yy[i][j];

return（cont==nn*nn）;

}

publicstaticvoidmain（String[]args）{

//TODOAuto-generatedmethodstub

Dtest=newD（）;

for（inti=0;i<25;i++）{

test.nQueen（8）;

}

test.min（）;

}

}

12.实验结果

13.实验题目E

餐巾计划问题

问题描述：

一个餐厅在相继的N天里，每天需要的餐巾数不尽相同。

假设第i天需要块餐巾（i=1,2，…，N）。

餐厅可以购买新的餐巾，每块餐巾的费用为p分；或者把旧餐巾送到快洗部，洗一块需要m天，其费用为f分；或者送到慢洗部，洗一块需要n天（n>m），费用s

但是每天洗好的餐巾和新购买的餐巾之和要满足当天的需求量。

试设计一个算法为餐厅合理地安排好N天中餐巾使用计划，使总的花费最少。

算法设计：

编程找到一个最佳餐厅使用计划。

数据输入：

N

P

m

f

n

s

3

10

2

3

3

2

第一天需要

5块

第二天需要

6块

第三天需要

7块

结果输出：

145

14.实验内容

#include

#include

#include

#include

#include"stdlib.h"

usingnamespacestd;

constintMAXN=2010;

constintINFS=0x3FFFFFFF;

structedge{

intfrom,to,cap,flow,cost;

edge（int_from,int_to,int_cap,int_flow,int_cost）

:

from（_from）,to（_to）,cap（_cap）,flow（_flow）,cost（_cost）{}

};

classMCMF{

public:

voidinitdata（intn）{

this->n=n;

edges.clear（）;

for（inti=0;i

G[i].clear（）;

}

voidaddedge（intu,intv,intcap,intcost）{

edges.push_back（edge（u,v,cap,0,cost））;

edges.push_back（edge（v,u,0,0,-cost））;

G[u].push_back（edges.size（）-2）;

G[v].push_back（edges.size（）-1）;

}

boolSPFA（ints,intt,int&flow,int&cost）{

for（inti=0;i

d[i]=INFS,inq[i]=false;

queueQ;

Q.push（s）;

d[s]=0,inq[s]=true,p[s]=0,a[s]=INFS;

while（!

Q.empty（））{

intu=Q.front（）;Q.pop（）;

inq[u]=false;

for（inti=0;i

edge&e=edges[G[u][i]];

if（e.cap>e.flow&&d[e.to]>d[u]+e.cost）{

d[e.to]=d[u]+e.cost;

p[e.to]=G[u][i];

a[e.to]=m