北航离散数学期末总结
用python语言描述图论中的概念及算法
判断子图算法
def issubgraph(V,E,Vs,Es):
tv=(Vs <= V) and (Es <= E) # 点集是子集，边集是子集
return tv
判断真子图算法
def ispropersubgraph(V,E,Vs,Es):
# 首先要是一个子图，然后点集或者边集是真子集
tv=((Vs <= V) and (Es <= E)) and ((Vs < V) or (Es < E))
return tv
判断生成子图算法
def isspanningsubgraph(V,E,Vs,Es):
# 边集是子集，点集相同
tv=((Vs == V) and (Es <= E))
return tv
判断导出子图算法
def isinducedsubgraph(V,E,Vs,Es):
tv=((Vs <= V) and (Es <= E)) # 首先判断是否是一个子图
# 对于E中的边所关联的两个点，要么不是都在Vs中，如果都在Vs里，
# 这条边就要在Es中出现
for (u,v) in E:
tv=tv and ((not((u in Vs) and (v in Vs))) or ((u,v) in Es))
return tv
完全图构建算法
def completeset(n):
V=set({})
E=set({})
# 两两顶点之间创建边
for i in range(n):
V=V | {i}
for j in range(n):
if(i < j):
E=E | {(i,j)}
return (V,E)
圈图构建算法
def cyclicset(n):
V={0} # 取出一个顶点作为起始顶点
E=set({})
for k in range(1,n):
V=V | {k}
E=E | {(k-1,k)} # 每个顶点和下一个顶点连边
E=E | {(n-1,0)} # 补上圈的最后一条边
return (V,E)
轮图构建算法
def wheelgset(n):
V={0,1} # 0作为内部的轮心
E=set({})
# 整体思路和圈图的是一样的
# 只不过对于外面的圈上的每个顶点都增加一个和内部轮心
# 相连的边
for k in range(1,n):
V=V | {k}
E=E | {(0,k)}
E=E | {(k-1,k)}
E=E | {(n-1,1)}
return (V,E)
二部图构建算法
def completebipartitegraph(n,m):
V0=set({})
V1=set({})
# 添加V0中的n个节点
for k in range(n):
V0=V0 | {k}
E=set({})
# 添加V1中的m个节点
for k in range(n,n+m):
V1=V1 | {k}
# 对于V0和V1中的每两个节点之间创建边
for u in V0:
for v in V1:
E=E | {(u,v)}
return (V0,V1,E)
n立方体图构建算法
def ncubeset(m): # 在这里m是二进制数的位数，如m = 3
V=set({})
E=set({})
n=2**m # 总共的顶点数，n = 8
for i in range(n):
V=V | {i}
u=1 # u作为一个指标，n = 001, 010, 100
k=0 # k作为一个遍历，用来使n里面的1二进制位遍历m个位置
while(k < m):
# 如果i里面u中1二进制位所对应的位是0，则将该位变成1
# 如果i里面u中1二进制位所对应的位是1，则将该位变成0
# 通过遍历，就可以使得每个顶点相邻的m个顶点与其都
# 只有一个二进制位不同
if(i & u == 0):
j=i | u
else:
j=i - u
E=E | {(i,j)}
u=u*2
k=k+1
return (V,E)
0-1序列图构建算法
def sequence01set(m):
V=set({})
E=set({})
n=2**m
# 思路就是对于每个顶点，将其左移一位，然后在最低位填0或1
# 这样就构造了两条边，而且其所关联的两个顶点满足条件
for i in range(n):
V=V | {i}
j=(2*i)%n
E=E | {(i,j)}
j=(2*i + 1)%n
E=E | {(i,j)}
return (V,E)
通路算法
import datetime
def pathset0(V,E,u0):
# path1最后保存的是所有以u0为起始节点的边
path1=set({})
for (u,v) in E:
if(u == u0):
path1=path1 |{(u,v)}
return path1
def pathset(path0,E):
path=set({})
for p0 in path0:
y=p0[-1] # 取通路的最后一个顶点
for (u,v) in E:
if u==v: # 如果是自环，忽略
continue
p=p0
if (u==y): # 如果发现能将该通路扩充
p=p+tuple([v]) # 将新的节点添加到当前路径中
path=path |{p}
return path
def main(V,E,k):
global path
t0=datetime.datetime.now( )
path=pathset0(V,E,1)
for k in range(k): # k这个参数我认为是寻找长度为k的通路
path=pathset(path,E)
t1=datetime.datetime.now( )
t=t1-t0
return [t,len(path)]
基本通路算法
def basicpathset(path0,E):
path=set({})
# 总体的思路是和pathset()一样的
# 但是由于是基本通路，要保证每个顶点出现不超过1次
for pk in path0:
x=pk[-1]
for (u,v) in E:
p=pk
if (u==x and v not in pk):
p=p+tuple([v])
path=path |{p}
if(v==x and u not in pk): # 这里好像又考虑无向图了...
# 知道思路就好，如果自己写也不会写成这样
p=p+tuple([u])
path=path |{p}
return path
def basicpathnset(V,E,v0):
pathk=pathv0(V,E,v0) # 这里的pathv0，我真不知道是什么....
# 我在这里当作pathset0这个函数
m=len(V)-2
for k in range(m):
n=len(pathk) # 我不知道这个n他要干啥
pathk=basicpathset(pathk,E)
return pathk
连通图的构建
def connectedgraph(V,E):
for (u,v) in E: # 神奇操作
break
Vc=set({u,v})
Ec=set({(u,v)})
while E !=set({}):
n=len(Ec) # 和后面的len(Ec) == n相对应，用来判断是都本次循环
# 对Ec进行了修改，如果没有就说明已经构造完了，就break
for (u,v) in E:
# 这里就是不断地加点
if (u,v) not in Ec and (u in Vc or v in Vc):
Vc=Vc | {u,v}
Ec=Ec | {(u,v)}
if len(Ec) == n:
break
return [Vc,Ec]
连通图判断
def isconnectedgraph(V,E):
# 就是判断这个图是不是只有一个连通分支
# 所以先构造一个联通子图，然后看边集和E是不是相等
[Vc,Ec]=connectedgraph(V,E)
if set(Ec)==set(E):
tv=True
else:
tv=False
return tv
树的构建
def graph2tree(V,E):
for (u,v) in E: # 神奇操作
break
Vt={u,v}
Et={(u,v)}
n=len(V)
while(len(Et) < (n-1)): # m = n - 1
m=len(Vt) # 用来判断本次循环是否对Vt更改，如果没有，就直接返回
# 避圈加边
for (u,v) in E:
if((u in Vt and v not in Vt)
or (u not in Vt and v in Vt)):
Vt=Vt | {u} | {v}
Et=Et | {(u,v)}
E=E-Et # 将已经加过的边从原来E中去掉
if(m == len(Vt)):
break
return [Vt,Et]
树的判断
def istree(V,E):
for (u,v) in E:
Vt={u,v}
E=E-{(u,v)}
tv=True
while(E != set({})):
for (u,v) in E:
# 如果E中的边所关联的两个点在Vt中已经出现
# 则说明出现了圈，不为树
if u in Vt and v in Vt:
E=E-{(u,v)}
tv=False
break
# 从E中去掉边，将点添加到Vt中
if u in Vt and v not in Vt:
Vt=Vt | {u} | {v}
E=E-{(u,v)}
if u not in Vt and v in Vt:
Vt=Vt | {u} | {v}
E=E-{(u,v)}
if(tv == False):
break
# 判断是否连通
if(len(Vt) != len(V)):
tv=False
return tv
二叉树构建算法
def createbitree(nodes):
# []是树
if(len(nodes) == 0):
return [ ]
# [a]是树
if(len(nodes) == 1):
return [nodes[0]]
# 从当前结点集中任意挑出一个点作为父结点
k=random.randint(0,len(nodes)-1)
# 左儿子
Lnodes=nodes[0:k]
# 右儿子
Rnodes=nodes[k+1:]
a=nodes.pop(k)
# 递归构造
L=createbitree(Lnodes)
R=createbitree(Rnodes)
return [a,L,R]
前序遍历
# 树的形式[root, left, right]
# 和数据结构书上的差不多
# 中序和后序同理，在这里就不写了
def preordertraversal(tree):
if(len(tree)==0):
return []
if(len(tree)==1):
return [tree[0]]
else:
return [tree[0]]+preordertraversal(tree[1])+preordertraversal(tree[2])
霍夫曼编码
def main( ):
global W,tree,gtree
# W中的每个子列表第一项是权值，第二项是名字
W=[[0.08,'a'],[0.10,'b'],[0.12,'c'],[0.15,'d'],[0.20,'e'],[0.35,'f']]
# tree的形式是[[1, [...], [...]]]，省略号表示形式是递归的
tree=Huffmantree(W)
# 将tree的形式变成[1, [...], [...]]
tree=tree[0]
gtree=Huffmantree2graph(tree)
drawgraph(gtree)
return gtree
def Huffmantree(W):
tree=sorted(W) # 首先对权值进行排序
while len(tree) != 1:
# 将权值最小的两个子树结合起来
# 权值相加，权值小的作为左子树，权值大的作为右子树
tree=[[tree[0][0]+tree[1][0],tree[0],tree[1]]]+tree[2:]
# 重新进行排序
tree=sorted(tree)
return tree
def Huffmantree2graph(tree):
gtree=set({})
if len(tree) == 2: # 如果是底层，例如(1.0, 0.38)这种形式，则直接返回
return gtree
L=Huffmantree2graph(tree[1]) # 递归左子树
R=Huffmantree2graph(tree[2]) # 递归右子树
a=math.floor(tree[0]*10000)/10000
l=math.floor(tree[1][0]*10000)/10000
r=math.floor(tree[2][0]*10000)/10000
# 将当前结点的左右子树和左右子树的递归给添加到gtree
gtree= {(a,l)} | {(a,r)}|L|R
return gtree
def huffmancoding(subtree,code):
# 和上一个函数思路是差不多的
if len(subtree) == 2:
return [[subtree[1],code]]
else:
node0=subtree[1]
node1=subtree[2]
# 如果是左子树，就加0，如果是右子树，就加1
huffmancode=huffmancoding(node0,code+'0')+huffmancoding(node1,code+'1')
return huffmancode
Prim和Kruskal以及Dijiskra和Floyd略
欧拉图构建方法
# 其实总体的思路就是树上欧拉图构建的证明
# 如果书上理解了，这里就会方便很多
def subEulerCircuit(v0,E):
# 这个函数起始就是从v0开始找圈
circuit=tuple([v0])
S=set({})
while (circuit[0]!=circuit[-1] or len(circuit) ==1):
y=circuit[-1]
for (u,v) in E:
if(u==y or v==y):
if (u==y):
circuit=circuit+tuple([v])
else:
circuit=circuit+tuple([u])
E=E-{(u,v)}
S=S|{(u,v)}
break
return [circuit,S]
def EulerCircuit(v0,E):
# 首先找到一个圈
[circuit,S]=subEulerCircuit(v0,E)
# 将E中在这个圈里的边去掉
E=E-S
while (E != set({})):
V1=set2V(E)
V2=set2V(S)
V1V2=V1&V2 # 找到E和S的公共点
for v0 in V1V2:
# 以公共点找圈
[subcircuit,S]=subEulerCircuit(v0,E)
k=circuit.index(v0)
# 将两个圈合成一个
circuit=circuit[0:k]+subcircuit+circuit[k+1:-1]+tuple([circuit[-1]])
E=E-S
break
return circuit
def set2V(E): # 将边集转换成顶点集
V=set({})
for (u,v) in E:
V=V|{u,v}
return V
哈密尔顿周游算法
# 整体算法ppt上写的很详细
# 在这里只是将算法拆分到具体的代码上
def tourpath0(V,E,path,m):
while(len(path) < m):
w=path[-1] # 取出路径最后一个点
i=V.index(w)
E1=E[i]
E2=E1[1] # 找到这个点的邻接点集
for u in E2: # 遍历邻接点集
if(u not in path): # 如果不在当前路径，就添加
path.append(u)
break
if(path[-1] == w): # 如果本次循环没有添加任何结点，就退出
break
return path
def tourpath1(V,E,path,m):
v=path.pop( ) # 取路径path的末尾顶点v=path.pop( )为v
while(len(path) != 0): # 若 path非空
u=path[-1] # 取路径path的末尾顶点path[-1]为u
i=V.index(u)
E1=E[i]
E2=E1[1]
k=E2.index(v) # 从顶点u的邻接表从顶点v以后依次检查k=E2.index(v)
while(k < (len(E2)-1)):
k=k+1
v=E2[k]
if(v not in path): # 若v=E2[k]不在path，则v为path的新末尾顶点，直至邻接表结束
path.append(v)
break
if(u != path[-1]): #若path有新顶点，则结束，否则，path弹出末尾顶点。
break
v=path.pop( )
return path
def tourpath(V,E,path,m):
if(len(path) == m): # 若len(path) == m，则求新的周游通路，即tourpath1(V,E,path,m)
path=tourpath1(V,E,path,m)
while(len(path) != 0): # 若len(path) != 0，依次迭代执行tourpath0与tourpath1
path=tourpath0(V,E,path,m)
if(len(path) == m):
break
path=tourpath1(V,E,path,m)
return path
# 这个是构建邻接表
def adjacentlist(V,E):
Ea=[]
for w in V:
e0=[w]
e1=[]
for (u,v) in E:
if u == w and (v not in e1):
e1=e1+[v]
if v==w and (u not in e1):
e1=e1+[u]
e0=e0+[sorted(e1)]
Ea=Ea+[e0]
return sorted(Ea)
关键路径算法
# di0中存的是入度为0的结点集
def stepu0v(di0,E):
S=set({})
for u0 in di0: # 对于每个入度为0的结点
# S添加E中所有以u0为起始结点的边集
for (w,u,v) in E:
if u == u0:
S=S|{(w,u,v)}
# 最后S中包含的是所有以di0中结点为起始结点的边集
return S
# do0中存的是出度为0的结点集
def stepuv0(do0,E):
S=set({})
for v0 in do0:
for (w,u,v) in E:
if v == v0:
S=S|{(w,u,v)}
# 最后S中包含的是所有以di0中结点为终止结点的边集
return S
def craticalTE(V,E,di,v0,vn):
Hx= [0]*len(V) # 初始化所有的最早完成时间都是0
di0={v0} # 以v0作为初始入度为0的结点
while vn not in di0:
S=stepu0v(di0,E) # 得到以di0中结点为起始结点的边集
[Hx,di,di0]=TEpath(S,Hx,di)
E=E-S
return Hx
# 与TE同理
def craticalTL(V,E,do,Hn,v0,vn):
Hy= [1000]*len(V)
Hy[len(V)-1]=Hn
do0={vn}
while v0 not in do0:
S=stepuv0(do0,E)
[Hy,do,do0]=TLpath(S,Hy,do)
E=E-S
return Hy
def TEpath(S,Hx,di):
# 对S中的每一条边，更新最早完成时间的值
di0=set({})
for (w,u,v) in S:
if Hx[v] < Hx[u]+w: # 更新
Hx[v]=Hx[u]+w
if di[v]>0: # 如果v的入度大于0，则减1
di[v]=di[v]-1
if di[v] == 0: # 将入度为0的点添加到di0中
di0=di0 | {v}
return [Hx,di,di0]
def TLpath(S,Hy,do):
do0=set({})
for (w,u,v) in S:
if Hy[u] > Hy[v]-w:
Hy[u]=Hy[v]-w
if do[u]>0:
do[u]=do[u]-1
if do[u] == 0:
do0=do0 | {u}
return [Hy,do,do0]
def craticalpath(V,E,di,do,v0,vn):
Hx=craticalTE(V,E,di,v0,vn)
Hn=Hx[len(V)-1]
Hy=craticalTL(V,E,do,Hn,v0,vn)
V=list(V)
N=len(V)
C=set({})
for k in range(N):
if Hx[k] == Hy[k]:
C=C|{V[k]}
W=set({})
for (w,u,v) in E:
if u in C and v in C:
W=W|{(u,v,w)}
return W
def main( ):
global V0,E0,V,E,path
V0={0,1,2,3,4,5} # 顶点集
E0={(0,1),(0,2),(0,3),(1,2),(1,4),(2,3),(2,5),(3,4),(3,5),(4,5)} # 边集
E={(1,0,1),(3,0,2),(5,0,3),(1,1,2),(2,1,4),(1,2,3),(2,2,5),(1,3,4),(3,3,5),(2,4,5)} # 带权的边集
drawdigraph(E0)
[d,di,do]=degreeset(V0,E) # 我理解这个函数的意思是，对每一个顶点算出度、入度、出度
# 保存在三个容器中
v0=0 # 起始结点
vn=5 # 终止结点
W=craticalpath(V0,E,di,do,v0,vn)
S=graphw2graph(W)
drawdigraph(S)
return W
二分图判断
def isbigraph(V,E,V1,V2):
tv=(V==V1|V2) # V是V1和V2的并
tv=tv&(V1&V2==set({})) # V1交V2是空集
for (u,v) in E: # E中的每条边都是一个点在V1一个点在V2
tv=tv&(u in V1)&(v in V2)
return tv