离散数学实验 C 关系的运算 幂运算 闭包运算.docx

离散数学实验 C 关系的运算 幂运算 闭包运算.docx

《离散数学实验 C 关系的运算 幂运算 闭包运算.docx》由会员分享，可在线阅读，更多相关《离散数学实验 C 关系的运算 幂运算 闭包运算.docx（7页珍藏版）》请在冰豆网上搜索。

离散数学实验C关系的运算幂运算闭包运算

实验2关系的运算

（1）关系的幂运算

输入：

集合A，二元关系集合R，幂次n

输出：

R的n次幂

要求：

尽量使运算的计算量最小

（2）关系闭包的计算

输入：

集合A，二元关系集合R

输出：

R的传递闭包t（R）

要求：

（a）采用Warshall算法（89页）

（b）编写代码判断输出t（R）为传递闭包

程序代码:

#include

#include

#include

usingnamespacestd;

typedefvector>Mat;

classRelation{

vectors;//集合

MatA;//关系矩阵

MatB;

MatC;

MatE;

MatD[100];//用来存储矩阵

intn;

public:

voidinputs（）;//将集合存入向量中

voidinputa（）;//将读入的关系转化为关系矩阵

voidprint（）;//输出关系矩阵

voidmi（）;

intWarshall（）;

};//定义类

intn,m;//全局变量，下文中使用

voidRelation:

:

inputs（）{

cout<<"输入集合";

for（inta;cin>>a;）{

s.push_back（a）;

if（getchar（）=='\n'）

break;}

}//将集合存入向量中

voidRelation:

:

inputa（）{//将读入的关系转化为关系矩阵

cout<<"输入关系";

inti,j,e,r;

for（i=0;i

vectoru;

for（j=0;j

intia=0;

u.push_back（ia）;}

A.push_back（u）;

B.push_back（u）;

C.push_back（u）;

E.push_back（u）;

}//创建二维向量，初始化，是每个元素为0

for（inth,z;cin>>h>>z;）{

if（h==0&&z==0）

break;

for（i=0;i

if（s[i]==h）e=i;

if（s[i]==z）r=i;

}

A[e][r]=1;B[e][r]=1;

E[e][r]=1;//C[e][r]=1;//读入关系，将关系对应的矩阵中的位置元素变为1

if（getchar（）=='\n'）

break;

}

}

voidRelation:

:

print（）{

for（inti=0;i

for（intj=0;j

cout<

cout<

}

}//输出关系矩阵

voidRelation:

:

mi（）{

inta,b,i,c;

cin>>n;//读入幂次

if（n==0）{//0次幂

for（intk=0;k

for（intj=0;j

if（k==j）

cout<<"1";//对角线上元素为1

else

cout<<"0";

}

cout<

}

}

else{

for（i=1;i

for（inth=0;h

for（intd=0;d

intm=0;

for（intx=0;x

m=m+B[h][x]*A[x][d];//第h行第d列的元素对应相乘的和

}

C[h][d]=m;

}

}

if（i>1）{

for（a=0;a

for（b=0;b

if（C[a][b]!

=D[0][a][b]）

break;

}

if（b!

=s.size（））break;

}

}//检验是否重复

if（a==s.size（）&&b==s.size（））{

break;//重复则跳出不再幂乘

}

for（intk=0;k

for（intj=0;j

B[k][j]=C[k][j];

}

D[i-1]=B;

c=i;

}

}

if（a==s.size（）&&b==s.size（））{

intq;

q=（n-i）%c;//找出结果位置

if（q==0）q=c;

for（inte=0;e

for（intf=0;f

cout<

}

cout<

}

return;

}else{//1次幂

for（inth=0;h

for（intn=0;n

cout<

}

cout<

}

}

}

}

intRelation:

:

Warshall（）{

for（inti=0;i

for（intj=0;j

if（A[j][i]==1）{

for（intk=0;k

A[j][k]=A[j][k]+A[i][k];

if（A[j][k]!

=0&&A[j][k]!

=1）

A[j][k]=1;

}

}

}

}

print（）;

inta=1;intb=1;//

for（intp=0;p

for（intl=0;l

if（A[p][l]==0）{

for（intx=0;x

if（A[p][x]*A[x][l]==1）

a=0;

}

}

}

}

if（a==0）{cout<<"wrong!

"<

else{

for（intp=0;p

for（intl=0;l

if（A[p][l]==1&&E[p][l]==0）{

A[p][l]=0;

//再判断传递性

for（intp=0;p

for（intl=0;l

if（A[p][l]==0）{

for（intx=0;x

if（A[p][x]*A[x][l]==1）

b=0;

}

}

}

}

if（b==1）{

cout<<"wrong!

"<

return0;

}

A[p][l]=1;

}

}

}cout<<"right!

"<

}//

return1;

}

voidmain（）{

Relationw;

w.inputs（）;

w.inputa（）;

w.print（）;

cout<<"输入n"<

w.mi（）;

cout<

cout<<"闭包为"<

w.Warshall（）;

}

实验截图：