离散数学闭包运算

编程题目：基于关系的矩阵表示，实现关系的自反闭包、对称闭包、传递闭包运算，并计算A上的关系R={<a,b>,<b,a>,<b,c>,<c,d>}的自反闭包、对称闭包、传递闭包，其中A={a,b,c,d}.

编程内容及要求：

编写程序，基于关系的矩阵表示，实现关系的自反闭包、对称闭包、传递闭包运算；利用编写的程序，计算并输出A上的关系R={<a,b>,<b,a>,<b,c>,<c,d>}的自反闭包、对称闭包、传递闭包，其中A={a,b,c,d}.

编程语言可选择C、C++、Java或Python。

闭包输出格式示例:

------------------

自反闭包

------------------

{,,,,,,,}

------------------

编程目的：学会用程序语言实现关系的矩阵表示，基本的关系矩阵运算，以及闭包运算。

编程语言：

Python

程序设计简要描述：

使用R2M函数将给出的关系R转换成关系矩阵便于计算，

使用r、s、t三个函数分别进行自反、对称、传递闭包的计算

根据定义，自反闭包将对角线元素改为1即可，对称闭包则是将对称位统一，传递闭包使用Warshall算法计算

最后将计算出的闭包关系矩阵使用M2R函数转换成关系的集合

输出的字符文件closure.txt内容（粘贴）：

------------------
自反闭包
------------------
{,,,,,,,}
------------------
对称闭包
------------------
{,,,,,}
------------------
传递闭包
------------------
{,,,,,,,,}
------------------

源程序代码：

1. from copy import deepcopy
 2.  
 3.  
 4. def r(M):
 5.     r_R = deepcopy(M)
 6.     for i in range(len(r_R)):
 7.         r_R[i][i] = 1
 8.     return r_R
 9.  
10. def s(M):
11.     s_R = deepcopy(M)
12.     n = len(s_R)
13.     for i in range(n):
14.         for j in range(i+1):
15.             if s_R[i][j] or s_R[j][i]:
16.                 s_R[i][j] = s_R[j][i] = 1
17.     return s_R
18.  
19. def t(M):
20.     t_R = deepcopy(M)
21.     n = len(t_R)
22.     for k in range(n):
23.         for i in range(n):
24.             for j in range(n):
25.                 if t_R[i][j] + t_R[i][k] * t_R[k][j]:
26.                     t_R[i][j] = 1
27.     return t_R
28.  
29.  
30. def R2M(R, A):
31.     n = len(A)
32.     dic_A = {}
33.     A = list(A)
34.     for i in range(n):
35.         dic_A[A[i]] = i
36.     M = [[0]*n for i in range(n)]
37.     for item in R:
38.         a = item.strip('<>').split(',')[0].strip()
39.         b = item.strip('<>').split(',')[1].strip()
40.         M[dic_A[a]][dic_A[b]] = 1
41.     return M
42.  
43.  
44. def M2R(M, A):
45.     n = len(A)
46.     dic_A = {}
47.     A = list(A)
48.     for i in range(n):
49.         dic_A[i] = A[i]
50.     R = set()
51.     for i in range(n):
52.         for j in range(n):
53.             if M[i][j]:
54.                 R.add(f'<{dic_A[i]},{dic_A[j]}>')
55.     return R
56.  
57.  
58. A = {'a', 'b', 'c', 'd'}
59. R = {'', '', '', ''}
60.  
61. # M = R2M(R, A)
62. # print(M)
63. # print(M2R(M, A))
64.  
65.  
66. with open('closure.txt', 'w', encoding='utf-8') as f:
67.     M = R2M(R, A)
68.  
69.     f.write('------------------\n')
70.     f.write('自反闭包\n')
71.     f.write('------------------\n')
72.     r_R = r(M)
73.     f.write(f'{{{",".join(list(M2R(r_R, A)))}}}\n')
74.     f.write('------------------\n')
75.     f.write('对称闭包\n')
76.     f.write('------------------\n')
77.     s_R = s(M)
78.     f.write(f'{{{",".join(list(M2R(s_R, A)))}}}\n')
79.     f.write('------------------\n')
80.     f.write('传递闭包\n')
81.     f.write('------------------\n')
82.     t_R = t(M)
83.     f.write(f'{{{",".join(list(M2R(t_R, A)))}}}\n')
84.     f.write('------------------\n')
85.