组合数学实验报告.docx

组合数学实验报告.docx

《组合数学实验报告.docx》由会员分享，可在线阅读，更多相关《组合数学实验报告.docx（17页珍藏版）》请在冰豆网上搜索。

组合数学实验报告

组合数学实验报告

班级：

网络091班

姓名：

郭静

学号：

092566

实验一Fibonacci数非递归解

一、实验题目

Fibonacci数列

的定义如下：

请用递归方法和非递归方法求解该问题，各编写一个函数，要求函数接受

的值，返回

的值。

二、实验要求

1分别求

的情况。

2对比两个程序的执行时间，然后分别对两种算法进行复杂性分析。

三、实验源程序

#include

#include

usingnamespacestd;

//递归方式求解Fibonacci数列

doublemethodOneFibonacci（intn）

{

doubleresult;

if（n==1||n==2）

{

result=1;

}

else

{

result=methodOneFibonacci（n-2）+methodOneFibonacci（n-1）;

}

returnresult;

}

//非递归方式求解Fibonacci数列

doublemethodTwoFibonacci（intn）

{

doubleresult;

doublef1=1;

doublef2=1;

if（n==1||n==2）

{

result=1;

}

else

{

while（n-2）

{

result=f1+f2;

f1=f2;

f2=result;

n--;

}

}

returnresult;

}

double（*fibonacci）（intn）;

voiddeal（intn）

{

//计算结果

doubleresult;

//计算开始时间

clock_tstart;

//计算结束时间

clock_tfinish;

//计算花费的时间

doubleduration;

start=clock（）;

result=fibonacci（n）;

cout<<"theresultis"<

finish=clock（）;

duration=（（double）（finish-start））/CLOCKS_PER_SEC;

cout<<"spenttimeis"<

}

intmain（intargc,char*argv[]）

{

while

（1）

{

//参数，表述计算的规模

intn;

cout<<"inputthedatanis:

";

cin>>n;

if（n>0）

{

cout<<"采用非递归的方法进行求解：

"<

fibonacci=methodTwoFibonacci;

deal（n）;

cout<<"采用递归的方法进行求解：

"<

fibonacci=methodOneFibonacci;

deal（n）;

}

else

{

cout<<"niswrong,pleaseinputthenagain!

"<

}

}

return0;

}

四、实验结果

采用递归算法时消耗太多的时间。

五、实验总结

结果截图是递归算法与非递归算法的执行时间对比。

根据两种算法所写的程序的执行时间的的对比，非递归算法要比递归算法的效率要高很多。

而且随着n的逐渐增大，非递归算法的效率要远远超过递归算法的效率。

但是，采用递归算法编写的程序易于理解，并且易于编写。

实验二二项式系数的加法求解

一、实验题目

编写一个程序，只用加法，求出

中取

个的组合数

二、实验要求

1要求使用公式

，采用递归方法和非递归方法进行求解

2对两种算法进行分析

三、实验源程序

#include

#include

usingnamespacestd;

//采用递归方法求解组合数

intMethodOneCombinatorics（intn,intr）

{

intresult;

if（r==0||n==1||n==r）

{

result=1;

}

else

{

result=MethodOneCombinatorics（n-1,r）+MethodOneCombinatorics（n-1,r-1）;

}

returnresult;

}

//采用非递归方法求解组合数

intMethodTwoCombinatorics（intn,intr）

{

intresult;

intC1=1;

intC2=1;

if（r==0||n==1||n==r）

{

result=1;

}

else

{

int*tempCom=newint[n];

for（inti=0;i

{

tempCom[i]=1;

}

for（inti=2;i

{

for（intj=1;j

{

C1=C2;

C2=tempCom[j];

tempCom[j]=C1+C2;

}

}

result=tempCom[r-1]+tempCom[r];

}

returnresult;

}

int（*Combinatorics）（intn,intr）;

voiddeal（intn,intr）

{

intresult;

clock_tstart;

clock_tfinish;

doubleduration;

start=clock（）;

result=Combinatorics（n,r）;

cout<<"theC（"<

finish=clock（）;

duration=（（double）（finish-start））/CLOCKS_PER_SEC;

cout<<"spenttimeis"<

}

intmain（intargc,char*argv[]）

{

intn;

intr;

while

（1）

{

cout<<"inputthe（n,r）is:

";

cin>>n>>r;

if（r>n）

{

cout<<"thenandriswrong,pleaseretry!

"<

}

else

{

cout<<"采用非递归方式求解组合数：

"<

Combinatorics=MethodTwoCombinatorics;

deal（n,r）;

cout<<"采用递归方式求解组合数：

"<

Combinatorics=MethodOneCombinatorics;

deal（n,r）;

}

cout<<"-------------------------------------------"<

}

return0;

}

四、实验结果

五、实验总结

当n一定时，随着r的增大，递归算法的效率越来越低，但是非递归算法的效率所受的影响比较小；当r一定时，随着n的增大，递归算法的效率越来越低，但是非递归算法的效率所受的影响比较小。

所以随着n的增大，非递归算法的效率要远高于递归算法。

随着r的增大（r<=n/2），非递归算法的效率要远高于递归算法。

实验三所有K各元素的子集

一、实验题目

编写一个程序，用字典顺序列出n个元素的所有排列（Permutation）

二、实验要求

编写字典顺序求n个元素的所有排列。

三、实验源程序

#include

usingnamespacestd;

voidmain（）

{

intn,N;

cout<<"请输入元素个数:

";

cin>>N;

inti=0;

int*a=newint[N];

for（i=0;i

a[i]=i+1;

intj=0;

n=1;

intfac_N=1;

while（n++

//cout<

cout<

"<

for（i=0;i

cout<

cout<

for（i=1;i

{

intmax_j=0,max_k=0;

for（j=0;j

{

if（a[j]

max_j=j+1;

}

for（j=0;j

{

if（（max_j>0）&&（a[max_j-1]

max_k=j;

}

inttemp;

if（max_j>0）

{

temp=a[max_j-1];

a[max_j-1]=a[max_k];

a[max_k]=temp;

}

for（j=max_j;j<=max_j+（N-1-max_j）/2;j++）

{

temp=a[j];

a[j]=a[N-1+max_j-j];

a[N-1+max_j-j]=temp;

}

for（intii=0;ii

cout<

cout<

}

cout<

system（"PAUSE"）;

}

四、实验结果

五、实验总结

字典顺序法是生成排列数的一种比较简单的算法，生成的效率也比较高。

字典顺序法生成的排列数按照由大到小的顺序排列，呈现一定的规律性。

通过字典顺序法的学习，掌握了生成排列数的一种方法。

实验四整数的所有不同分割数目

一、实验题目

编写一个递归程序，输入一个正整数，输出它不同分割方式的数目

二、实验要求

用P（n,m）表示在n的分割中极大值最多为m的分割数，亦即分割具有n=m+…，n=m+m+…,n=m+m+m+…，这一类形式。

于是n与m的关系不外乎一下几种情况：

（1）m为1

（2）n为1

（3）n=m

（4）n

（5）n>m

显然，前两种情况是递归结束的条件，后三种情况请写出各自的递归公式，并编写程序实现之。

三、实验源程序

#include

usingnamespacestd;

intcomminuteInteger（intn,intm）

{

if（n==1||m==1）

{

return1;

}

if（n

{

returncomminuteInteger（n,n）;

}

if（n==m）

{

return1+comminuteInteger（n,m-1）;

}

returncomminuteInteger（n,m-1）+comminuteInteger（n-m,m）;

}

intmain（intargc,char*argv[]）

{

intn;

intresult;

while

（1）

{

cout<<"pleaseinputaintegern:

";

cin>>n;

result=comminuteInteger（n,n）;

cout<<"theintegern'stotalnumberis:

"<

}

return0;

}

四、实验结果

五、实验总结

递推公式如下：

实验五产生所有排列——旋转法

一、实验题目

编写一个程序，用旋转顺序（rotationorder）法，列出n个元素的所有排列。

二、实验要求

编写旋转顺序求n个元素的所有排列。

三、实验源程序

#include

#include

#include

#defineM4//链表的最大长度

//longcount=0;

voidSolve（intn,inta[]）;

intmain（void）

{

inti;

intSource[M]={0};//用来存储输入的数据，数据可重复

printf（"请输入%d个数字：

",M）;

for（i=0;i

scanf（"%d",&Source[i]）;

printf（"\n你输入的数据为：

\n"）;

Solve（M,Source）;//数据处理部分

//printf（"\ncount=%d",count）;

system（"pause"）;

return0;

}

voidSolve（intk,inta[]）

{

if（k==1）

{

//count++;

for（inti=0;i

printf（"%d",a[i]）;

printf（"\n"）;

}

else

{

for（inti=M-k;i

{

intt=a[M-k];

a[M-k]=a[i];

a[i]=t;

Solve（k-1,a）;

t=a[M-k];

a[M-k]=a[i];

a[i]=t;

}

}

}

四、实验结果