目录
第1关：求给定集合的对角线关系（diagonal relation）
第1关：求给定集合的对角线关系（diagonal relation）
这个他也说了，恒等关系，好办的很！
def diagonalRelation(self):
########## Begin ##########
return Relation(self.sets, set([(a, a) for a in self.sets]))
########## End ##########
如果 self.sets 是一个包含元素 'A'、'B' 和 'C' 的集合，那么 set([(a, a) for a in self.sets]) 将生成一个包含元组 ('A', 'A')、 ('B', 'B') 和 ('C', 'C') 的集合。
第2关：关系的合成
这好说也就是(x1,y1) (x2,y2)如果y1等于x2那么便可以合成为(x1,y2)
def __mul__(self, other):
assert self.sets == other.sets
return Relation(self.sets, set([(x, y1) for x, y in other.rel for x1, y1 in self.rel if y == x1]))第3关：关系的幂运算
def __pow__(self, power, modulo=None):
assert power >= -1
if power == -1:
return Relation(self.sets, set([(x, y) for y, x in self.rel]))
elif power == 0:
return self.diagonalRelation()
return self ** (power - 1) * self第4关：关系的并运算
这简单加一下就行了！
def __add__(self, other):
assert self.sets == other.sets
########## Begin ##########
# 将两个关系的关系集合进行并集操作
new_rel = self.rel.union(other.rel)
return Relation(self.sets, new_rel)
#实现两个关系的并运算，重载+运算符，即self+other表示self并other
#请注意，是Relation对象rel成员的并
#返回结果为一个Relation对象
# 请删除pass后编程实现该方法功能
########## End ##########
第5关：转换为关系矩阵
def toMatrix(self):
#将序偶集合形式的关系转换为矩阵。
#为保证矩阵的唯一性，需对self.sets中的元素先排序
matrix = []
elems = sorted(list(self.sets))
line = [0]*len(self.sets)
for elem in elems:
########## Begin ##########
#请在此处编写程序，实现转换为矩阵的功能
for x, y in self.rel:
if x == elem:
line[elems.index(y)] = 1
matrix.append(line)
line = [0] * len(self.sets)
#请在上面编写程序，不要修改下面的代码
########## End ##########
return matrix第6关：自反关系的判断
def isReflexive(self):
########## Begin ##########
#判断self是否为自反关系，是则返回True，否则返回False
# 请删除pass后编程实现该方法功能
for x in self.sets:
if (x, x) not in self.rel:
return False
return True
########## End ########## 第7关：反自反关系的判断
def isIrreflexive(self):
########## Begin ##########
# 判断self是否为反自反关系，是则返回True，否则返回False
# 请删除pass后编程实现该方法功能
for x in self.sets:
if (x, x) in self.rel:
return False
return True 第8关：对称关系的判断
def isSymmetric(self):
########## Begin ##########
# 判断self是否为对称关系，是则返回True，否则返回False
# 请删除pass后编程实现该方法功能
for x, y in self.rel:
if (y, x) not in self.rel:
return False
return True
第9关：非对称关系的判断
def isAsymmetric(self):
########## Begin ##########
# 判断self是否为非对称关系，是则返回True，否则返回False
# 请删除pass后编程实现该方法功能
for x, y in self.rel:
if (y, x) in self.rel:
return False
return True第10关：反对称关系的判断
def isAntiSymmetric(self):
########## Begin ##########
# 判断self是否为反对称关系，是则返回True，否则返回False
# 请删除pass后编程实现该方法功能
for x, y in self.rel:
if (y, x) in self.rel and x != y:
return False
return True
第11关：传递关系的判断
def isTransitive(self):
########## Begin ##########
# 判断self是否为传递关系，是则返回True，否则返回False
# 请删除pass后编程实现该方法功能
for x, y in self.rel:
for x1, y1 in self.rel:
if x1 == y:
if (x, y1) not in self.rel:
return False
return True
########## End ########## 第12关：计算自反闭包
def reflexiveClosure(self):
########## Begin ##########
#求self的自反闭包，注意使用前面已经重载过的运算符
#返回一个Relation对象，为self的自反闭包
# 请删除pass后编程实现该方法功能
return self + self.diagonalRelation()
########## End ########## 第13关：关系的对称闭包
def symmetricClosure(self):
########## Begin ##########
# 求self的对称闭包，注意使用前面已经重载过的运算符
# 返回一个Relation对象，为self的对称闭包
# 请删除pass后编程实现该方法功能
return self + self ** -1
########## End ##########
第14关：关系的传递闭包
def transitiveClosure(self):
closure = self
# 求self的传递闭包，注意使用前面已经重载过的运算符
# 该方法实现的算法：严格按照传递闭包计算公式求传递闭包
#********** Begin **********#
for i in range(2, len(self.sets) + 1):
if closure.isTransitive(): # 反正是或运算，可以省此判断，或许还会更快算得
break
closure = closure + self ** i
#********** End **********#
return closure第15关：利用Warshall算法求传递闭包
def __warshall(self, a):
assert (len(row) == len(a) for row in a)
n = len(a)
#请在下面编程实现Roy-Warshall求传递闭包的算法
#参数a：为一个关系矩阵
#********** Begin **********#
for r in range(n):
for c in range(len(a[r])):
if a[c][r] == 1:
for k in range(n):
a[c][k] = a[c][k] | a[r][k]
#********** End **********#
return a第16关：判断等价关系
def isEquivalenceRelation(rel):
#该函数对给定的Relation对象rel，判断其是否为等价关系
#是则返回True，否则返回False
#********** Begin **********#
return rel.isReflexive() and rel.isSymmetric() and rel.isTransitive()
#********** End **********#第17关：计算等价类
def createPartition(rel):
#对给定的Relation对象rel，求其决定的rel.sets上的划分
#如果rel不是等价关系，返回空集
if not isEquivalenceRelation(rel):
print("The given relation is not an Equivalence Relation")
return set([])
#如rel是等价关系，实现求划分的程序
partition = set([])
#********** Begin **********#
partition = set([])
for elem in rel.sets: # 给个元素的等价类
partition.add(frozenset(y for x, y in rel.rel if x == elem))
#********** End **********#
return partition
第18关：从划分生成等价关系
def createEquivalenceRelation(partition, A):
#对给定的集合A，以及A上的一个划分partition
#生成由该划分决定的等价关系
assert functools.reduce(lambda x, y: x.union(y), partition) == A
#********** Begin **********#
return Relation(A, set((a,b) for part in partition for a in part for b in part))
#********** End **********#第19关：判断半序关系
def isPartialOrder(rel):
# 该函数对给定的Relation对象rel，判断其是否为半序关系
#是则返回True，否则返回False。
#********** Begin **********#
return (rel ** (-1)).rel.intersection(rel.rel) == set((x, x) for x in rel.sets)
#********** End **********#
第20关：判断拟序关系
def isQuasiOrder(rel):
# 该函数对给定的Relation对象rel，判断其是否为拟序关系
# 是则返回True，否则返回False。
#********** Begin **********#
return rel.isIrreflexive() and rel.isAntiSymmetric() and rel.isTransitive()
#********** End **********#第21关：判断全序关系
def isLinearOrder(rel):
# 该函数对给定的Relation对象rel，判断其是否为全序关系
#是则返回True，否则返回False
if not isPartialOrder(rel):
return False
else:
#********** Begin **********#
return set(x for x, y in rel.rel if x != y) == rel.sets == set(y for x, y in rel.rel if x != y)
#********** End **********#
第22关：关系矩阵的join运算
def join(rel1, rel2):
#对给定的关系rel1和rel2
assert rel1.sets == rel2.sets
#首先得到二者的矩阵
M1 = rel1.toMatrix()
M2 = rel2.toMatrix()
m = len(M1)
n = m
M = []
#********** Begin **********#
#实现关系矩阵的join运算，结果存于M中
for r in range(m):
row = [0] * n
for c in range(n):
row[c] = M1[r][c] | M2[r][c] # 或
M.append(row)
return M
#********** End **********#第23关：关系矩阵的meet运算
def meet(rel1, rel2):
# 对给定的关系rel1和rel2
assert rel1.sets == rel2.sets
# 首先得到二者的矩阵
M1 = rel1.toMatrix()
M2 = rel2.toMatrix()
m = len(M1)
n = m
M = []
#********** Begin **********#
# 实现关系矩阵的meet运算，结果存于M中
for r in range(m):
row = [0] * n
for c in range(n):
row[c] = M1[r][c] & M2[r][c]
M.append(row)
#********** End **********#
return M
第24关：关系矩阵的布尔乘积
def booleanProduct(rel1, rel2):
# 对给定的关系rel1和rel2
assert rel1.sets == rel2.sets
# 首先得到二者的矩阵
M1 = rel1.toMatrix()
M2 = rel2.toMatrix()
m = len(M1)
n = m
M = []
#********** Begin **********#
# 实现关系矩阵的布尔乘积运算，结果存于M中
for r in range(m):
row_M1_r = M1[r] # 准备M1矩阵的行
row_M_r = [0] * n
for c in range(n):
col_M2_c = [M2[r_2][c] for r_2 in range(m)] # 准备M2矩阵的列
# 计算r行c列的结果
row_M_r[c] = 1 if sum([x & y for x, y in zip(row_M1_r, col_M2_c)]) else 0
M.append(row_M_r)
#********** End **********#
return M
3116
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
