def djikstra(arquivo, s):
# Inicialização
G = GrafoDicionario(arquivo)
Tab = tabelaDj(G, s)
while not Tab.nVisitados():
#selecionar um vertice nao visitado que tenha o menor D
u = Tab.getNotVisited()
Tab.setVisitado(u)
#loop para cada vertice vizinho de u nao visitado
for vizinho in G.vizinhos(u):
distAtual = Tab.getDistancia(u) + G.grafo[u][vizinho]
if Tab.getDistancia(vizinho) > distAtual:
Tab.setDistancia(distAtual, vizinho)
Tab.setAncestral(u + 1, vizinho)
#print(Tab)
return Tab.Result()
def subGrafo(self,Pset):
arestas = []
arestas_set = []
for vertice in Pset:
vizinhos = list((self.G.vizinhos(vertice)).keys())
for vizinho in vizinhos:
if vizinho in Pset:
arestas.append((int(vertice), int(vizinho), float(0.0)))
arestas_set.append({int(vertice), int(vizinho)})
subG = GrafoDicionario(None,False,Pset,arestas,arestas_set)
#print(subG)
return subG
def ciclo_euleriano(arquivo):
def buscarSubcicloEuleriano(G, v, C):
# Marca início do ciclo
ciclo = [v]
t = v
while True:
# Só prossegue se existir uma aresta não-visitada conectada a Ciclo
for u in G.vizinhos(v).keys():
if {u, v} in C or {v, u} in C:
break
else:
return None
# Prosseguindo, marca a aresta como visitada, isto é, remove-la de C
C.remove({v, u})
# Adiciona o vértice v ao final do ciclo
v = u
ciclo.append(v)
# Ciclo encontrado
if v == t:
break
# Para todo vértice x no ciclo que tenha uma aresta adjacente não visitada
for i in range(len(ciclo)):
c = ciclo[i]
for u in G.vizinhos(c).keys():
# Se há uma aresta no ciclo que possui aresta não visitadas
if {u, c} in C or {c, u} in C:
novo_ciclo = buscarSubcicloEuleriano(G, c, C)
if not novo_ciclo:
return None
# Inclui o novo ciclo no ciclo anterior
ciclo.pop(i)
for v in novo_ciclo[::-1]:
ciclo.insert(i, v)
return ciclo
# Inicialização
G = GrafoDicionario(arquivo)
C = G.E_set
v = 0 # Altere aqui o indice
return buscarSubcicloEuleriano(G, v, C)
# Glin = self.subGrafo(self.powersets[31])
#print(Glin)
vertices = Glin.getVertices()
conjuntos = self.independentesMaximais(Glin)
indMax = conjuntos
#self.printTab()
if len(conjuntos) > 0:
#print(conjuntos)
for conjunto in conjuntos:
#print(conjunto)
ids = []
cVertices = vertices.copy()
#subtraio do meu Glin o conjunto atual
for c in conjunto:
cVertices.pop(self.retIDlista(cVertices,c))
cVertices.sort()
#busco o valor do que sobrou na tabela e somo +1 e salvo para ver se algum conjunto consegue menor valor
val = self.consultaTab(cVertices) + 1
valAtual = self.consultaTab(vertices)
if val < valAtual:
self.preencheTab(vertices,val)
self.printTab()
return self.X[self.i-1]
if __name__ == '__main__':
arquivo = input('Nome do arquivo: ')
grafo = Lawler(GrafoDicionario(arquivo,True))
cores = grafo.executar()
print("Minimo necessário de cores: ",cores)
# 2) Ordenação Topológica
from grafo_dicionario import GrafoDicionario
# Le o nome do aqruivo e a posicao do vertice inicial
# arquivo = input('Nome do arquivo: ')
arquivo = input('Nome do arquivo: ')
# Cria o grafo
grafo = GrafoDicionario(arquivo)
# Inicializacao
# Ordenação Topológica
# DFS
def dfs_visit_ot(v):
C[v] = True
for u in grafo.vizinhos_dir(v):
if not C[u]:
dfs_visit_ot(u)
O.insert(0, v)
# DFS-Visit-OT
C = [False for _ in range(grafo.qtd_vertices())]
O = []
for u in grafo.grafo.keys():
if not C[u]:
dfs_visit_ot(u)
C[v] = True
tempo += 1
T[v] = tempo
for u in G.vizinhos_dir(v):
if not C[u]:
A[u] = v
tempo = dfs_visit(G, u, C, T, A, F, tempo)
tempo += 1
F[v] = tempo
return tempo
# Le o nome do aqruivo e a posicao do vertice inicial
# arquivo = input('Nome do arquivo: ')
arquivo = input('Nome do arquivo: ')
G = GrafoDicionario(arquivo)
# Componentes Fortemente Conexas
# Tornando V global para evitar criar 2 métodos dfs
V = G.grafo.keys()
# Primeira busca
C, T, Al, F = dfs(G)
# Ordenando V, basead em F, para a segunda busca
# Ordenando por index
F = sorted(range(len(F)), key=lambda i: F[i])
F.reverse()
V = F
elif D[mate[vertice2]] == inf:
D[mate[vertice2]] = D[vertice] + 1
Q.append(mate[vertice2])
return D[self.numE] != inf
def retMatchs(self):
mt = []
for vt1, vt2 in zip(self.X, self.mate):
#print("[",vt1,",",vt2,"]")
mt.append([vt1, vt2])
return mt
def executar(self): # Parece OK
m = 0
while self.BFS(self.G, self.mate, self.D) == True:
for x in self.X:
if self.mate[x] == None:
if self.DFS(self.G, self.mate, x, self.D):
m = m + 1
return m, self.retMatchs()
if __name__ == '__main__':
#arquivo = input('Nome do arquivo: ')
arquivo = "teste_hop2.txt"
G = GrafoDicionario(arquivo, True)
hop = Hop(G)
nMatch, matchs = hop.executar()
print("Numero de Matchs: ", nMatch)
print("Matchs: ", matchs)
# Busca em largura
from grafo_dicionario import GrafoDicionario
from math import inf
# Le o nome do aqruivo e a posicao do vertice inicial
arquivo = input('Nome do arquivo: ')
posicao_inicial = int(input('Posicao do vertice inicial: '))
# Cria o grafo
grafo = GrafoDicionario(arquivo)
s = posicao_inicial - 1
# Inicializacao
C = [False for _ in range(grafo.qtd_vertices())]
D = [inf for _ in range(grafo.qtd_vertices())]
A = [None for _ in range(grafo.qtd_vertices())]
C[s] = True
D[s] = 0
Q = []
Q.append(s)
# Busca em largura
i = 0
while Q:
u = Q.pop(0)
for v in grafo.vizinhos(u).keys():
if C[v] == False:
C[v] = True
D[v] = D[u] + 1
A[v] = u
Q.append(v)