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 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 " +
"- - - - - - - - - - - - - - - - - - - - - - - - - -")
class Sistema(object):
"""Representa al sistema que se ocupa de resolver los problemas de Navidad."""
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 agregar_esquina(self, id_esquina, x, y, latitud, longitud):
"""Funcion que se encarga de agregar una esquina al mapa."""
nueva_esquina = Esquina(id_esquina, x, y, latitud, longitud)
self.dicc_esquinas[id_esquina] = nueva_esquina
self.grafo.agregar_vertice(nueva_esquina)
def agregar_arista(self, id_esquina_inicial, id_esquina_final):
esquina_inicial = self.dicc_esquinas[id_esquina_inicial]
esquina_final = self.dicc_esquinas[id_esquina_final]
peso = calcular_peso(esquina_inicial, esquina_final)
self.grafo.agregar_arista(peso, esquina_inicial, esquina_final)
def agregar_fabrica(self, id_fabrica, id_esquina, horario_entrada,
horario_salida):
nueva_fabrica = Fabrica(id_fabrica, id_esquina, horario_entrada,
horario_salida)
self.dicc_fabricas[id_fabrica] = nueva_fabrica
def agregar_juguete(self, id_fabrica, id_juguete, valor, peso):
try:
nuevo_juguete = Juguete(id_fabrica, id_juguete, valor, peso)
fabrica = self.dicc_fabricas[id_fabrica]
fabrica.agregar_juguete(nuevo_juguete)
except KeyError:
print "Error: la fabrica con id %s no existe" % (id_fabrica)
def valuar_juguetes(self, id_fabrica):
fabrica = self.dicc_fabricas[id_fabrica]
lista_ju = fabrica.listar_juguetes()
#Armo las lista que seran los parametros del problema de la mochila.
lista_pesos = []
lista_valores = []
lista_ids = []
for jug in lista_ju:
lista_pesos.append(jug.obtener_peso())
lista_valores.append(jug.obtener_valor())
lista_ids.append(jug.obtener_id())
return problema_mochila(len(lista_ju), self.capacidad, lista_pesos,
lista_valores, lista_ids)
def listar_fabricas(self):
lista = problema_charlas(self.dicc_fabricas)
return str("Cantidad: " + str(len(lista)) + '\n' +
'\n'.join(['%s' % str(v) for v in lista])), lista
def listar_camino_minimo(self, id_fabrica):
fabrica = self.dicc_fabricas[id_fabrica]
esquina_final = self.dicc_esquinas[fabrica.obtener_esquina()]
esquina_inicial = self.dicc_esquinas[self.polo_norte]
return self.grafo.camino_minimo(esquina_inicial, esquina_final)
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 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 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 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_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 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 gravar(grafo: Grafo, nome):
g_file = open(f'{nome}.txt', 'w')
# writing file
# writing vertices
g_file.write(f"* Vertices {grafo.getSize()}\n")
for i in range(len(grafo.getNodes())):
g_file.write(f'{i} "{grafo.getNodes()[i]}"\n')
# writing edges
g_file.write(f'* Arcs\n')
for i in grafo.arestas():
g_file.write(f'{i}\n')
g_file.close()
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 __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 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 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 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 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 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, 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 __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 decimal_final_state(self, linea, columna, text, word):
self.counter += 1
self.column += 1
Deci = Grafo.grafica()
if self.counter < len(text):
if (self.flag_decimal == False):
Deci.grafoDecimal()
self.flag_decimal = True
return [linea, columna, 'decimal', word]
def simple_string_final_state(self, linea, columna, text, word):
self.counter += 1
self.column += 1
Char = Grafo.grafica()
if self.counter < len(text):
if (self.flag_char == False):
Char.grafoChar()
self.flag_char = True
return [linea, columna, 'string', word]
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 main():
mapa = Grafo()
mapa.agregar_nodo(Nodo((0,1), "nodo1"))
mapa.agregar_nodo(Nodo((0,0), "nodo2"))
mapa.agregar_arco(Nodo((0,1), "nodo1"))
print mapa.to_string()
return 0
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 F_state(self, linea, columna, text, word):
self.counter += 1
self.column += 1
Multi = Grafo.grafica()
if self.counter < len(text):
if (self.flag_multicomment == False):
Multi.grafoMultiComment()
self.flag_multicomment = True
return [linea, columna, 'comentario', word]
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 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 double_string_final_state(self, linea, columna, text, word):
self.counter += 1
self.column += 1
doublestring = Grafo.grafica()
if self.counter < len(text):
if (self.flag_string == False):
doublestring.grafoString()
self.flag_string = True
return [linea, columna, 'string', word]
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)
class EspacioEstados:
def __init__(self, file):
self.graph = Grafo(
file) # Creamos el grafo a partir del fichero graphlm
def sucesores(self, state):
actual = state.get_posicionActual # Obtenemos la posicion actual y la marcamos como el origen
sucesores = [] # Creamos una lista vacia de sucesores
listadenodos = self.graph.adyacentesnodo(actual)
#Ver cuando listadenodos es NoneType
if listadenodos is None:
return sucesores
for sucesor in listadenodos: # Para cada nodo:
destino = sucesor[1] # marcamos el sucesor como destino
#accM = 'Ir por ' + self.graph.get_nombrecalle(actual, destino)
accM = '(' + self.graph.get_nombrecalle(actual, destino) + ')'
costAcci = float(sucesor[3])
#costAcci = self.graph.get_coste(actual, destino) # buscamos el coste en el grafo entre esos dos nodos
try:
listadenodos.remove(actual)
except ValueError:
pass
estadoNuevoM = Estado(
destino, list.copy(state.listaNodos)
) # Creamos el nuevo estado desde el nodo destino
actual = destino # Cambiamos la posicion actual
sucesores.append([
accM, estadoNuevoM, costAcci
]) # Añadimos el sucesor a la lista en el formato pedido
return sucesores
def esta(self, state): # Nos dice si state está en el espacio de estados
for nodososm in self.graph.listanodos():
if state.get_posicionActual() == nodososm[0]:
return True
return False
class Main(object):
#construtor da classe, recebe como parametro os arquivos de entrada e saida
def __init__(self, interface = None, arquivo_entrada = None, arquivo_saida = None):
self.arquivo_entrada = arquivo_entrada
self.arquivo_saida = arquivo_saida
self.arquivo = Arquivo( self.arquivo_entrada, self.arquivo_saida ) #estancia da classe Arquivo
self.grafo = None
self.interface = interface
#funcao que que valida os arquivos de entrada e saida
def validar_arquivo(self):
try:
# Abro os aqruivos para garantir que não estão corrompidos
e = open(self.arquivo_entrada, "r")
s = open(self.arquivo_saida, "w")
#verifica se existe conteudo no arquivo de entrada
if len(e.readline()) == 0:
raise IOError
#tratando os erros
except IOError:
# os.system("cls")
print("\nArquivos de entradas invalidos ou corrompidos")
sys.exit(0)
#chama o metodo que ler os dados do arquivo de entrada
def tratar_dados_de_entrada(self):
return self.arquivo.ler_entrada()
#chama o metodo que vai gravar as respostas no arquivo de saida
def grava_resposta_arquivo(self, algoritmo, resposta):
return self.arquivo.grava_saida(algoritmo, resposta)
# #monta a lista de adjacencia
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
#Executa algoritmo que calcula a distancia de um determinado caminho
def calcula_distancia(self, caminho, requisicao = False):
lista_caminho = list(caminho) #copia a lista de caminho para lista_caminho
result = self.grafo.calcula_distancia(caminho)
if result == None:
if requisicao == True:
return result
else:
self.interface.lista_respostas.append('Calcula distancia - [ ERROR ]')
else:
dados = {"caminho": lista_caminho, "distancia": result}
if requisicao == True:
return dados
else:
resposta = self.grava_resposta_arquivo("distancia", dados)
if resposta != False:
self.interface.lista_respostas.append('Calcula distancia - [ OK ]')
def busca_largura(self, lista, requisicao = False):
vertices = list(lista)
result = self.grafo.busca_em_largura( lista[0], lista[1] )
if result == None:
if requisicao == True:
return result
else:
self.interface.lista_respostas.append('Busca em largura - [ ERROR ]')
else:
dados = {"vertices": vertices, "resposta": result}
if requisicao == True:
return dados
else:
resposta = self.grava_resposta_arquivo("largura", dados)
if resposta != False:
self.interface.lista_respostas.append('Busca em largura - [ OK ]')
def busca_profundidade(self, lista, requisicao = False):
vertices = list(lista)
result = self.grafo.busca_em_profundidade( lista[0], lista[1] )
if result == None:
if requisicao == True:
return result
else:
self.interface.lista_respostas.append('Busca em profundidade - [ ERROR ]')
else:
dados = {"vertices": vertices, "resposta": result}
if requisicao == True:
return dados
else:
resposta = self.grava_resposta_arquivo("profundidade", dados)
if resposta != False:
self.interface.lista_respostas.append('Busca em profundidade - [ OK ]')
def menor_caminho(self, origem, destino, requisicao = False):
result = self.grafo.dijkstra(origem, destino)
if result == None:
if requisicao == True:
return result
else:
self.interface.lista_respostas.append('Busca menor caminho (DIJKSTRA) - [ ERROR ]')
else:
dados = {"vertices": [origem, destino], "resposta": result}
if requisicao == True:
return dados
else:
resposta = self.grava_resposta_arquivo("menorcaminho", dados)
if resposta != False:
self.interface.lista_respostas.append('Busca menor caminho (DIJKSTRA) - [ OK ]')
def gerar_prim(self, origem, requisicao = False):
result = self.grafo.prim( origem )
if result == None:
if requisicao == True:
return result
else:
self.interface.lista_respostas.append('Prim - [ ERROR ]')
else:
dados = {"vertices": origem, "resposta": result}
if requisicao == True:
return dados
else:
print(dados)
resposta = self.grava_resposta_arquivo("prim", dados)
if resposta != False:
self.interface.lista_respostas.append('Prim - [ OK ]')
#executa a lista de comandos do arquivo de entrada
def executa_comandos(self, comandos):
for i in comandos:
self.chama_funcoes(i)
print("Executando...")
def chama_funcoes(self, comando, requisicao = False):
if (requisicao == True):
if comando['algoritmo'].lower() == "distancia":
return self.calcula_distancia(comando['lista'], True)
if comando['algoritmo'].lower() == "largura":
return self.busca_largura(comando['lista'], True)
if comando['algoritmo'].lower() == "profundidade":
return self.busca_profundidade(comando['lista'], True)
if comando['algoritmo'].lower() == "menorcaminho":
return self.menor_caminho(comando['lista'][0], comando['lista'][1], True)
if comando['algoritmo'].lower() == "prim":
return self.gerar_prim(comando['lista'][0], True)
else:
if comando['algoritmo'].lower() == "distancia":
return self.calcula_distancia(comando['lista'])
if comando['algoritmo'].lower() == "largura":
return self.busca_largura(comando['lista'])
if comando['algoritmo'].lower() == "profundidade":
return self.busca_profundidade(comando['lista'])
if comando['algoritmo'].lower() == "menorcaminho":
return self.menor_caminho(comando['lista'][0], comando['lista'][1])
if comando['algoritmo'].lower() == "prim":
return self.gerar_prim(comando['lista'][0])
from Grafo import *
espacio = Grafo();
espacio.agregar("Arad")
espacio.agregar("Timisora")
espacio.agregar("Zerind")
espacio.agregar("Oradea")
espacio.agregar("Sibiu")
espacio.agregar("Lugoj")
espacio.agregar("Mehadia")
espacio.agregar("Drobeta")
espacio.agregar("Craiova")
espacio.agregar("Rimnicu")
espacio.agregar("Fagaras")
espacio.agregar("Pitesti")
espacio.agregar("Bucarest")
espacio.agregar("Giurgiu")
espacio.agregar("Urziceni")
espacio.relacionarUnilateral("Arad","Zerind",75)
espacio.relacionarUnilateral("Arad","Sibiu",140)
espacio.relacionarUnilateral("Arad","Timisora",118)
espacio.relacionarUnilateral("Zerind","Oradea",71)
espacio.relacionarUnilateral("Sibiu","Fagaras",99)
espacio.relacionarUnilateral("Sibiu","Rimnicu",80)
espacio.relacionarUnilateral("Timisora","Lugoj",111)
class Main:
#construtor da classe, recebe como parametro os arquivos de entrada e saida
def __init__(self, arquivo_entrada, arquivo_saida):
self.arquivo_entrada = arquivo_entrada
self.arquivo_saida = arquivo_saida
self.arquivo = Arquivo( self.arquivo_entrada, self.arquivo_saida ) #estancia da classe Arquivo
self.grafo = None
#funcao que que valida os arquivos de entrada e saida
def validar_arquivo(self):
try:
# Abro os aqruivos para garantir que não estão corrompidos
e = open(self.arquivo_entrada, "r")
s = open(self.arquivo_saida, "w")
#verifica se existe conteudo no arquivo de entrada
if len(e.readline()) == 0:
raise Erros #lancando erro
#tratando os erros
except IOError:
os.system("cls")
print("\nArquivos de entradas invalidos ou corrompidos")
sys.exit(0)
except Erros as E:
os.system("cls")
print(E.arquivo_vazio())
sys.exit(0)
#chama o metodo que ler os dados do arquivo de entrada
def tratar_dados_de_entrada(self):
return self.arquivo.ler_entrada()
#chama o metodo que vai gravar as respostas no arquivo de saida
def grava_resposta_arquivo(self, algoritmo, resposta):
return self.arquivo.grava_saida(algoritmo, resposta)
#monta a lista de adjacencia
def monta_grafo(self, dados):
self.grafo = Grafo(dados) #instancia da classe Grafo
self.grafo.cria_lista_adjacencia() #metodo que cria a lista de adjacencia
#Executa algoritmo que calcula a distancia de um determinado caminho
def calcula_distancia(self, caminho):
lista_caminho = list(caminho) #copia a lista de caminho para lista_caminho
result = self.grafo.calcula_distancia(caminho)
if result == None:
print("Caminho Invalido")
else:
dados = {"caminho": lista_caminho, "distancia": result}
resposta = self.grava_resposta_arquivo("distancia", dados)
if resposta != False:
#time.sleep( 1 )
print("Calcula distancia - [ OK ]")
#executa o algoritmo que encontra uma rota entre 2 vertices
def encontra_caminho(self, v_origem, v_destino):
result = self.grafo.encontra_caminho( v_origem, v_destino )
if result == None:
print("Caminho Invalido")
else:
self.grava_resposta_arquivo("caminho", result)
def busca_largura(self, lista):
vertices = list(lista)
result = self.grafo.busca_em_largura( lista[0], lista[1] )
if result == None:
print("Caminho Invalido")
else:
dados = {"vertices": vertices, "resposta": result}
resposta = self.grava_resposta_arquivo("largura", dados)
if resposta != False:
#time.sleep( 1 )
print("Busca em largura - [ OK ]")
def busca_profundidade(self, lista):
vertices = list(lista)
result = self.grafo.busca_em_profundidade( lista[0], lista[1] )
if result == None:
print("Caminho Invalido")
else:
dados = {"vertices": vertices, "resposta": result}
resposta = self.grava_resposta_arquivo("profundidade", dados)
if resposta != False:
#time.sleep( 1 )
print("Busca em profundidade - [ OK ]")
def dijkstra(self, origem, destino):
self.grafo.dijkstra(origem, destino)
#executa a lista de comandos do arquivo de entrada
def executa_comandos(self, comandos):
os.system("cls")
print ("\nExecutando algoritmos: \n")
for i in comandos:
self.chama_funcoes(i)
print("\nArquivo de saida criado com sucesso")
def chama_funcoes(self, comando):
if comando['algoritmo'].lower() == "distancia":
self.calcula_distancia(comando['lista'])
if comando['algoritmo'].lower() == "largura":
self.busca_largura(comando['lista'])
if comando['algoritmo'].lower() == "profundidade":
self.busca_profundidade(comando['lista'])
def monta_grafo(self, dados): self.grafo = Grafo(dados) #instancia da classe Grafo self.grafo.cria_lista_adjacencia() #metodo que cria a lista de adjacencia
from Grafo import * from Formiga import * from Caminho import * from Pool import * from PoolSet import * from Cmd import * from random import choice # Lendo parâmetros da linha de comando cmd = Cmd() # Número global de loops numLoops = cmd.var['N'] # Criando o grafo g = Grafo(cmd.var) g.carregaGrafo() # # Estrura que armaneza as formigas # formigas = [] # # TODO acochambra # cidadesDisponiveis = [] # for i in range(0,g.getQtdNos()): # cidadesDisponiveis.append(i) # # Gerador de numeros aleatorios sem repeticao # num = NumerosAleatorios(g.getQtdNos()) # # Distribuição das formigas - cada um vai para uma cidade diferente # for i in range(0,g.getQtdNos()):
