def test_monta_grafo(self): # teste verdadeiro G = Grafo(dados_valido) self.assertEqual(G.cria_lista_adjacencia(), True) # testa falso G = Grafo(dados_invalido) self.assertEqual(G.cria_lista_adjacencia(), False)
def test_distancia(self): # teste verdadeiro G = Grafo(dados_valido) G.cria_lista_adjacencia() self.assertEqual(G.calcula_distancia(['0', '1', '2']), 21) # testa falso G = Grafo(dados_invalido) G.cria_lista_adjacencia() self.assertEqual(G.calcula_distancia(['0', '1', '2']), None)
def test_dijkstra(self):
# teste verdadeiro
G = Grafo(dados_valido)
G.cria_lista_adjacencia()
resposta_esperada = {'caminho': ['3', '1', '0'], 'distancia': 23}
self.assertEqual(G.dijkstra('0', '3'), resposta_esperada)
# testa falso
G = Grafo(dados_invalido)
G.cria_lista_adjacencia()
resposta_esperada = None
self.assertEqual(G.dijkstra('0', '3'), resposta_esperada)
def test_prim(self):
# teste verdadeiro
G = Grafo(dados_valido)
G.cria_lista_adjacencia()
resposta_esperada = {'caminho': [['2', '3', 12], ['2', '0', 14], ['0', '1', 10]], 'distancia': 36}
self.assertEqual(G.prim('2'), resposta_esperada)
# testa falso
G = Grafo(dados_invalido)
G.cria_lista_adjacencia()
resposta_esperada = None
self.assertEqual(G.prim('2'), resposta_esperada)
def test_profundidade(self):
# teste verdadeiro
G = Grafo(dados_valido)
G.cria_lista_adjacencia()
resposta_esperada = [['0'], ['1', '2'], ['2', '3', '2']]
self.assertEqual(G.busca_em_profundidade('0', '2'), resposta_esperada)
# testa falso
G = Grafo(dados_invalido)
G.cria_lista_adjacencia()
resposta_esperada = [['0']]
self.assertEqual(G.busca_em_profundidade('0', '2'), resposta_esperada)
def __init__(self, capacidad, id_esquina_polo_norte):
"""Crea una instancia de la clase."""
self.grafo = Grafo()
self.dicc_fabricas = {}
self.dicc_esquinas = {}
self.capacidad = int(capacidad)
self.polo_norte = int(id_esquina_polo_norte)
def __init__(self, matriz, n):
self.g = Grafo.Grafo(matriz, n)
self.visitado = [False] * (self.g.n**2)
self.bateriaAtual = self.g.bateriaInicial
self.retorno = list()
self.caminho = list()
self.SeqAcoes = list()
def cria_grafoOR() -> object:
"""
:rtype: object
"""
name = input("qual o nome do grafo: ")
x = int(input("Informe a quantidade de vertices do grafo ORIENTADO\n"))
lista = [0 for i in range(x)]
listaADJ = [['' for i in range(1)] for j in range(x)]
listaADJOB = [[0 for i in range(1)] for j in range(x)]
matriz = [[0 for i in range(x)] for j in range(x)]
print(matriz)
print(lista)
dicStN = {}
dicNtS = {}
for i in range(x):
a = str(input("informe os vertices a serem inseridos\n"))
vertice = Vertice(a, '', '')
lista[i] = vertice
dicStN[a] = i
dicNtS[i] = a
for i in range(x):
for j in range(x):
print('Existe arestas saindo do vertice ', dicNtS[j],
' para o vertice ', dicNtS[i],
'? (s para sim, qualquer letra para não): ')
c = input()
if (c == 's'):
s = int(input('Qual o peso da aresta: '))
matriz[i][j] = Aresta('', '', s)
else:
matriz[i][j] = Aresta('', '', 0)
print(lista)
print(listaADJ)
for i in range(len(lista)):
for j in range(len(lista)):
arest = matriz[i][j]
if (arest.num != 0):
x = dicNtS[i]
y = dicNtS[j]
listaADJ[i][0] = x
listaADJ[i].append(y)
listaADJOB[i][0] = lista[i]
listaADJOB[i].append(lista[j])
print(listaADJ)
print(listaADJOB)
new_graf = Grafo(name, matriz, lista, listaADJ, listaADJOB, dicStN,
dicNtS) # type: Grafo
print(new_graf.dicStN)
return new_graf
def procesarCadena(self, cadena, operacion):
grafo = Grafo(self.Q, self.Sigma, self.Delta, "AFD")
alfa = grafo.auxAlfabeto
est = grafo.auxEstados
tran = grafo.auxtransi
ax = self.q0[1]
bandera = False
for i in range(len(cadena)):
indest = est.index(ax)
indalfa = alfa.index(cadena[i])
if tran[est.index(ax) + (indalfa + (indest * (len(alfa)-1)))] != None:
bandera = True
ax = tran[est.index(ax) + (indalfa + (indest * (len(alfa)-1)))]
else:
bandera = False
break
if operacion == "proceCad":
if bandera == True and ax in self.F:
return True
else:
return False
elif operacion == "returnTran":
return tran
elif operacion == "returnAlfa":
return alfa
elif operacion == "returnEst":
return est
def grafo_aleatorio(n_vertices=5, n_arestas=6, is_conexo=True):
if n_arestas <= n_vertices and is_conexo == True:
raise Exception(
'Não é possível gerar um grafo conexo com n_arestas menor que n_vertices'
)
aleatorio = Grafo(n_vertices)
for i in range(n_vertices):
aleatorio.setInfo(i, f'Vertice {i}')
if is_conexo:
vertices = [i
for i in range(n_vertices)] # lista de vértices não usados
v = vertices.pop(random.randint(0,
len(vertices) -
1)) # primeiro vértice usado
adjcencias_conexas(aleatorio, v, vertices,
v) # criação das adjacencias
for i in range(n_arestas - len(aleatorio.arestas())):
aleatorio.criaAdjascencia(random.randint(0, n_vertices - 1),
random.randint(0, n_vertices - 1),
random.randint(1, 10))
else:
for i in range(n_arestas):
aleatorio.criaAdjascencia(random.randint(0, n_vertices - 1),
random.randint(0, n_vertices - 1),
random.randint(1, 10))
return aleatorio
def procesarCadenaConDetalles(self, cadena):
grafo = Grafo(self.Q, self.Sigma, self.Delta, "AFD")
alfa = grafo.auxAlfabeto
est = grafo.auxEstados
tran = grafo.auxtransi
ax = self.q0[1]
bandera = False
estadosRecorridos = str(self.q0[1])
for i in range(len(cadena)):
indest = est.index(ax)
indalfa = alfa.index(cadena[i])
if tran[est.index(ax) + (indalfa + (indest * (len(alfa)-1)))] != None:
bandera = True
ax = tran[est.index(ax) + (indalfa + (indest * (len(alfa)-1)))]
estadosRecorridos += (" -> "+str(ax))
else:
estadosRecorridos += " -> ?? "
bandera = False
break
if bandera == True and ax in self.F:
estadosRecorridos += " |CADENA ACEPTADA| "
return estadosRecorridos
else:
estadosRecorridos += " |CADENA NO ACEPTADA| "
return estadosRecorridos
def leerTroncales(self):
print("\033[0;32m" + "*** Reading JSON...***")
print("\033[0;32m" + "*** Mapping Troncales...***")
self.grafo = Grafo()
self.diccionarioTroncales = {}
for troncal in self.troncales:
letra = troncal["letra"]
nombre = troncal["nombre"]
C1 = troncal["conexion1"]
C2 = troncal["conexion2"]
C3 = troncal["conexion3"]
C4 = troncal["conexion4"]
C5 = troncal["conexion5"]
C6 = troncal["conexion6"]
self.diccionarioTroncales[letra] = nombre
self.grafo.agregarVertice(Vertice(letra))
if C1 != "": self.esquinas.append(letra + C1)
if C2 != "": self.esquinas.append(letra + C2)
if C3 != "": self.esquinas.append(letra + C3)
if C4 != "": self.esquinas.append(letra + C4)
if C5 != "": self.esquinas.append(letra + C5)
if C6 != "": self.esquinas.append(letra + C6)
print("\033[1;37m " +
"- - - - - - - - - - - - - - - - - - - - - - - - - -")
for esquina in self.esquinas:
self.grafo.agregarBorde(esquina[:1], esquina[1:])
self.grafo.imprimirGrafo(self.diccionarioTroncales)
print("\033[1;37m " +
"- - - - - - - - - - - - - - - - - - - - - - - - - -")
def app():
grafo = None
distancias = readFile("distancias.txt")
mapa = readFile("mapa.txt")
mapa_linhas = mapa.split("\n")
for i in mapa_linhas:
values = i.split(" ")
if grafo == None:
grafo = Grafo.Grafo(values[0], values[1])
else:
verticeOrigem = grafo.obterVerticePorNome(values[0])
verticeDestino = grafo.obterVerticePorNome(values[1])
arresta = Arresta.Arresta(verticeOrigem, verticeDestino,
int(values[2]))
verticeOrigem.addArresta(arresta)
#arrestaInversa = Arresta.Arresta(verticeDestino, verticeOrigem, values[2])
#verticeDestino.addArresta(arrestaInversa)
distancias_linhas = distancias.split("\n")
for i in distancias_linhas:
values = i.split(" ")
vertice = grafo.obterVerticePorNome(values[0])
vertice.setDistancia(int(values[1]))
caminho = grafo.aEstrela()
caminho.printCaminho()
def converteMAparaMI(matriz, ehDirecionado, ehPonderado):
tamanho = len(matriz)
listaVertices = list(range(tamanho))
listaArestas = []
listaJaInseridos = []
for i in range(
tamanho
): #Para cada posição da matriz verifica se tem uma ligação entre os vértices da posicção i e j
for j in range(tamanho):
if not ehDirecionado: #Verifica se o grafo é não direcionado
if matriz[i][j] != '0' and [
str(j), str(i), matriz[i][j]
] not in listaJaInseridos: #Verifica se há uma ligação entre os vértices i e j, e se já foi inserida anteriormente
listaArestas.append([
str(i), str(j), matriz[i][j]
]) #Insere na lista de arestas no formato (u,v,p)
listaJaInseridos.append(
[str(i), str(j), matriz[i][j]]
) #Insere na lista as arestas já inseridas, para evitar a repetição de arestas
elif matriz[i][
j] != '0': #Verifica se tem uma ligação entre os vértices da posição i e j
listaArestas.append(
[str(i), str(j), matriz[i][j]]
) #Insere na lista de arestas no formato (u,v,p), sem verificação se a aresta já foi inserida(grafo direcionado)
grafo = Grafo(
listaVertices, listaArestas, ehDirecionado,
ehPonderado) #Cria grafo auxiliar que será a entrada da geraMI
return geraMI(grafo)
def converteMIparaMA(matriz, ehDirecionado, ehPonderado):
qntArestas = len(matriz)
qntVertices = len(matriz[0])
listaArestas = []
listaVertices = list(range(qntVertices))
jaAcheiPrimeiro = False
for i in range(qntArestas):
for j in range(qntVertices):
if (matriz[i][j] != '0'):
if (ehDirecionado):
if (matriz[i][j] > '0'):
posicaoSaindo = j
peso = matriz[i][j]
else:
posicaoChegando = j
else:
if (jaAcheiPrimeiro):
segundaPosicao = j
else:
primeiraPosicao = j
peso = matriz[i][j]
jaAcheiPrimeiro = True
jaAcheiPrimeiro = False
if (ehDirecionado):
listaArestas.append(
[str(posicaoSaindo),
str(posicaoChegando), peso])
else:
listaArestas.append(
[str(primeiraPosicao),
str(segundaPosicao), peso])
grafo = Grafo(listaVertices, listaArestas, ehDirecionado, ehPonderado)
return geraMA(grafo)
def converteLAparaMI(
lista, ehDirecionado, ehPonderado
): # Utiliza os atributos para conversão ao inSves do objeto
listaV = lista.vertices
listaA = lista.arestas
grafo = Grafo(listaV, listaA, ehDirecionado, ehPonderado)
return geraMI(grafo)
def __init__(self, matriz, n):
self.g = Grafo.Grafo(matriz, n)
self.bateriaAtual = self.g.bateriaInicial
self.ouroAtual = 0
self.coletado = 0
self.explorados = 0
self.SeqAcoes = list()
self.distancias = {}
def __init__(self, busca, distancia=5):
self.ponto_inicial = 'http://www.rugbyfluminense.com.br/'
self.distancia = 2
self.crawler = Crawler.Crawler()
self.criar_no = Criar_No.Criar_No
self.catalogo = []
self.busca = busca #### termo buscado
self.grafo = Grafo.Grafo()
def monta_grafo(self, dados_do_grafo): if len(dados_do_grafo) > 0: self.grafo = Grafo(dados_do_grafo) #instancia da classe Grafo self.grafo.cria_lista_adjacencia() #metodo que cria a lista de adjacencia return True else: return False
def converteMIparaLA(
matriz, ehDirecionado,
ehPonderado): # Utiliza os atributos para conversão ao inves do objeto
listaV = matriz.vertices
listaA = matriz.arestas
grafo = Grafo(listaV, listaA, ehDirecionado, ehPonderado)
return geraLA(grafo)
def generarGrafo(self, colores):
# Inicializamos el Grafo
gra = Grafo.Grafo()
for i in range(self.g.numVertices):
gra.agregarVertice(i, colores[i])
for j in self.g.listaVertices:
vecinos = self.g.obtenerVertice(j).obtenerConexiones()
for h in vecinos:
gra.agregarArista(j, h.id, 0)
return gra
def inicializacion(self):
graph = Grafo.Grafo()
with open(self.path, mode='r') as f:
i = 0
for line in f.readlines():
if line.split()[0] == 'A':
_, w1, w2 = line.split()
if w1 != w2:
graph.agregarArista(int(w1), int(w2), 0)
elif line.split()[0] == 'V':
_, w = line.split()
graph.agregarVertice(int(w), 1)
i = i + 1
return graph
def converteMAparaLA(matriz, ehDirecionado, ehPonderado):
qntVertices = len(matriz)
listaVertices = list(range(qntVertices))
listaArestas = []
for i in range(qntVertices):
for j in range(qntVertices):
if (
matriz[i][j] != '0'
): # é percorrida toda matriz e ao final é achada a lista de arestas
listaArestas.append([str(i), str(j), matriz[i][j]])
grafo = Grafo(listaVertices, listaArestas, ehDirecionado, ehPonderado)
return geraLA(grafo) #geração da LA por meio do grafo instanciado
def leer_itinerario(archivo):
grafito = Grafo(DIRIGIDO)
with open(archivo) as file:
itinerario_csv = csv.reader(file, delimiter='\n')
for linea in itinerario_csv:
lineas = linea[0].split(',')
if len(lineas) == 2: poner_arista(grafito, lineas[0], lineas[1])
else:
for elem in lineas:
grafito.agregar_vertice(elem)
return orden_topologico_dfs(grafito)
def definirClube(aData = []):
serie = Grafo()
print(20 * "-", "CLUBES", 20 * "-", "HABILIDADE", 18 * "-")
with open('times.txt', 'r') as file:
lines = file.readlines()
for data in lines:
dados = data[:-1]
habilidade = random.randint(0, 10)
# aData.append({dados:habilidade})
clube = Vertice()
clube.nome = dados
clube.dado = habilidade
vizinho = Vertice()
vizinho.nome = dados
vizinho.dado = habilidade
# print(clube.nome, clube.dado)
serie.grafo = {clube.nome:clube.dado}
# key = hash(serie.grafo)
print(serie.grafo)
def gera(self):
linhaMapeadas = []
grafo = Grafo.Grafo()
grafo.montaGrafo()
lDao = LinhaDAO.LinhaDAO()
pcDAO = PCDao.PCDao()
listLinha = lDao.getLinhasOrdenadasDistancia()
for linha in listLinha:
pcList = pcDAO.pcFromLinhas(linha)
linhaNome = lDao.linhaNome(linha)
grafo.addEdge(pcList, linha)
l = self.generateLinha(grafo, pcList, linhaNome, linha)
linhaMapeadas.append(l)
grafoHash = {}
grafoHash["nos"] = grafo.g.nodes(data=True)
grafoHash["arestas"] = grafo.g.edges()
grafoHash["linhas"] = linhaMapeadas
return grafoHash
def recuperar(file: str):
g_file = open(file, 'r')
data = g_file.read()
linhas = data.split('\n')
grafo = Grafo(int(linhas[0][11:]))
linha = 1
for i in linhas[1:]:
if i[0] == '*': break
else:
l = i.split()
grafo.setInfo(int(l[0]), l[1] + l[2])
linha += 1
for i in linhas[linha + 1:-1]:
l = i.split()
grafo.criaAdjascencia(int(l[0]), int(l[1]), int(l[2]))
return grafo
from Grafo import *
# from test_Roteiro7 import VerificarTests
# test = VerificarTests()
# test.setUp()
# test.test_Dijkstra()
def adiciona_ae(grafo, aresta, vezes):
for vez in range(vezes):
grafo.adicionaAresta(aresta)
g1 = Grafo(['A', 'B', 'C', 'D', 'E', 'F'])
adiciona_ae(g1, 'A-B', 2)
adiciona_ae(g1, 'A-F', 1)
adiciona_ae(g1, 'A-D', 1)
adiciona_ae(g1, 'B-C', 2)
adiciona_ae(g1, 'D-C', 5)
adiciona_ae(g1, 'C-E', 3)
adiciona_ae(g1, 'D-E', 7)
adiciona_ae(g1, 'D-F', 1)
adiciona_ae(g1, 'F-E', 9)
print(g1.kruskal())
# print(g1.peso_aresta('D-E'))
# g2 = Grafo(['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13'])
# g2.adicionaAresta('1-2')
# g2.adicionaAresta('1-5')
def __init__(self):
layout = [[
sg.Button('Lista'),
sg.Button('Fila'),
sg.Button('Pilha'),
sg.Button('Árvore'),
sg.Button('Grafo')
], [sg.Button('Fechar')]]
win = sg.Window('Projeto de ED', layout)
event, value = win.read()
random.shuffle(aux)
global estrutura
global estrutura2
global estrutura3
if (event == sg.WIN_CLOSED or event == 'Fechar'):
win.close()
elif (event == "Lista"):
estrutura = ListaDinamica.CoviList()
x = 0
while (x < 100):
dado = Struct.CovidLine(*data.loc[aux[x]])
estrutura.inserir(dado)
x += 1
win.close()
janela_lista()
elif (event == "Fila"):
estrutura = Fila.CoviList()
x = 0
while (x < 100):
dado = Struct.CovidLine(*data.loc[aux[x]])
estrutura.inserir(dado)
x += 1
win.close()
janela1()
elif (event == "Pilha"):
estrutura = Pilha.CoviList()
x = 0
while (x < 100):
dado = Struct.CovidLine(*data.loc[aux[x]])
estrutura.inserir(dado)
x += 1
win.close()
janela1()
elif (event == "Árvore"):
texto = '''Escolha a lista dos dados que irão ser escolhidos para cada árvore:
0-Somente a chave
1-Data da observação
2-Província (China)
3-País
4-Última atualização
5-Casos Confirmados
6-Número de mortos
7-Número de recuperados
'''
for i in range(3):
aux2 = sg.popup_get_text(
message=texto,
title="Digite uma chave da árvore {0}:".format(i + 1))
while (aux2 == None or aux2.isnumeric() == False
or not (int(aux2) in range(8))):
aux2 = sg.popup_get_text(
message=texto,
title="Digite uma chave da árvore {0}:".format(i + 1))
if (i == 0):
estrutura = Arvore.CoviList(int(aux2))
x = 0
while (x < 100):
dado = Struct.CovidLine(*data.loc[aux[x]])
estrutura.inserir(dado)
x += 1
if (i == 1):
estrutura2 = Arvore.CoviList(int(aux2))
x = 0
while (x < 100):
dado = Struct.CovidLine(*data.loc[aux[x]])
estrutura2.inserir(dado)
x += 1
if (i == 2):
estrutura3 = Arvore.CoviList(int(aux2))
x = 0
while (x < 100):
dado = Struct.CovidLine(*data.loc[aux[x]])
estrutura3.inserir(dado)
x += 1
win.close()
janela_arvore()
elif (event == 'Grafo'):
estrutura = Grafo.Grafo()
for node in Struct.starwars["nodes"]:
estrutura.add_vertice(node)
for link in Struct.starwars["links"]:
estrutura.add_aresta(link["source"], link["target"],
10.0 / link["value"])
estrutura.add_aresta(link["target"], link["source"],
10.0 / link["value"])
win.close()
janela_grafo()
# Bruno Marchi Pires
from Grafo import *
# True para grafos direcionados
# False para grafos não direcionados
grf = Grafo(False)
while True:
print("Escolha a sua opção")
print(" \t (1)Questão 1\n\t (2)Questão 2\n\t (3)Questão 3\n\t (9)Sair")
escolha = input("Digite sua opção: ").lower()
if escolha == '1':
"""Executa exercício 1"""
print("-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-")
print("----------EXERCÍCIO 1----------")
print(
"A entrada deve ser um grafo: Conexo e cíclico ou Conexo e acíclico ou Desconexo"
)
while True:
print(
" \t (1)Mostra\n\t (2)Inserir vertice\n\t (3)Inserir Aresta\n\t (4)Verificar se é uma árvore \n\t (9)Finalizar"
)
print("Escolha: ")
choose = input("Digite sua opção").lower()
if choose == '1':
grf.imprimeMatriz()
elif choose == '2':
valor = input("Digite o rotulo do vertice a inserir: ")
grf.adicionaVertice(valor)
elif choose == '3':
origem = input("Digite o rotulo do vertice de origem: ")
