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: ")