def setDistancias(self):
'''
saltos =
1: Prof -> Disc
2: Disc -> Dia
3: Dia -> Horario
4: Horario -> Labs
'''
for p in self.Prof:
for dc in self.Disc:
distancia = self.DisciplinaPorProfessor(
self.Prof[p], self.Disc[dc])
self.Arestas.append(
Aresta(1, self.Prof[p], self.Disc[dc], distancia))
for dc in self.Disc:
for di in self.Dias:
distDia = self.DiasPorDisciplina(self.Disc[dc], self.Dias[di])
self.Arestas.append(
Aresta(2, self.Disc[dc], self.Dias[di], distDia))
for h in self.Horarios:
distHorario = self.HorariosPorDisciplina(
self.Disc[dc], self.Horarios[h], distDia)
self.Arestas.append(
Aresta(3, self.Dias[di], self.Horarios[h],
distHorario))
for l in self.Labs:
distLab = self.DiscplinaPorLaboratorio(
self.Disc[dc], self.Labs[l], distHorario)
self.Arestas.append(
Aresta(4, self.Horarios[h], self.Labs[l], distLab))
def insert_edge(self, vertex_a, vertex_b, peso, label=None):
if vertex_a in self.vertices and vertex_b in self.vertices:
if label is None or label == "":
label = vertex_a + vertex_b
if label not in self.edges:
if peso != "":
self.edges[label] = Aresta(vertex_a, vertex_b, peso)
else:
self.edges[label] = Aresta(vertex_a, vertex_b)
self.vertices[vertex_a].add_adj_vertex(vertex_b)
self.vertices[vertex_b].add_adj_vertex(vertex_a)
if self.debug >= 1:
self.debug_version()
return "Inserida aresta: " + label
return "Aresta já existe no grafo. Não inserida."
return "Inserir os vértices primeiro."
def nova_aresta(self, origem, destino, peso):
origem_aux = self.busca_vertice(origem)
destino_aux = self.busca_vertice(destino)
if (origem_aux is not None) and (destino_aux is not None):
self.lista_arestas.append(Aresta(origem_aux, destino_aux, peso))
else:
print("Um dos Vertices ou ambos sao invalidos")
def adiciona_aresta(self, inicio, fim, peso):
if not isinstance(inicio, Vertice) or not isinstance(fim, Vertice):
raise ValueError("Para adicionar uma aresta, os atributos inicio e " +
"fim devem ser provindos da classe Vértice.")
# evita ligação entre dois computadores e duas tarefas
if inicio in self.__computadores and fim in self.__computadores:
raise ValueError("Não é possível fazer uma ligação entre dois computadores.")
if inicio in self.__tarefas and fim in self.__tarefas:
raise ValueError("Não é possível fazer uma ligação entre duas tarefas.")
# evita ligações entre máquinas e tarefas não cadastradas
# pois neste trecho é garantido que não há ligações entre máquinas/máquinas
# e tarefas/tarefas
if inicio not in self.__computadores and inicio not in self.__tarefas and self.__sorvedouro != inicio:
raise ValueError("O vértice que representa o início da aresta não foi adicionado.")
if fim not in self.__computadores and fim not in self.__tarefas and self.__fonte != fim:
raise ValueError("O vértice que representa o fim da aresta não foi adicionado.")
# Finalmente, posso criar a aresta e fazer atribuições
ligacao = Aresta(inicio, fim, peso)
# adiciona aresta presente na ligação e seu devido mapeamento
self.__ligacoes[inicio].append(ligacao)
def gerate_arestas(self, vertices, qtd_arestas_max):
aresta = set()
if not vertices:
vertices = self.vertices
for v_part in vertices:
v_destino = sample(vertices, randint(0, qtd_arestas_max))
aresta.add(v_part)
for v_dest in v_destino:
aresta.add(v_dest)
if len(aresta) == 2:
a = Aresta(aresta)
self.arestas.add(a)
else:
pass
# while v_part is v_dest:
# desvio = v_dest
# v_destino.remove(v_dest)
# if len(v_destino) > 1:
# v_dest = sample(v_destino, 1)[0]
# else:
# v_destino.insert(0, desvio)
# break
if v_dest.nome != v_part.nome:
# if not(any((v_dest, v_part) in a for a in self.arestas) and any((v_part, v_dest) in a for a in self.arestas)):
# self.arestas.add(Aresta([v_part, v_dest]))
self.add_matriz_adj(v_part)
self.add_matriz_adj(v_dest)
aresta.clear()
if all(type(x) is Vertice for x in vertices):
for v in vertices:
self.lista_adjacencia.append(self.vizinhos(v))
else:
TypeError("Um nao-vertice foi informado em {0}".format(vertices))
return len(self.arestas)
def makeArestas(matriz,qtdeVertices):
arestas = []
for i in range((qtdeVertices-1)):
for j in range(i+1,qtdeVertices):
if(matriz[i][j] > 0):
arestas.append(Aresta(i,j,matriz[i][j]))
return arestas
def adicionarAresta(self, origem, destino, custo):
aresta = Aresta(origem=origem, destino=destino, custo=custo)
self.arestas[(origem, destino)] = aresta
if origem not in self.vizinhos:
self.vizinhos[origem] = [destino]
else:
self.vizinhos[origem].append(destino)
def novaAresta(self, origem, destino, peso):
origemIndex = self.buscaVerticeId(origem)
destinoIndex = self.buscaVerticeId(destino)
if (origemIndex is not None) and (destinoIndex is not None):
self._arestas.append(Aresta(origemIndex, destinoIndex, peso))
print("okkkkkkk")
else:
print("vertice invalido")
def ler_de_arquivo(arq):
cont = open(arq, 'r').read()
dic = ast.literal_eval(cont)
grf = Grafo(0) # Cria um Grafo vazio
grf.nome = dic[
'nome'] # Extrai o nome do arquivo e inclui direto no grafo vazio
lista = []
# grf.vertices = dic['vertices']
for v in dic['vertices']:
grf.vertices.append(
Vertice(v)
) # Cria um Vertice para cada vertice extraido do arquivo e inclui em vertices
grf.qtd_vertices = int(len(grf.vertices)) # atualiza o Numero de vertices
# grf.arestas = dic['arestas']
for a in dic['arestas']: # para cada aresta do arquivo...
if type(a) is list and len(
a) == 2: # verifica se é válida (uma lista com 2 elementos)...
for v in a: # e para cada elemento dessa lista de 2...
for vertc in grf.vertices: # verifica se corresponde a um vertice obtidos...
if str(v) == vertc.nome: # através do nome...
lista.append(vertc) # e junta a uma lista parcial...
grf.arestas.add(
Aresta(lista)) # para gerar uma aresta com esses 2 vertices
lista.clear() # limpa a lista parcial para recomeçar
else:
grf.arestas.add(
Aresta(a)
) # caso não ache o vertice em vértices, registra como uma lista de vertices, não uma resta
for x in range(
0, grf.qtd_vertices
): # reeinicia a matriz de adjacencia vazia com os vértices inseridos anteriormente
grf.matriz_adjacencia.append(
list(itertools.repeat(0, grf.qtd_vertices)))
for v in grf.vertices:
grf.add_matriz_adj(
v
) # popular matriz de adjacencia vazia com os vértices inseridos anteriormente
grf.lista_adjacencia.append(
grf.vizinhos(v)) # popular lista de adjacências
return grf
def nova_aresta(self, origem, destino, peso):
origem_aux = self.busca_no(origem)
destino_aux = self.busca_no(destino)
'''
if (origem_aux):
#print(origem)
if (destino_aux):
print(destino)
'''
if ((origem_aux is not None) and (destino_aux is not None)):
self.lista_arestas.append(Aresta(origem_aux, destino_aux, peso))
#print("aresta criada")
else:
print("############ ERROR ############")
print("Aresta nao criada nos invalidos")
def main():
g1 = Grafo(False) # gera um grafo sem direção
v1 = Vertice("a", 12) # cria o vérice v1
g1.add_vertice(v1) # insere o vérice v1 no grafo g1
v2 = Vertice("b", 13) # cria o vértice v2
g1.add_vertice(v2) # insere o vértice v2 no grafo g1
v3 = Vertice("c", 6) # cria o vértice v3
g1.add_vertice(v3) # insere o cértice v3 no grafo v3
a1 = Aresta(v1, v2, "a1", 2) # cria uma aresta entre v1 e v2
a2 = Aresta(v2, v3, "a2", 2) # cria uma aresta entre v2 e v3
a3 = Aresta(v3, v1, "a3", 2) # cria uma aresta entre v3 e v1
# corrigir
g1.add_aresta(a1) # insere a aresta a1 no grafo
g1.add_aresta(a2) # insere a aresta a2 no grafo
g1.add_aresta(a3) # insere a aresta a3 no grafo
print(g1)
g1.getFTD(v1)
g1.dfs()
def __init__(self, num_vertices, arestas):
self.num_comparacoes = 0
# Cria os vertices
self.vertices = []
for i in range(num_vertices):
vertice = Vertice(i)
self.vertices.append(vertice)
# Cria um dicionario de arestas com o par de vertices sendo a chave
self.dic_arestas = {}
for aresta in arestas:
v1, v2, capacidade = aresta
key = (v1, v2)
invert_key = (v2, v1)
aresta_dicionario = self.dic_arestas.get(key)
# Se nao existe aresta entre os vertices no dicionario
if (aresta_dicionario is None):
nova_aresta = Aresta(v1, v2, capacidade)
self.dic_arestas[key] = nova_aresta
self.dic_arestas[invert_key] = nova_aresta
else:
# Se existir mais de uma aresta entre dois vertices, pode-se
# considerar que existe apenas uma aresta com a soma das
# capacidades
self.dic_arestas[key].capacidade += capacidade
self.dic_arestas[key].atualiza_residual()
# Cria um vetor com os indices das arestas (para facilitar a criação da
# lista de adjacencia)
self.indices_arestas = set()
for aresta in arestas:
key = (aresta[0], aresta[1])
invert_key = (aresta[1], aresta[0])
if (key in self.indices_arestas
or invert_key in self.indices_arestas):
continue
self.indices_arestas.add((aresta[0], aresta[1]))
self.grafo = ListaAdjacencia(num_vertices, self.indices_arestas)
def insereAresta(self, idVerticeOrigem, idVerticeDestino):
"""
insere uma aresta no grafo, verificando se os vértices existem
Args:
idVerticeOrigem (string): id do vértice de origem da aresta
idVerticeDestino (string): id do vértice de destino da aresta
Returns:
bool: True caso consiga ser feita a criação da aresta, e false caso contrário
"""
v1 = self.buscaVertice(idVerticeOrigem)
v2 = self.buscaVertice(idVerticeDestino)
if(v1 == None or v2 == None):
print("ERRO!:Algum vértice inválido")
return False
self.listaArestas.append(Aresta(v1,v2))
return True
def prim(grafo):
# Inicializa a árvore geradora mínima
arvore = []
# Pega um vértice inicial qualquer
vertice = 0 # vértice aleatório -> random.randint(0, len(grafo) - 1)
# Inicializa fila sem elementos repetidos para comparar pesos de arestas
filaSet = set()
filaSet.add(vertice)
# Enquanto a árvore tem menos vértices que o grafo,
while len(arvore) < len(grafo) - 1:
# Inicializa variáveis do while
min = inf
vertice = None
outroVertice = None
# Pra cada vértice U da fila,
for verticeU in filaSet:
# Pra cada vértice V do grafo,
for verticeV in range(len(grafo)):
# Se o peso da aresta entre U e V for menor que o mínimo
if grafo[verticeU][verticeV] < min:
# Atualiza mínimo
min = grafo[verticeU][verticeV]
# Guarda valores para mais tarde
vertice = verticeU
outroVertice = verticeV
# Adiciona "último verticeV" para comparação posterior
filaSet.add(outroVertice)
# Adiciona aresta entre "últimos" U e V na árvore, já que é mínima
arvore.append(
Aresta(grafo[vertice][outroVertice], vertice, outroVertice))
# "Retira" os dois vértices da comparação pois já foram checados
# Nos dois sentidos pois o grafo é simples e a matriz é simétrica
grafo[vertice][outroVertice] = inf
grafo[outroVertice][vertice] = inf
# Alteramos o grafo, mas estamos interessados na árvore
return arvore
noE9 = Vertice('E9', 12)
vertices.append(noE9)
noE10 = Vertice('E10', 27)
vertices.append(noE10)
noE11 = Vertice('E11', 15)
vertices.append(noE11)
noE12 = Vertice('E12', 0)
vertices.append(noE12)
noE13 = Vertice('E13', 31)
vertices.append(noE13)
noE14 = Vertice('E14', 37)
vertices.append(noE14)
custo_trafego_desta_aresta = 0 # cada aresta possui seu custo
noE1.add_aresta_adj(Aresta(noE2, 11, 'azul',
custo_trafego_desta_aresta)) # azul
noE2.add_aresta_adj(Aresta(noE1, 11, 'azul',
custo_trafego_desta_aresta)) # azul
noE2.add_aresta_adj(Aresta(noE3, 9, 'azul',
custo_trafego_desta_aresta)) # azul
noE2.add_aresta_adj(Aresta(noE9, 11, 'amarelo',
custo_trafego_desta_aresta)) # amarelo
noE2.add_aresta_adj(Aresta(noE10, 4, 'amarelo',
custo_trafego_desta_aresta)) # amarelo
noE3.add_aresta_adj(Aresta(noE2, 9, 'azul',
custo_trafego_desta_aresta)) # azul
noE3.add_aresta_adj(Aresta(noE4, 7, 'azul',
custo_trafego_desta_aresta)) # azul
noE3.add_aresta_adj(
# arestas.append(Aresta(1, 'a', 'b'))
# arestas.append(Aresta(8, 'a', 'c'))
# arestas.append(Aresta(3, 'c', 'b'))
# arestas.append(Aresta(4, 'b', 'd'))
# arestas.append(Aresta(2, 'd', 'e'))
# arestas.append(Aresta(3, 'b', 'e'))
# arestas.append(Aresta(-1, 'c', 'd'))
# arestas.append(Aresta(13, '0', '3'))
# arestas.append(Aresta(24, '0', '1'))
# arestas.append(Aresta(13, '0', '2'))
# arestas.append(Aresta(22, '0', '4'))
# arestas.append(Aresta(13, '1', '3'))
# arestas.append(Aresta(22, '1', '2'))
# arestas.append(Aresta(13, '1', '4'))
# arestas.append(Aresta(19, '2', '3'))
# arestas.append(Aresta(14, '2', '4'))
# arestas.append(Aresta(19, '3', '4'))
arestas.append(Aresta(2, "0", "1"))
arestas.append(Aresta(-10, "0", "3"))
arestas.append(Aresta(3, "0", "2"))
arestas.append(Aresta(5, "1", "2"))
arestas.append(Aresta(0, "1", "3"))
arestas.append(Aresta(4, "2", "3"))
grafo = kruskal(arestas)
print("Imprimindo árvore geradora mínima:")
for aresta in grafo:
print(f"Peso {aresta.peso:2}: {aresta.first:1} para {aresta.second:2}")