def Teste():
G = GrafoListaAdj(orientado = False)
G.DefinirN(12)
G.AdicionarAresta(1,7)
G.AdicionarAresta(1,8)
G.AdicionarAresta(1,9)
G.AdicionarAresta(2,7)
G.AdicionarAresta(2,8)
G.AdicionarAresta(2,9)
G.AdicionarAresta(3,7)
G.AdicionarAresta(3,10)
G.AdicionarAresta(3,11)
G.AdicionarAresta(4,8)
G.AdicionarAresta(5,10)
G.AdicionarAresta(5,11)
G.AdicionarAresta(5,12)
G.AdicionarAresta(6,12)
G.tV1 = 6
G.Desenhar("G.png")
M = EmparelhamentoBipartido(G)
for v in G.V():
if M[v] != None:
for w_no in G.N(v, IterarSobreNo=True):
if w_no.Viz == M[v]:
G.DefinirAtrE(w_no, 'color=blue')
G.Desenhar("G-M.png")
print()
def CompFortementeConexas(D):
def F(v):
global j
D.Marcado[v] = True
j = j + 1
PE[v], low[v] = j, j
for w in D.N(v, Tipo="+"):
if not D.Marcado[w]:
T.AdicionarAresta(v, w)
F(w)
low[v] = min(low[v], low[w])
else:
if not T.Escrito[w]:
low[v] = min(low[v], PE[w])
if low[v] == PE[v]:
C = []
EscreverComponente(T, v, C)
print("Componente:", C)
global j
j = 0
D.Marcado, PE, low = [False] * (D.n + 1), [0] * (D.n + 1), [0] * (D.n + 1)
T = GrafoListaAdj(orientado=True)
T.DefinirN(D.n)
T.Escrito = [False] * (T.n + 1)
for s in D.V():
if not D.Marcado[s]:
F(s)
def LerGrafosTeste():
for num in range(1, 3):
if num == 1:
E = [(1, 2, 1), (2, 3, 2), (3, 4, 10), (3, 5, 3), (2, 6, 8),
(6, 7, 7), (7, 8, 2), (7, 9, 2), (6, 10, 5), (10, 11, 3),
(10, 12, 6), (10, 13, 1)]
k = 3
else:
E = [(1, 5, 4), (5, 6, 3), (2, 6, 2), (6, 7, 4), (3, 7, 5),
(7, 4, 1)]
k = 3
SP = 0
T = GrafoListaAdj(orientado=False)
T.DefinirN(len(E) + 1)
for (u, v, d) in E:
e = T.AdicionarAresta(u, v)
e.d = d
SP = SP + d
d = [None] * (T.n + 1)
for i in range(1, T.n + 1):
d[i] = [None] * (T.n + 1)
for j in range(1, T.n + 1):
d[i][j] = float("-inf")
for v in T.V():
for no_u in T.N(v, IterarSobreNo=True):
u = no_u.Viz
d[v][u] = no_u.e.d
d[u][v] = d[v][u]
yield (T, d, k, SP)
def ObterRedeCamadas(Dlin, s, t):
Dest = GrafoListaAdj(orientado=True)
Dest.DefinirN(Dlin.n, VizinhancaDuplamenteLigada=True)
BuscaLargura(Dlin, s)
for (v, elin) in Dlin.E(IterarSobreNo=True):
w = elin.Viz
if Dlin.Nivel[v] < min(Dlin.Nivel[w], Dlin.Nivel[t]) and elin.e.r > 0:
e = Dest.AdicionarAresta(v, w)
e.eD, e.r, e.direta = elin.e.eD, elin.e.r, elin.e.direta
#vértices não são removidos; busca em profundidade é modificada para remover arestas que não obtiveram sucesso em encontrar t. Assim, a condição "Dest é vazio" deve se trocado por "existe caminho entre s,t"
return Dest
def ObterD(G, M): D = GrafoListaAdj(orientado = True) D.DefinirN(G.n+1) D.tV1 = G.tV1 D.Exp = [False]*(D.n+1) for v in range(1, D.n): D.Exp[v] = (M[v] == None) for v in range(1, G.tV1+1): if D.Exp[v]: D.AdicionarAresta(D.n, v) for w in G.N(v): if M[v] == w: D.AdicionarAresta(w,v) else: D.AdicionarAresta(v,w) return D
def ObterRedeResidual(D):
""" Rede D: Digrafo com rótulo c (capacidade), f (fluxo) nas arestas, vértices s=1 e t=D.n
Retorna digrafo residual, com rótulos r (residuo), direta (direta ou nao), eD (aresta correspondente em D)
"""
Dlin = GrafoListaAdj(orientado=True)
Dlin.DefinirN(D.n)
for (v, uv) in D.E(IterarSobreNo=True):
uv = uv.e
if uv.c - uv.f > 0:
e = Dlin.AdicionarAresta(uv.v1, uv.v2)
e.r = uv.c - uv.f
e.direta = True
e.eD = uv
if uv.f > 0:
e = Dlin.AdicionarAresta(uv.v2, uv.v1)
e.r = uv.f
e.direta = False
e.eD = uv
return Dlin
def ObterGFMF(G, M, F, H):
GF = GrafoListaAdj(orientado=False)
GF.DefinirN(G.n - len(F) + 1)
GF.VAssocD = [None] * (GF.n + 1)
G.VAssocO = [None] * (G.n + 1)
G.VizEmF = [None] * (G.n + 1)
ArestaComFlor = [False] * (G.n + 1)
G.VAssocStr = ""
#vertices de F em G serao associados ao vertice 1 de GF
for v in F:
G.VAssocO[v] = 1
GF.VAssocD[1] = F[0]
n = 2
for v in G.V():
if G.VAssocO[v] == None:
G.VAssocO[v] = n
GF.VAssocD[n] = v
n = n + 1
MF = [None] * (GF.n + 1)
for v in G.V():
if M[v] != None and G.VAssocO[v] != G.VAssocO[M[v]]:
MF[G.VAssocO[v]] = G.VAssocO[M[v]]
for v in G.V():
for w in G.N(v):
if v < w:
(x, y) = (v, w) if G.VAssocO[v] == 1 else (w, v)
if G.VAssocO[y] != 1:
if G.VAssocO[x] == 1:
if G.VizEmF[y] == None or GF.VAssocD[1] == x:
G.VizEmF[y] = x
if not ArestaComFlor[y]:
ArestaComFlor[y] = True
GF.AdicionarAresta(G.VAssocO[x], G.VAssocO[y])
else:
GF.AdicionarAresta(G.VAssocO[x], G.VAssocO[y])
return (GF, MF)
def LerGrafosTeste():
for num in range(1, 5):
if num == 1:
E = [(1, 2), (2, 3), (3, 4), (3, 5), (2, 6), (6, 7), (7, 8),
(7, 9), (6, 10), (10, 11), (10, 12), (10, 13)]
elif num == 2:
E = [(1, 5), (5, 6), (2, 6), (6, 7), (3, 7), (7, 4)]
elif num == 3:
E = [(1, 2), (2, 3), (3, 4), (4, 5)]
else:
E = [(1, 2), (2, 3), (3, 4), (3, 5), (3, 6), (2, 9), (9, 10),
(2, 7), (7, 8), (8, 11), (8, 12), (8, 13)]
T = GrafoListaAdj(orientado=False)
T.DefinirN(len(E) + 1, VizinhancaDuplamenteLigada=True)
for (u, v) in E:
T.AdicionarAresta(u, v)
yield (T)
def arvoreMinima(grafo):
E = []
G = GrafoListaAdj(orientado=False)
for a in grafo.arestas:
E.append((int(a.v1.id) + 1, int(a.v2.id) + 1, a.peso))
G.DefinirN(len(grafo.vertices))
for (u, v, w) in E:
e = G.AdicionarAresta(u, v)
e.w = w
ET = ArvoreGerMinima(G)
tree = []
for i in ET:
tree.append((i.v1 - 1, i.v2 - 1))
counter1 = 0
counter2 = 0
final = []
#print len(grafo.arestas)
for i in grafo.arestas:
counter1 += 1
adj1 = (int(i.v1.id), int(i.v2.id))
if tree.count(adj1) == 1:
counter2 += 1
final.append(i)
#grafo.removeAresta(i)
#else:
# grafo.removeAresta(i)
#print counter1, counter2, len(final)
#print tree, len(tree)
#print [(a.v1.id, a.v2.id) for a in final]
return final
def LerGrafosTeste(): for num in range(1,5): if num == 1: E = [(1,2),(2,3),(3,4),(3,5),(2,6),(6,7),(7,8),(7,9),(6,10),(10,11),(10,12),(10,13)] n = len(E)+1 elif num == 2: E = [(1,5),(5,6),(2,6),(6,7),(3,7),(7,4)] n = len(E)+1 elif num == 3: E = [(1,2),(2,3),(3,4),(4,5)] n = len(E)+1 else: E = [(1,2),(2,3),(3,4),(3,5),(3,6),(2,9),(9,10),(2,7),(7,8),(8,11),(8,12),(8,13)] n = len(E)+1 G = GrafoListaAdj(orientado=False) G.DefinirN(n) for (u,v) in E: G.AdicionarAresta(u,v) yield G
def Aumentante(G, M):
#Construcao de Df
Df = GrafoListaAdj(orientado=True)
Df.DefinirN(G.n)
Df.ExpAssoc = [None] * (Df.n + 1)
for v in G.V():
for w in G.N(v):
if M[w] != v: #vw nao esta em M
if M[w] == None:
Df.ExpAssoc[v] = w
else:
e = Df.AdicionarAresta(v, M[w])
e.inter = w
Df.Exp = [True] * (Df.n + 1)
for v in M:
if v != None:
Df.Exp[v] = False
Pf = BuscaCamAumentante(Df)
(P, F, H) = CONSTRUCAO_3(Pf, Df, G, M)
return (P, F, H)
s = D.n
P(s)
return Q[1:]
def DifSimetrica(M, P):
""" M: emparelhamento, P: (arestas de) um caminho. Retorna a diferença simétrica de M por P """
MR = [v for v in M]
for i in range(0, len(P), 2):
MR[P[i]], MR[P[i + 1]] = P[i + 1], P[i]
return MR
G = GrafoListaAdj(orientado=False)
E = [(1, 4), (2, 4), (3, 4), (3, 5), (3, 6), (3, 7)]
G.DefinirN(7)
for (u, v) in E:
G.AdicionarAresta(u, v)
G.tV1 = 3
M = EmparelhamentoBipartido(G)
print(M)
G = GrafoListaAdj(orientado=False)
G.DefinirN(15)
E = [(1, 8), (1, 9), (2, 8), (2, 9), (2, 10), (3, 9), (3, 10), (3, 11),
(4, 10), (4, 11), (5, 11), (5, 12), (6, 11), (6, 13), (6, 14), (6, 15),
(7, 14), (7, 15)]
for (u, v) in E:
G.AdicionarAresta(u, v)
G.tV1 = 7
M = EmparelhamentoBipartido(G)
D.Marcado = [False] * (D.n + 1)
if P(s):
break
return Q
def CONSTRUCAO_3(Pf, Df, G, M):
Ciclo = None
H = None
VMarcado = [-1] * (Df.n + 1)
i = 0
for v in Pf:
if VMarcado[v] > -1:
Ciclo = Pf[VMarcado[v]:i]
H = Pf[:VMarcado[v] + 1]
break
else:
VMarcado[v] = i
i = i + 1
return (Pf, Ciclo, H)
G = GrafoListaAdj(orientado=False)
G.DefinirN(9)
E = [(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9), (2, 4)]
for (u, v) in E:
G.AdicionarAresta(u, v)
M = EmparelhamentoGeral(G)
print(M)
rlin = T[rlin] M = DifSimetrica(M, P) EXPOSTO[r] = False; EXPOSTO[rlin] = False par = [None] + [ EXPOSTO[v] for v in G.V() ] impar = [False]*(G.n+1) T = [None] + [ (v if EXPOSTO[v] else None) for v in G.V() ] E = G.E() (u,v) = next(E, (None, None)) return M def DifSimetrica(M, P): MR = [ v for v in M ] for i in range(0, len(P), 2): MR[P[i]], MR[P[i+1]] = P[i+1], P[i] return MR G = GrafoListaAdj(orientado = False) G.DefinirN(15) E = [(1,8),(1,9),(2,8),(2,10),(3,9),(3,10),(4,10),(4,11),(5,11),(5,12),(6,11),(6,13),(6,14),(6,15),(7,14),(7,15)] for (u,v) in E: G.AdicionarAresta(u,v) G.tV1 = 7 M = EmparelhamentoBipartidoMetodoHungaro(G) print (M) print()
def ArvoreGerMinima(G): """G: grafo conexo em lista de adjacência, E(G) rotulado com inteiro w""" S = UniaoDisjunta(G.n); for v in G.V(): S.Insere(v) ET = []; E = [] for v in G.V(): for w_no in G.N(v, IterarSobreNo=True): if w_no.Viz < v: E.append(w_no.e) E.sort(key=lambda e: e.w) for e in E: v,w = e.v1,e.v2 if S.Conjunto(v) != S.Conjunto(w): S.Une(v,w) ET.append(e) return ET G = GrafoListaAdj(orientado = False) E = [(1,2,4),(1,3,2),(1,4,6),(2,4,9),(2,3,1),(2,5,4),(3,4,7),(3,5,5),(3,6,6),(4,6,2),(3,6,7)] G.DefinirN(6) for (u,v,w) in E: e = G.AdicionarAresta(u,v); e.w = w ET = ArvoreGerMinima(G) print ([(e.v1,e.v2) for e in ET]) print()
