闭包运算实验报告
传递闭包实验报告
一、实验目的1. 理解传递闭包的概念及其在图论中的应用。
2. 掌握利用Floyd-Warshall算法求解传递闭包的方法。
3. 通过编程实现传递闭包的计算，验证算法的正确性。
4. 分析实验结果，加深对传递闭包性质的理解。
二、实验原理传递闭包是指在给定集合X上的二元关系R，找到一个最小的传递关系R，使得对于任意的x, y, z∈X，若xRy且yRz，则xRz成立。
传递闭包可以用来描述图中节点之间的可达性，是图论中一个重要的概念。
Floyd-Warshall算法是一种求解传递闭包的经典算法，它通过构建一个n×n的邻接矩阵A，其中A[i][j]表示节点i到节点j的可达性。
算法的基本思想是：逐步更新矩阵A，使得A[i][j]的值表示节点i到节点j的最短路径可达性。
三、实验内容1. 设计一个图，包括节点和边，并构建相应的邻接矩阵。
2. 利用Floyd-Warshall算法计算邻接矩阵的传递闭包。
3. 分析传递闭包的结果，验证算法的正确性。
4. 对比不同图结构下的传递闭包计算结果，探讨传递闭包的性质。
四、实验步骤1. 设计一个图，包括5个节点和6条边，如下所示：```1 -- 2| || |3 -- 4| || |5 -- 6```2. 构建邻接矩阵A，如下所示：```| 1 2 3 4 5 6 |1| 0 1 0 0 0 0 |2| 0 0 1 0 0 0 |3| 0 0 0 1 0 0 |4| 0 0 0 0 1 0 |5| 0 0 0 0 0 1 |6| 0 0 0 0 0 0 |```3. 编写Floyd-Warshall算法的代码，计算传递闭包。
```pythondef floyd_warshall(adj_matrix):n = len(adj_matrix)for k in range(n):for i in range(n):for j in range(n):if adj_matrix[i][j] > adj_matrix[i][k] + adj_matrix[k][j]:adj_matrix[i][j] = adj_matrix[i][k] + adj_matrix[k][j]return adj_matrix# 初始化邻接矩阵adj_matrix = [[0, 1, 0, 0, 0, 0],[0, 0, 1, 0, 0, 0],[0, 0, 0, 1, 0, 0],[0, 0, 0, 0, 1, 0],[0, 0, 0, 0, 0, 1],[0, 0, 0, 0, 0, 0]]# 计算传递闭包transitive_closure = floyd_warshall(adj_matrix) print(transitive_closure)```4. 分析传递闭包的结果，验证算法的正确性。
二值形态学基本运算实验报告
3.开运算：
void CImageProcessingDoc::Onimageopening()
{ // TODO: Add your command handler code here CImageProcessingDoc::Onimageerosion();//先调用二值腐蚀 CImageProcessingDoc::Onimagedilation(); //再调用二值膨胀 }
2.腐蚀：
void CImageProcessingDoc::Onimageerosion() { // TODO: Add your command handler code here int m_Width, m_Height, m_SaveWidth; m_Width = m_pDibInit->GetWidth(); m_Height = m_pDibInit->GetHeight(); m_SaveWidth = m_pDibInit->GetSaveWidth(); int i,j; double *y=new double[m_Width*m_Height]; for(j=1;j<m_Height;j++) //将图像数据赋予新开辟内存空间 { for(i=1;i<m_Width;i++) {
二值形态学基本运算实验报告
1、 实验目的
1. 法； 2. 学会二值形态学的基本运算：膨胀、腐蚀、开启和闭合； 3. 掌握膨胀、腐蚀、开启和闭合的物理意义。 掌握二值形态学的思想，进一步掌握图像处理和分析的实用算
2、 实验原理 （1） 膨胀：
;
（2） 腐蚀：
;
（3） 开运算：
;
（4） 闭运算：
离散实验报告
离散实验报告专业：数学与应用数学班级：091121学号：2009112125姓名：张鼎珩日期：2011.06.23实验内容：实验一真值计算实验二两个集合运算实验三关系闭包计算实验四关系与函数进行试验：实验一真值计算一、实验目的熟悉联结词合取、析取、条件和双条件的概念，编程求其真值。
二、实验内容(1)求任意一个命题公式的真值表：从键盘输入两个命题P 和Q的真值，求它们的合取、析取、蕴含和等价的真值(2)利用真值表求任意一个命题公式的主范式(3)利用真值表进行逻辑推理三实验程序：#include<stdio.h>/*标准输入输出头文件*/#include<stdlib.h>/*该文件包含了的C语言标准库函数的定义*/#include<string.h>/*字符串数组的函数定义的头文件*/#include<conio.h>/*通用输入输出库*/#include<math.h>#define N 50void jisuan();void zhenzhibiao();void panduan(int b[N],int f);int tkh (char sz[N], char ccu[N], int icu[N], int h0);int fkh (char sz[N], char ccu[N], int icu[N], int h0);main(){int a1;start:do{printf(" 1.求P、Q的合取、析取、条件和双条件的真值\n 2.求任意一个命题公式的真值表，并根据真值表求主范式\n 3.退出\n");printf("\n选择功能选项:");fflush(stdin);/*清空输入缓冲区，通常是为了确保不影响后面的数据读取*/scanf("%d",&a1);switch(a1)/*switch语句实现选择功能*/{case 1:system("cls");jisuan();break;/*功能A*/case 2:system("cls");fflush(stdin);zhenzhibiao();break;/*功能BC*/case 3:system("exit");exit(0);/*结束整个程序的运行*/default:system("cls");goto start;/*控制流转移到start处*/}}while(1);}void jisuan()/*功能A*/{char p,q,t,ch;int p1,q1;do{start:fflush(stdin);printf("请输入P和Q的真值(T或F):");scanf("%c,%c",&p,&q);if((p=='F'||p=='f'||p=='T'||p=='t')&&(q=='F'||q=='f'||q=='T'||q=='t')){if(p=='F'||p=='f')/*赋值*/p1=0;elsep1=1;if(q=='F'||q=='f')q1=0;elseq1=1;if(p1|q1)/*计算*/t='T';elset='F';printf("P析取Q为:%c\n",t);if(p1&q1)t='T';elset='F';printf("P和取Q为:%c\n",t);if((!p1)|q1)t='T';elset='F';printf("P条件Q为:%c\n",t);if(p1==q1)t='T';elset='F';printf("P双条件Q为:%c\n",t);}else{printf("请按正确格式输入!\n");goto start;};printf("是否继续输入?Y/N");fflush(stdin);ch=getch();system("cls");}while(ch!='n'&&ch!='N');}void zhenzhibiao()/*功能BC*/{int i1,i2,d=1,icu[N],kh=0,jg,j=0,h0;int bj=0,hq[N],h=0,x=0,xq[N];char sz[N],ccu[N],sz0[N];hq[0]=-1;xq[0]=-1;printf("请输入一个合法的命题公式(可含与或非及括号):\n");gets(sz);strcpy(sz0,sz);for(i1=0;i1<strlen(sz);i1++){if(sz[i1]==')' || sz[i1]=='(')kh++;if(sz[i1]>='a' && sz[i1]<='z' || sz[i1]>='A' && sz[i1]<='Z'){for(i2=0;i2<j;i2++) /*判断并储存变量*/if(ccu[i2]==sz[i1])d=0;if(d==1){ccu[j]=sz[i1];j++;}d=1;}}printf("\n该式子中的变量个数为：%d\n",j);h0=j;printf("\n输出真值表如下：\n \n");for(i1=0;i1<h0;i1++)printf(" %c ",ccu[i1]);printf(" ");puts(sz);printf("\n");for(i1=0;i1<j;i1++) /*先将所有的变量赋值为零*/icu[i1]=0;for(i2=0;i2<j;i2++)printf(" %d ",icu[i2]);jg=tkh(sz,ccu,icu,h0);if(jg==0)hq[h++]=bj;elsexq[x++]=bj;printf(" ------> %d\n",jg);strcpy(sz,sz0);for(i1=0;i1<(int)pow(2,j)-1;i1++){++bj;panduan(icu,0); /*赋值变量*/jg=tkh(sz,ccu,icu,h0);if(jg==0)hq[h++]=bj;elsexq[x++]=bj;strcpy(sz,sz0); /*恢复被修改的数组*/for(i2=0;i2<j;i2++)printf(" %d ",icu[i2]);printf(" ------> %d\n",jg);}if(hq[0]==-1)printf("\n该命题公式不存在主合取范式。
闭包运算的实验报告
一、实验目的1. 理解闭包运算的概念及其在离散数学中的应用。
2. 掌握关系闭包运算（自反闭包、对称闭包、传递闭包）的求解方法。
3. 利用编程语言实现关系闭包运算，并分析实验结果。
二、实验内容1. 自反闭包运算：给定一个关系R，求出R的自反闭包R^。
2. 对称闭包运算：给定一个关系R，求出R的对称闭包R^s。
3. 传递闭包运算：给定一个关系R，求出R的传递闭包R^t。
三、实验环境1. 操作系统：Windows 102. 编程语言：Python3.73. 开发工具：PyCharm四、实验步骤1. 定义关系R：以矩阵形式表示关系R，其中R[i][j]表示元素i和元素j之间的关系，1表示存在关系，0表示不存在关系。
2. 求自反闭包R^：a. 初始化一个与R同样大小的矩阵R^。
b. 遍历R^，对于每个元素R^[i][j]，若R[i][j]=1或i=j，则R^[i][j]=1。
3. 求对称闭包R^s：a. 初始化一个与R同样大小的矩阵R^s。
b. 遍历R，对于每个元素R[i][j]，若R[i][j]=1，则R^[i][j]=1且R^[j][i]=1。
c. 遍历R^s，对于每个元素R^[i][j]，若R^[i][j]=1，则R^[j][i]=1。
4. 求传递闭包R^t：a. 初始化一个与R同样大小的矩阵R^t。
b. 遍历R，对于每个元素R[i][j]，若R[i][j]=1，则R^[i][j]=1。
c. 循环执行以下步骤，直到R^t不再变化：i. 遍历R^t，对于每个元素R^[i][j]，若R^[i][k]=1且R^[k][j]=1，则R^[i][j]=1。
五、实验结果与分析1. 自反闭包运算：给定关系R如下：0 1 01 0 10 1 0求自反闭包R^，结果如下：1 1 11 1 11 1 12. 对称闭包运算：给定关系R如下：0 1 01 0 10 1 0求对称闭包R^s，结果如下：1 1 11 1 11 1 13. 传递闭包运算：给定关系R如下：0 1 01 0 10 1 0求传递闭包R^t，结果如下：1 1 11 1 11 1 1通过实验，我们可以发现：1. 自反闭包运算使得关系R中的所有元素都与自身存在关系。
离散数学试验报告
学院理学院学生姓名 xxx学号 xxxxxxxxxxx实验：编程二元关系的传递性判别，二元关系闭包方法一．前言引语：二元关系是离散数学中重要的内容。
因为事物之间总是可以根据需要确定相应的关系。
从数学的角度来看，这类联系就是某个集合中元素之间存在的关系。
二．数学原理：1．传递关系：对任意的x,y,z∈A，如果<x,y>∈R且<y,z>∈R，那么<x,z>∈R，则称关系R是传递的，或称R具有传递性，即R在A上是传递的⇔ (∀x)(∀y)(∀z)[(x ∈A)∧(y∈A)∧(z∈A)∧((<x,y>∈R)∧(<y,z>∈R)→(<x,z>∈R))]=12．自反闭包、对称闭包、传递闭包：设R是定义在A上的二元关系，若存在A 上的关系R′满足：1)R′是自反的(或对称的、或可传递的)，2)R⊆ R′，3)对A上任何其它满足1）和2）的关系R〞，都有：R′⊆R〞。
则称R′为R的自反闭包(或对称闭包、或传递闭包)，分别记为r(R)、(s(R)和t(R))。
三．实验编程语言：c++四．实验程序源代码：#include<iostream>using namespace std;int cdx(int a[100][100],int n){int b[100][100],i,j;for(i=1;i<=n-1;i++){for(j=1;j<=n;j++){if(a[1][j]==a[i+1][j] && a[1][j]==0)b[i][j]=0;elseb[i][j]=1;}for(j=1;j<=n;j++){if(b[i][j]!=a[1][j])return 0;}}return 1;}void zfbb(int a[100][100],int n){int i,j;for(j=1;j<=n;j++){for(i=1;i<=n;i++){if(a[i][j]==1){a[i][i]=1;a[j][j]=1;}}}cout<<"自Á?反¤¡ä闭À?包㨹关?系¦Ì矩?阵¨®为a：êo"<<endl;for(i=1;i<=n;i++){for(j=1;j<=n;j++){if(a[i][j]>1){a[i][j]=1;cout<<a[i][j]<<" ";}else{cout<<a[i][j]<<" ";}}cout<<""<<endl;}}void dcbb(int a[100][100],int n){int i,j;for(j=1;j<=n;j++){for(i=1;i<=n;i++){if(a[i][j]==1){a[j][i]=1;}}}cout<<"对?称?闭À?包㨹关?系¦Ì矩?阵¨®为a：êo"<<endl;for(i=1;i<=n;i++){for(j=1;j<=n;j++){if(a[i][j]>1){a[i][j]=1;cout<<a[i][j]<<" ";}else{cout<<a[i][j]<<" ";}}cout<<""<<endl;}}void cdbb(int a[100][100],int n){int i,j,k;for(j=1;j<=n;j++){for(i=1;i<=n;i++){if(a[i][j]==1){for(k=1;k<=n;k++){a[i][k]=a[i][k]+a[j][k];}}}}cout<<"传ä?递ÌY闭À?包㨹关?系¦Ì矩?阵¨®为a：êo"<<endl;for(i=1;i<=n;i++){for(j=1;j<=n;j++){if(a[i][j]>1){a[i][j]=1;cout<<a[i][j]<<" ";}else{cout<<a[i][j]<<" ";}}cout<<""<<endl;}}void main(){int i,j,n,a[100][100],sel,ins;cout<<"请?输º?入¨?二t元a关?系¦Ì矩?阵¨®维?数ºyn"<<endl;cin>>n;cout<<"请?按ã¡äa[1,1],a[1,2]...a[1,n],a[2,1]...a[n.n]的Ì?顺3序¨©输º?入¨?关?系¦Ì矩?阵¨®的Ì?元a素?值¦Ì（ꡧ0，ê?1）ê?"<<endl;for(i=1;i<=n;i++)for(j=1;j<=n;j++){cin>>a[i][j];}INDEX:cout<<"请?输º?入¨?要©a判D定¡§的Ì?性?质¨º：êo"<<endl;cout<<"1、¡é传ä?递ÌY性?"<<endl;cout<<"2、¡é自Á?反¤¡ä闭À?包㨹"<<endl;cout<<"3、¡é对?称?闭À?包㨹"<<endl;cout<<"4、¡é传ä?递ÌY闭À?包㨹"<<endl;cout<<"5、¡é退ª?出?"<<endl;cin>>sel;if(sel==1){ins=cdx(a,n);if(ins==0)cout<<"该?二t元a关?系¦Ì不?具?有®D传ä?递ÌY性?。
实验一传递闭包的实现
实验一传递闭包的实现实验一：传递闭包的实现摘要：本实验通过使用离散数学中的传递闭包的概念，设计了一种算法来实现传递闭包的计算。
实验首先介绍了传递闭包的定义和性质，然后详细描述了实现算法的步骤。
接着，通过编程语言来实现算法，并使用一个具体的例子进行了测试。
最后，对实验结果进行了分析和总结，验证了算法的正确性和有效性。
1.引言在离散数学中，传递闭包是一个重要的概念，它在关系理论以及图论中都有广泛的应用。
传递闭包是指对于给定集合上的关系R，存在一个最小的传递关系R'，它是R的一个子关系且满足传递性。
计算传递闭包的问题是离散数学中的一个经典问题，解决该问题对于理解传递关系的性质以及进行相应的推理和分析非常重要。
2.传递闭包的定义和性质给定集合A上的关系R，传递闭包R'满足以下条件：-R'是R的一个子关系，即R'⊆R；-R'是传递的，即对于任意的a,b,c∈A，如果aR'b且bR'c，则aR'c。
传递闭包的计算有多种方法，本实验将介绍一种基于矩阵运算的方法。
3.实现算法的步骤给定集合A和关系R，计算传递闭包R'的步骤如下：1)构建集合A上的关系矩阵M，其中M[i][j]表示a[i]Rb[j]是否成立；2)对矩阵M进行幂运算，即计算M的n次幂，其中n为集合A的元素个数；3)对矩阵M每个元素进行逻辑或运算，得到最终的传递闭包关系矩阵；4)根据传递闭包关系矩阵构建传递闭包关系R'。
4.实现代码及测试下面给出了使用Python实现传递闭包计算的代码：```pythondef transitive_closure(A, R):n = len(A)M = [[False] * n for _ in range(n)]for i, a in enumerate(A):for j, b in enumerate(A):if (a, b) in R:M[i][j] = Truefor k in range(n):for i in range(n):for j in range(n):M[i][j] = M[i][j] or (M[i][k] and M[k][j])R_prime = []for i in range(n):for j in range(n):if M[i][j]:R_prime.append((A[i], A[j]))return R_prime#测试A=[1,2,3,4]R=[(1,2),(2,3),(3,4)]R_prime = transitive_closure(A, R)print("传递闭包R'：", R_prime)```运行以上代码，输出结果为：```传递闭包R'：[(1,2),(1,3),(1,4),(2,3),(2,4),(3,4)]```可以看到，计算得到的传递闭包R'包含了所有满足传递性的关系。
离散数学上机实验报告
一、实验内容
从键盘输入二元关系用沃尔算法求出它的传递闭包，并输出。
二、实验步骤
熟悉沃尔算法，然后将其用程序编写出来，任意输入二元关系，观察程序运行结果，
用另一种算法算出结果，与其比较，调试程序。
三、实验代码
#include<stdio.h>
int main()
{
int n,i,j,k,a[10][10];
printf("﹁q=0\n");
printf("p∧q=1\n");
printf("p∨q=1\n");
printf("p→q=1\n");
printf("p<->q=1\n");
}
continue;
}
if('n'==t)
break;
}
return 0;
}
四、实验体会
求真值运算中，应注意各种连接词的试用方法，以及其在不同情况下的真值。
printf("\n");
}
return 0;
}
四、实验体会
熟悉并使用沃尔算法，关系矩阵中只有0和1，所以用沃尔算法求得的数若大于1，应该返回1，其余不变。
实验四、三种闭包运算
一、实验内容
从键盘输入一个二元关系，求它的自反闭包，对称闭包，传递闭包，并输出。
二、实验步骤
编写程序，从键盘输入一个二元关系，当求传递闭包时，试与沃尔算法的传递闭包做比较，观察程序运行结果，调试程序。
char t;
while(t)
{
printf("是否运算程序(y/n):\n");
数据运算实验报告总结(3篇)
第1篇一、实验背景随着科学技术的不断发展，数据处理与分析已成为各个领域不可或缺的重要环节。
为了更好地掌握数据运算的基本原理和方法，我们开展了数据运算实验，通过实际操作加深对数据运算的理解和应用。
本次实验旨在提高我们对数据处理与分析技能的掌握，为后续学习与研究打下坚实基础。
二、实验目的1. 掌握数据运算的基本概念和常用方法；2. 熟悉各类数据运算工具的使用；3. 提高数据处理的实际操作能力；4. 培养团队合作精神与交流能力。
三、实验内容本次实验主要包括以下内容：1. 数据的收集与整理：通过调查问卷、网络爬虫等手段获取数据，并进行数据清洗和预处理；2. 数据的统计分析：运用统计软件对数据进行描述性统计分析、推断性统计分析等；3. 数据的建模与预测：根据实际需求，选择合适的模型对数据进行建模，并对未来趋势进行预测；4. 数据可视化：运用图表、图形等方式展示数据，以便更好地理解和分析。
四、实验过程1. 数据收集与整理：本次实验以我国某地区居民消费数据为例，通过网络爬虫获取相关数据，并使用Python进行数据清洗和预处理，包括去除缺失值、异常值等；2. 数据统计分析：运用Python中的Pandas、NumPy等库对数据进行描述性统计分析，如计算均值、方差、标准差等，并绘制直方图、箱线图等图表；3. 数据建模与预测：针对消费数据，选择线性回归模型进行建模，运用Python中的scikit-learn库进行训练和预测，并对预测结果进行评估；4. 数据可视化：运用Python中的matplotlib、seaborn等库，将统计数据、模型预测结果以图表形式展示，便于直观理解。
五、实验结果与分析1. 数据收集与整理：通过数据清洗和预处理，提高了数据质量，为后续分析奠定了基础；2. 数据统计分析：描述性统计分析结果显示，居民消费水平整体呈上升趋势，其中食品、教育、医疗等消费支出占比较大；3. 数据建模与预测：线性回归模型对消费数据的拟合度较高，预测结果与实际数据基本吻合；4. 数据可视化：通过图表展示，直观地反映了居民消费趋势和结构，为相关决策提供了参考。
闭包运算实验报告
一、实验目的了解和掌握闭包运算的概念，熟悉Warshall算法，掌握求关系的自反闭包、对称闭包和传递闭包的方法。
二、实验内容从键盘输入一个关系的关系矩阵，计算其自反闭包、对称闭包和传递闭包，传递闭包要求使用Warshall算法，用C语言实现。
三、思路分析（即代码分析）声明：R[][]表示关系R；x[]表示集合X; r[]表示自反闭包；s[]表示对称闭包；t[]表示传递闭包（一），输入形式：先输出提示符：请先输入集合X中元素的个数，之后输入集合X中的元素（不同元素之间用空格隔开,行末用回车结束）:第一行：先输入集合X中元素的个数n，空一格之后输入集合X中的元素，不同元素之间用空格隔开,行末用回车结束:输出提示符：请先输入集合X上的二元关系R的序偶对个数，再输入集合X上的二元关系R,每一对序偶用a,b表示，序偶之间用空格隔开，行末用回车结束：第二行：先输入集合X上的二元关系R的序偶对个数，空一格之后输入集合X上的二元关系R,每一对序偶用a,b表示，序偶之间用空格隔开，行末用回车结束：（二）、输入记录：记录时将X中的元素按照输入的次序依次编号，存储在数组x[]中对应编号的位置1，通过输入的集合X中元素的个数n来控制之后的元素输入循环次数；2，通过输入的集合X上二元关系序偶对的个数来控制之后序偶对的输入循环次数；3，输入序偶对时，每次直接输入到临时变量a，b中，之后在集合x[]中遍历，找到此次输入的序偶对在x[]所对应的位置，之后将二维矩阵R[][]对应位置置1，表示有此对应关系（三），自反闭包计算将关系R[][]复制到自反闭包 r[][] 矩阵中，之后将行数等于列数的元素置1，便按照自反闭包定义将矩阵r[][]扩充到符合要求（四），对称闭包计算扫瞄关系矩阵R[][]，记录其中不为1的元素的行列数，之后将对称矩阵s[][]相应的行列数和行数和列数相反的位置都置1；便按照对称闭包定义将矩阵r[][]扩充到符合要求（五），传递闭包计算1，按照Warshall算法，先将R[][]复制到r[][]中，2，遍历r[][]的每列，在每列中找到不为0的元素r[i][j]，之后将j行与i行对应的元素进行逻辑加，将结果赋值到第i行上去；3，遍历完每一列后所得的矩阵就是传递闭包的对应矩阵四、实验结果与分析对于输出的闭包关系中，每对序偶用a，b表示，序偶之间用空格隔开，每输出一次用回车结束（例）每次输出时先输出提示符：关系R的自反闭包为：Sample Output：关系R的自反闭包为：a,a a,b b,b b,d c,a c,c d,d d,e e,b e,e关系R的对称必包为：a,b a,c b,a b,d b,e c,a d,b d,e e,b e,d关系R的传递必包为：a,b a,d a,e b,b b,d b,e c,a c,b c,d c,e d,b d,d d,e e,b e,d e,e五、VS2010中验证结果（全视图）：请先输入集合X中元素的个数，之后输入集合X中的元素（不同元素之间用空格隔开,行末用回车结束）:5 a b c d e请先输入集合X上的二元关系R的序偶对个数，再输入集合X上的二元关系R,每一对序偶用a,b表示，序偶之间用空格隔开，行末用回车结束：5 a,b b,d c,a d,e e,b关系R的自反闭包为：a,a a,b b,b b,d c,a c,c d,d d,e e,b e,e关系R的对称必包为：a,b a,c b,a b,d b,e c,a d,b d,e e,b e,d关系R的传递必包为：a,b a,d a,e b,b b,d b,e c,a c,b c,d c,e d,b d,d d,e e,b e,d e,e 请按任意键继续. . .六、实际输出：。
实验一 传递闭包的实现(离散数学实验报告)
实验一传递闭包算法一、实验目的1、理解关系矩阵作为布尔矩阵的逻辑运算2、通过编程深刻理解Warshall快速算法3、验证Warshall快速算法的正确性4、掌握C语言的编程技巧和方法二、实验内容用C语言编程实现传递闭包的Warshall快速算法三、实验原理（Warshall算法的原理）M[i,j]表示关系R的关系矩阵M中元素若在关系R的关系图中存在从v i到v j的有向路径，则M[i,j]=1；否则M[i,j]=0。
定义：M k[i,j]=1 若在关系R的关系图中存在从v i到v j的有向路径,且这条路上除了v1，v2，┉，v k外没有其它节点否则M[i,j]=0即M0[i,j]=1⇔在关系R的关系图中存在从v i到v j的有向边M1[i,j]=1⇔在关系R的关系图中存在从v i到v j的有向路径,且这条路上除了可能有v1外没有其它节点M2[i,j]=1⇔在关系R的关系图中存在从v i到v j的有向路径,且这条路上除了可能有v1，v2外没有其它节点┉┉┉根据此定义，仅当下列两情形之一发生时，M k[i,j]=1（1）存在从v i到v j的有向路径，且这条路上除了可能有v1，v2，┉，v k-1外没有其它节点。
因此M k-1[i,j]=1（2）存在从v i到v k的有向路径和从v k到vj的有向路径,且每条路上除了可能有v1，v2，┉，v k-1外没有其它节点。
因此M k-1[i,k]=1 且M k-1[k,j]=1因此，M k[i,j]= M k-1[i,j] ∨（M k-1[i,k]=1∧M k-1[k,j]=1）四、实验要求：1、对输入的数据进行合法性检查，输入输出界面友好2、编写和调试完成程序3、保存和打印程序的运行结果五、实验步骤(一)算法描述Step 1 初始化MStep 2 刷新M 对k=1,2,┉n 重复Step 3和Step 4Step 3 刷新行对i=1,2,┉n 重复Step 4Step 4 刷新M ij对j=1,2,┉n置M ij=M ij ∨（M ik∧M kj）[结束Step 3循环][结束Step 2循环]Step 5 退出（二）流程图┉┉┉┉┉（三）程序清单┉┉┉┉┉六、测试数据1、输入关系矩阵的传递闭包的关系矩阵：R1=⎪⎪⎪⎭⎫⎝⎛001011001， R2=⎪⎪⎪⎪⎪⎭⎫ ⎝⎛0010001001000011， R3=⎪⎪⎪⎪⎪⎪⎭⎫⎝⎛0000000000110000010110010 输出的结果应为：t(R1)=⎪⎪⎪⎭⎫ ⎝⎛001011001， t(R2)=⎪⎪⎪⎪⎪⎭⎫⎝⎛0110011001100111，t(R3)=⎪⎪⎪⎪⎪⎪⎭⎫⎝⎛0000000000110001111111111参考程序：#include<stdio.h>#define N 3int main(){int i,j,k,M[N][N];printf("put in data 0 or 1\n");for(i=0;i<N;i++)for(j=0;j<N;j++)scanf("%d",&M[i][j]);printf("mibao:\n");for(k=0;k<N;k++)for(i=0;i<N;i++)for(j=0;j<N;j++)if((M[i][k]&&M[k][j])||M[i][j]) M[i][j]=1;for(i=0;i<N;i++){for(j=0;j<N;j++)printf(" %d",M[i][j]);printf("\n");}}输出结果：。
离散数学实验指导
实验1 关系的闭包运算1、实验类型：设计性2、实验目的通过算法设计并编程实现求给定关系的各种闭包运算，加深学生对闭包运算的概念的理解。
3、实验内容给定关系R，求R的自反闭包、对称闭包及R的传递闭包。
4、实验原理若关系R的关系矩阵为M，而自反闭包为A（即r（R）=A），对称闭包为B（即S （R）=B），则A=M∨I B=M∨M T 其中，I为恒等矩阵，M T为M的转置矩阵。
5、实验仪器设备或软件环境及工具运行Windows 或Linux操作系统的PC机，具有gcc(Linux)、Turboc、Vc(Windows)等C语言的编译环境。
6、实验要求复习关系闭包的定义，实验由一人一组完成。
所编程序能够通过编译，并能够实现求出给定关系的闭包的运算。
7、实验报告要求（1）写出实验过程中遇到的问题及其解决过程。
（2）写出类c的算法并编写一个程序求出给定关系的闭包。
（3）写出实验结束时的程序清单及运行结果及实验总结。
实验2 最小生成树的Kruskal算法1、实验类型：设计性2、实验目的通过算法设计并编程实现求出给定无向连通加权图的一棵最小生成树，加深学生对求最小生成树的Kruskal算法的理解。
3、实验内容给定无向连通加权图，编程设计求出其一棵最小生成树。
4、实验原理设所给定无向连通加权图具有n个结点，m条边，首先，将各条边的权按从小到大的顺序排序。
然后依次将这些边按所给图的结构放到生成树中去。
如果在放置某一条边时，使得生成树形成回路，则删除这条边。
这样，直至生成树具有n-1条边时，我们所得到的就是一棵最小生成树。
5、实验仪器设备或软件环境及工具运行Windows 或Linux操作系统的PC机，具有gcc(Linux)、Turboc、Vc、CFree(Windows)等C语言的编译环境。
6、实验要求复习树及最小生成树的定义，实验由一人一组完成。
所设计程序能够通过编译，并能够求出给定无向连通加权图的一棵最小生成树。
离散数学二元关系传递性判别、闭包方法实验报告材料
离散数学二元关系传递性判别、闭包方法实验报告学院：理学院班级：11信息与计算科学1班姓名：*** 学号：*************一、实验目的1. 通过上机程序，进一步加深对二元关系传递性判别，自反闭包，对称闭包，传递闭包的理解。
2. 掌握传递性判别，Warshall算法。
3. 学会用程序解决离散数学中的问题。
4. 增强我们编写程序的能力二、实验内容实验1：二元关系传递性判别实验2：有限集上给定关系的自反、对称和传递闭包（用Warshall算法）。
三、实验环境在microsoft visual c++实验环境下完成的，而所设计的程序也在这个环境下通过了编译，运行和测试。
四、实验原理和实现过程实验1：#include <iostream>using namespace std;void main(){int n,i,j,k;int m=0; //m是判断传递关系计数参数cout<<"请输入矩阵的行列数n:";cin>>n;int a[20][20];for(i=1;i<=n;i++){for(j=1;j<=n;j++){cout<<"请输入a["<<i<<"]["<<j<<"]:";cin>>a[i][j];}} //输入R矩阵cout<<"R的关系矩阵为："<<endl;for(i=1;i<=n;i++){for(j=1;j<=n;j++){cout<<a[i][j]<<" ";}cout<<endl;} //输出R矩阵for(i=1;i<=n;i++){for(j=1;j<=n;j++){if(a[i][j]!=0){for(k=1;k<=n;k++){if(a[i][k]<a[j][k] //利用布尔加的特征，前一行数大于后一行{m=m+1; //如果有一个数不成立，m加1}}}}}if(m==0) cout<<"R有传递关系"<<endl;else cout<<"R没有传递关系"<<endl;}实验2:1)自反闭包#include <iostream>using namespace std;void main(){int n,i,j;cout<<"请输入矩阵的行列数n:";cin>>n;int a[20][20];for(i=1;i<=n;i++){for(j=1;j<=n;j++){cout<<"请输入a["<<i<<"]["<<j<<"]:";cin>>a[i][j];}}cout<<"R的关系矩阵为："<<endl;for(i=1;i<=n;i++){for(j=1;j<=n;j++){cout<<a[i][j]<<" ";}cout<<endl;}for(i=1;i<=n;i++){for(j=1;j<=n;j++){if(a[i][j]!=0){a[i][i]=1;a[j][j]=1; //把符合条件的对角线上的值改为1 }}}cout<<"R的关系矩阵为："<<endl;for(i=1;i<=n;i++){for(j=1;j<=n;j++){cout<<a[i][j]<<" ";}cout<<endl;}}2)对称闭包#include <iostream>using namespace std;void main(){int n,i,j;cout<<"请输入矩阵的行列数n:";cin>>n;int a[20][20];for(i=1;i<=n;i++){for(j=1;j<=n;j++){cout<<"请输入a["<<i<<"]["<<j<<"]:";cin>>a[i][j];}}cout<<"R的关系矩阵为："<<endl;for(i=1;i<=n;i++){for(j=1;j<=n;j++){cout<<a[i][j]<<" ";}cout<<endl;}for(i=1;i<=n;i++){for(j=1;j<=n;j++){if(a[i][j]!=0){a[j][i]=1; //对称元素的值改为1 }}}cout<<"R的对称闭包矩阵为："<<endl;for(i=1;i<=n;i++){for(j=1;j<=n;j++){cout<<a[i][j]<<" ";}cout<<endl;}}3)传递闭包#include <iostream>using namespace std;void main(){int n,i,j,k;int m=0;cout<<"请输入矩阵的行列数n:";cin>>n;int a[20][20];for(i=1;i<=n;i++){for(j=1;j<=n;j++){cout<<"请输入a["<<i<<"]["<<j<<"]:";cin>>a[i][j];}}cout<<"R的关系矩阵为："<<endl;for(i=1;i<=n;i++){for(j=1;j<=n;j++){cout<<a[i][j]<<" ";}cout<<endl;}for(j=1;j<=n;j++){for(i=1;i<=n;i++){if(a[i][j]==1){for(k=1;k<=n;k++){a[i][k]=a[i][k]+a[j][k]; //warshall方法if(a[i][k]==2) a[i][k]=1; //规范布尔加}}}}cout<<"R的传递闭包矩阵为："<<endl;for(i=1;i<=n;i++){for(j=1;j<=n;j++){cout<<a[i][j]<<" ";}cout<<endl;}}五、实验输入输出和数据实验1：1）输入没有传递关系的关系矩阵R2)输入课本P30/例2.6实验2：1）自反闭包2)对称闭包3）传递闭包 P52/例2.13六、实验体会通过这次的实验，使我明白了，平日里学习不能浅尝辄止，必须要知道它的方法。
闭包的交并运算
闭包的交并运算
闭包是计算机科学中的一个重要概念，特别是在函数式编程和函数式语言如JavaScript 中。
闭包可以简单理解为一个能访问和操作其外部词法环境（lexical environment）的函数。
这意味着一个函数内部的函数（或称为内嵌函数）可以访问其父级函数的变量，甚至在父级函数执行完毕后，这些变量依然可以被内嵌函数访问。
这是因为闭包可以维持一个到其外部作用域的引用。
关于闭包的交并运算，首先需要明确一点：闭包本身并不直接进行交并运算。
交并运算更多的是集合论中的概念，用于描述两个或多个集合之间的关系。
然而，我们可以将闭包看作是一种特殊的集合，这个集合包含了函数以及它们可以访问的外部变量。
如果我们尝试将闭包与集合运算进行类比，可能会得出一些有趣的结论。
例如，两个闭包的"交集"可能是一个新的闭包，这个新的闭包包含了两个原始闭包共有的函数和外部变量。
而两个闭包的"并集"则可能是一个能够访问两个原始闭包所有外部变量的新闭包。
然而，这种类比需要谨慎处理。
在集合论中，交集和并集运算有明确的定义和性质，但在闭包的情况下，这些运算可能并不总是那么直观或明确。
此外，闭包还有其他的特性，如它们可以记住并访问其创建时的环境，这一点在集合论中并没有直接的对应。
总的来说，虽然闭包和集合运算在某些方面可以进行类比，但我们必须认识到它们之间的根本区别。
闭包是一种函数和环境的组合，而集合运算则是一种描述集合之间关系的操作。
理解这一点对于正确使用闭包以及避免常见的误解和错误至关重要。
离散数学实验报告
离散数学闭包实验报告专业12计算机科学与技术学号12407127姓名周谦益时间2011—11--15一、实验目的1.通过上机程序，进一步加深对关系中自反闭包，对称闭包，传递闭包的理解。
2.掌握Warshall算法。
3.学会用程序解决离散数学中的问题。
4.增强我们编写程序的能力。
二、实验内容求有限集上给定关系的自反、对称和传递闭包（用Warshall算法）。
三、实验环境我的实验是在Vs2008实验环境下完成的，而所设计的程序也在这个环境下通过了编译，运行和测试。
四、实验原理和实现过程设计思路在三种闭包中自反和对称闭包的求解很容易，对矩阵表示的关系，其自反闭包只要将矩阵的主对角线全部置为1就可；对称闭包则只需要将矩阵中数值为1的元素关于主对角线对称的元素数值也设为1就可以了；而对于传递闭包，用Warshall算法可以很方便的计算出来。
下面我就来具体分析一下每一种闭包运算的设计。
自反闭包的设计：我们只要把关系矩阵的对角线的元素全赋值为1就可以啦。
具体程序如下：求自反闭包的程序：int Relation::Reflexive()//求自反闭包的函数{for(int i=0;i<Len;i++)if(!R[i][i])return(0);return(1);};对称闭包的求法：对于对称闭包，我们只只需要将矩阵中数值为1的元素的对称位置的元素数值也设为1就可以了。
具体程序如下：对称闭包：int Relation::Symmetric()//对称闭包的函数{int i,j,K=Len-1;for(i=0;i<K;i++)for(j=i+1;j<Len;j++)if(R[i][j]!=R[j][i])return(0);return(1);};传递闭包设计：传递闭包我主要用Warshall算法来求。
书上的Walshall算法的伪代码如下：设R的关系矩阵为M(1)令矩阵A=M(2)置i=1(3)对所有的j，若A[j，i]=1，则对于 k=1，2，…，n，令A[j，k]=A[j，k]+A[i，k](4) i=i+l．(5)若i≤n，则转到(3)，否则结束根据Warshall算法，我设计求出了关系的传递闭包，具体程序如下：int Relation::Transitive()//传递闭包函数{Relation t;t=C_t(1);for(int i=0;i<Len;i++)for(int j=0;j<Len;j++)if(R[i][j]!=t.R[i][j])return(0);return(1);};把上面的每个子函数串在一起，再加上主函数，就可以实现这次实验的要求。
合肥工业大学离散数学实验报告2
实验二：逻辑运算与闭包运算求解姓名：李亚鸣学号：2014211590班级：计算机科学与技术14-1班实验地点：三号实验楼4号机房实验时间：2015年10月24日1实验目的和要求实验目的：（1）通过补充代码，完成基本逻辑运算的程序，加深对逻辑运算的理解。
（2）通过补充待完善的MFC程序，添加核心warshall算法部分，加强对闭包运算的求解的理解，同时对warshall算法加深理解。
实验要求：(1)在luojiyuns.cpp文件中补充And(), Or(), Not(), Xor(), Single_condition(),Doublbe_condition()以实现基本逻辑运算。
(2)warshallDlg.cpp文件中的CWarshallDlg::OnCalculate() 函数中补充warshall算法(3)在待完善的MFC代码上补充warshall算法的核心部分，并在图形上实现。
2实验环境和工具VisualC++6.03实验结果3.1算法流程图3.2程序核心代码（1）/****************************************************//该函数用于进行逻辑与运算//val_one和val_two分别为参与运算的逻辑值//调用twovalue_Judge函数检测是否符合输入要求，然后进行//逻辑运算并返回运算结果*****************************************************/ int luoji::And(int val_one,int val_two){//int jud;if(twovalue_Judge(val_one,val_two)){return val_one==1&&val_two==1;}else{Output();return 2;}cout<<"\n\n";}/**************************************************** //该函数用于进行逻辑或运算//val_one和val_two分别为要进行计算逻辑值//调用twovalue_Judge函数检测是否符合输入要求，然后进行//逻辑运算并返回运算结果*****************************************************/ int luoji::Or(int val_one,int val_two){//int jud;if(twovalue_Judge(val_one,val_two)){return val_one==1||val_two==1;}else{Output();return 2;}cout<<"\n\n";}/**************************************************** //该函数用于进行逻辑非运算//val_one为要进行计算的逻辑值//调用onevalue_Judge函数检测是否符合输入要求，然后进行//逻辑运算并返回运算结果*****************************************************/ int luoji::Not(int val_one){//int jud;if(onevalue_Judge(val_one)){return val_one==0;}else{Output();return 2;}cout<<"\n\n";}/**************************************************** //该函数用于进行逻辑异或运算//val_one和val_two分别为要进行计算逻辑值//调用twovalue_Judge函数检测是否符合输入要求，然后进行//逻辑运算并返回运算结果*****************************************************/ int luoji::Xor(int val_one,int val_two){//int jud;if(twovalue_Judge(val_one,val_two)){return val_one^val_two;}else{Output();return 2;}cout<<"\n\n";}/**************************************************** //该函数用于进行逻辑单条件运算//val_one和val_two分别为要进行计算逻辑值*****************************************************/ int luoji::Single_condition(int val_one,int val_two){//int jud;if(twovalue_Judge(val_one,val_two)){return val_one==1&&val_two==0;}else{Output();return 2;}cout<<"\n\n";}/****************************************************//该函数用于进行逻辑双条件运算//val_one和val_two分别为要进行计算逻辑值*****************************************************/int luoji::Double_condition(int val_one,int val_two){//int jud;if(twovalue_Judge(val_one,val_two)){return val_one==0&&val_two==0;}else{Output();return 2;}cout<<"\n\n";}（4）// 以下语句段使用warshall方法改变矩阵中的值以帮助求解传递闭包// 需要用到的矩阵的行、列值存储在变量dim中，矩阵中各个位置上的对应// 值存储在two_mat[][]数组中//请在此添加warshall算法代码int j,k;int **temp=new int *[dim]; //定义二维动态数组for(i=0;i<dim;i++)temp[i] = new int[dim];for(k=0;k<dim;k++) //依次取k作为中间点的顶点{for(i=0;i<dim;i++){for(j=0;j<dim;j++){//if(two_mat[k][i]&&(two_mat[k][j]||two_mat[j][i])) two_mat[k][i]=1;temp[i][j]=(two_mat[i][j])||(two_mat[i][k]&two_mat[k][j]);}}for(i=0;i<dim;i++)for(j=0;j<dim;j++)two_mat[i][j]=temp[i][j];}3.3运行结果3.4运行结果分析对基本逻辑运算，用了几个简单的例子进行检测，运行结果都正确对warshall算法也用了一个4X4的矩阵作为例子进行检测，运算结果正确。
闭包运算
复习
2.4 设X={0,1,2,3}, R 1 {(i , j ) | j i 1或 j i 2} {(0,1), (1, 2), (2, 3), (2,1), (0, 0)} R 2 {(i , j ) | i j 2} {(2, 0), (3,1)} 解：(1) R 1 R 2 {(1, 0), (2,1)} (2) R 2 R 1 {(2,1), (2, 0), (3, 2)} (3) R 1 R 2 R 1 {(1,1), (1, 0), (2, 2)}
第五节 关系的闭包
三、传递闭包（必须具备条件1,2）
定义 2.19 设 R 是非空集合 A 上的关系, R 的传递闭包 t(R) 是 A 上的关系,t(R)满足以下条件： （1）t(R)是传递的； （2）R t(R) （3）对 A 上任何包含 R 的传递关系 R ，有 t(R)R.
说明：R 的传递闭包 t(R)，就是所有包含 R 且具备传递 性的关系中最小的那个.
2.9 设有X上的关系R， E 是X上的恒等关系，试证 (1) R是自反的当且仅当 E R 证明： R是自反的 x X , ( x , x ) R E R x X , ( x, x ) E 且 ( x, x ) R R是自反的当且仅当 E R (2) R是反自反的当且仅当 E R = 证明： R是反自反的 x X , ( x , x ) R E R = x X , ( x, x ) E 且( x, x ) R x X , ( x, x ) R R是反自反的当且仅当 E R =
例题 3 设 A＝{1,2,3}, R 是 A 上的关系, 其中
R＝{(1,1), (1,2),(3,1), (2,3)}， 则，t(R)= {(1,1), (1,2),(3,1), (2,3)， （1，3）（3，2） ， ， （2，1）,(3,3),(2,2)}
传递闭包计算
传递闭包计算
闭包（closure）是指一个函数可以访问并操作其包含函数中定义的变量。
通过传递闭包，可以将包含函数中的变量保持在内存中，并在后续的调用中继续使用这些变量。
下面是一个例子，展示了如何使用闭包来进行简单的计算：
```python
def add(x):
def inner(y):
return x + y
return inner
add5 = add(5) # 创建一个闭包，将闭包赋值给变量add5 result = add5(3) # 调用闭包计算结果，将结果赋值给变量result
print(result) # 输出8
```
在上面的例子中，函数`add()`返回内部函数`inner()`，并在
`inner()`中使用了`add()`中的变量`x`。
通过调用`add()`并传递参数5，我们创建了一个闭包`add5`，该闭包可以将参数与传递给`add()`的值相加。
在调用闭包时，我们将参数3传递给
`add5`，得到计算结果8。
通过传递闭包，我们可以将包含函数中的变量保存在内存中，并在闭包的后续调用中使用这些变量。
这在某些特定情况下可
以很有用，例如在一个长时间运行的任务中需要保持一些状态或缓存结果。
等价闭包文档
等价闭包文档第一组目录1.等价闭包概述————————————————————32.等价闭包目的和要求—————————————————32.1实验目的———————————————————32.2实验要求———————————————————33.需求分析（基于每个功能点）—————————————44.软件设计——————————————————————44.1概要设计———————————————————44.2详细设计———————————————————45.编码实现——————————————————————56.软件测试——————————————————————87.结论与心得体会——————————————————10等价闭包1.等价闭包概述1.1等价闭包的概述对于给定的集合A上关系R，对于A上关系S，若其满足①R S；②S是一个等价关系；③若A上关系S’满足上述两个条件，则必有S S’，则以下简称S为R的等价闭包，记作S=Re1.2等价类的概述等价类（Equivalence class）在数学中，给定一个集合 X 和在 X 上的一个等价关系 ~，则 X 中的一个元素 a 的等价类是在 X 中等价于 a 的所有元素构成的集合的子集： a = { X ; X ~ a } 2.等价闭包目的和要求2.1实验目的设计一款软件从文件中读取一个矩阵，完成等价闭包计算和等价类计算，运用到实际应用场景中。
2.2实验要求①描述程序的结构和流程②提供程序源代码③由教师给出的测试样例（test1.txt—test8.txt），给出输出结果，以检验程序的正确性④能够应用到实际场景中3.需求分析（基于每个功能点）实验平台：PC机,Windows XP操作平台，Visual C++实验步骤以及调试分析（1）编写一个计算某关系的等价闭包与等价类的程序（2）将实际应用抽象成关系矩阵读入该程序进行计算（3）程序自动输出等价闭包与等价类4.软件设计4.1概要设计从六个测试文件中读取不同的矩阵，通过ReflexiveClosure()，isreflexiveClosure()，TransitiveClosure()，SymmetricClosure()等计算闭包函数，还有isSymmetricClosure()，isreflexiveClosure()，isirreflexiveClosure()，isTransitiveClosure()，等判断函数来进行判断，最终得出相应的对称闭包，自反闭包，传递闭包，等价闭包。
中南大学自动化专业离散数学实验报告2
“离散数学”实验报告(实验二AC)专业：自动化班级：学号：姓名：2010年12月20日一、实验目的：掌握关系的概念与性质，基本的关系运算，关系的各种闭包的求法。
理解等价类的概念，掌握等价类的求解方法。
二、实验内容：1. 求有限集上给定关系的自反、对称和传递闭包。
（有两种求解方法，只做一种为A，两种都做为B）2. 求有限集上等价关系的数目。
（有两种求解方法，只做一种为A，两种都做为B）3. 求解商集，输入集合和等价关系，求相应的商集。
（C）三、实验环境:工具：Mcrosoft Visual Studio 2005；程序设计语言：C语言。
四、实验原理和实现过程（算法描述）:实验A 求有限集上等价关系的数目。
集合上的等价关系与该集合的划分之间存在一一对应关系。
一个等价关系对应一个划分，一个划分也对应一个等价关系。
我们把n 个元素的集合划分成k块的方法数叫第二类Stirling数，表示为S(n,k)。
给定S(n,n) = S(n,1) = 1，有递归关系：S(n,k) = S(n − 1,k − 1) + kS(n − 1,k)集合上所有等价类的个数即为k从1到n，所有S(n,k)之和。
这个问题的算法比较简单，仅需两步就可完成，首先根据上式，定义一个递归函数S（n,k），然后对k从1到n，求取sum=∑S（n，k），sum的值就是给定n元集合上的等价关系数目，最后将其输出即可。
实验A的流程图如下所示：实验C 求解商集，输入集合和等价关系，求相应的商集商集即等价类构成的集合，要求商集，首先需要判断输入的关系是否为等价关系，否则没有商集。
判断输入的关系是否为等价关系的算法如下：(1)将输入的关系转换为关系矩阵，这里定义了一个函数translate()，转换的方法为：依次查找输入的关系中的二元组的两个元素在集合中的位置，例如<a，b>，若a在集合A中的位置为i，b在集合A中的位置为j，就令存放关系矩阵的二维数组M[i][j]=1,这样就将输入的关系R转换为关系矩阵的形式。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一、实验目的
了解和掌握闭包运算的概念，熟悉Warshall算法，掌握求关系的自反闭包、对称闭包和传递闭包的方法。
二、实验内容
从键盘输入一个关系的关系矩阵，计算其自反闭包、对称闭包和传递闭包，传递闭包要求使用Warshall算法，用C语言实现。
三、思路分析（即代码分析）
声明：R[][]表示关系R；x[]表示集合X; r[]表示自反闭包；s[]表示对称闭包；t[]表示传递闭包
（一），输入形式：
先输出提示符：
请先输入集合X中元素的个数，之后输入集合X中的元素（不同元素之
间用空格隔开,行末用回车结束）:
第一行：先输入集合X中元素的个数n，空一格之后输入集合X中的元素，不同元素之间用空格隔开,行末用回车结束:
输出提示符：
请先输入集合X上的二元关系R的序偶对个数，再输入集合X上的二元
关系R,每一对序偶用a,b表示，序偶之间用空格隔开，行末用回车结束：第二行：先输入集合X上的二元关系R的序偶对个数，空一格之后输入集合X上的二元关系R,每一对序偶用a,b表示，序偶之间用空格隔开，行末用回车结束：
（二）、输入记录：
记录时将X中的元素按照输入的次序依次编号，存储在数组x[]中对应编号的位置
1，通过输入的集合X中元素的个数n来控制之后的元素输入循环次数；
2，通过输入的集合X上二元关系序偶对的个数来控制之后序偶对的输入循环次数；
3，输入序偶对时，每次直接输入到临时变量a，b中，之后在集合x[]中遍历，找到此次输入的序偶对在x[]所对应的位置，之后将二维矩阵R[][]对应位置置1，表示有此对应关系
（三），自反闭包计算
将关系R[][]复制到自反闭包 r[][] 矩阵中，之后将行数等于列数的元素置1，便按照自反闭包定义将矩阵r[][]扩充到符合要求
（四），对称闭包计算
扫瞄关系矩阵R[][]，记录其中不为1的元素的行列数，之后将对称矩阵s[][]相应的行列数和行数和列数相反的位置都置1；便按照对称闭包定义将矩阵r[][]扩充到符合要求
（五），传递闭包计算
1，按照Warshall算法，先将R[][]复制到r[][]中，
2，遍历r[][]的每列，在每列中找到不为0的元素r[i][j]，之后将j行与i
行对应的元素进行逻辑加，将结果赋值到第i行上去；
3，遍历完每一列后所得的矩阵就是传递闭包的对应矩阵
四、实验结果与分析
对于输出的闭包关系中，每对序偶用a，b表示，序偶之间用空格隔开，每输出一次用回车结束
（例）每次输出时先输出提示符：
关系R的自反闭包为：
Sample Output：
关系R的自反闭包为：
a,a a,b b,b b,d c,a c,c d,d d,e e,b e,e
关系R的对称必包为：
a,b a,c b,a b,d b,e c,a d,b d,e e,b e,d
关系R的传递必包为：
a,b a,d a,e b,b b,d b,e c,a c,b c,d c,e d,b d,d d,e e,b e,d e,e
五、VS2010中验证结果（全视图）：
请先输入集合X中元素的个数，之后输入集合X中的元素（不同元素之间用空格隔开,行末用回车结束）:
5 a b c d e
请先输入集合X上的二元关系R的序偶对个数，再输入集合X上的二元关系R,每一对序偶用a,b表示，序偶之间用空格隔开，行末用回车结束：
5 a,b b,d c,a d,e e,b
关系R的自反闭包为：
a,a a,b b,b b,d c,a c,c d,d d,e e,b e,e
关系R的对称必包为：
a,b a,c b,a b,d b,e c,a d,b d,e e,b e,d
关系R的传递必包为：
a,b a,d a,e b,b b,d b,e c,a c,b c,d c,e d,b d,d d,e e,b e,d e,e 请按任意键继续. . .
六、实际输出：。