def itinerario_cultural(archivo_itinerario, grafo_aeropuertos, aeropuertos):
'''Recibe un archivo existente con formato csv,
donde la primera linea incluye las ciudades que se desea visitar,
y las subsiguientes lineas indican qué ciudades deben ser visitadas antes de qué otras.
Imprime por salida estandar el orden en que deben ser visitadas y el recorrido que se debe realizar,
para que la cantidad de escalas sea mínima.
'''
with open(archivo_itinerario) as itinerario:
itinerario = csv.reader(itinerario)
ciudades = next(itinerario)
grafo_ciudades = Grafo(True, ciudades)
for ciudad_a, ciudad_b in itinerario:
grafo_ciudades.agregar_arista(ciudad_a, ciudad_b)
orden = orden_topologico_dfs(grafo_ciudades)
imprimir_camino(orden, ', ')
camino_total = []
for i in range(len(orden) - 1):
origen, destino = orden[i], orden[i + 1]
camino_min = camino_minimo(grafo_aeropuertos, aeropuertos, origen,
destino, True)
camino_total.extend(camino_min)
if i != len(orden) - 2:
camino_total.pop()
imprimir_camino(camino_min, SEP_CAMINO)
return camino_total
def grafo_crear(nombre_archivo):
"""
Crea un grafo de conexiones de actores a partir de un archivo de datos.
PRE: Recibe el nombre de un archivo separado por comas que contenga de lineas:
actor,pelicula,pelicula,pelicula
que equivalen a: vertice,arista,arista,arista
POST: Devuelve un grafo creado a partir de estos datos.
"""
grafo = Grafo()
with open(nombre_archivo
) as archivo: #Mas adelante habra que ver como manejar esto
#por lo del tema de que no entra en memoria...
peliculas = {}
for linea in archivo:
informacion = (linea.rstrip('\n')).split(',')
grafo.agregar_vertice(informacion[0])
for pelicula in informacion[1:]:
lista = peliculas.get(pelicula, [])
if not lista:
peliculas[pelicula] = lista
lista.append(informacion[0])
for pelicula, actores in peliculas.items():
for i in range(len(actores)):
for j in range(i + 1, len(actores)):
grafo.agregar_arista(actores[i], actores[j], pelicula)
#Es horrible el orden de esto pero no se me ocurrio nada mejor...
#Habra que ver otra forma de cambiarlo...
return grafo
def cargar_en_grafo(archivoMapa, lineaEspia1, lineaEspia2, lineaAeropuerto,
distancia):
'''Carga el mapa en un grafo, y devuelve los puntos donde se encuentran el espia 1, 2 y el aeropuerto.
Si se produjo un error con el archivoMapa se informa '''
pos_espia_1 = -1
pos_espia_2 = -1
pos_aeropuerto = -1
grafo = Grafo()
try:
archivo = open(archivoMapa)
nroLinea = 0
for linea in archivo: #'p1.x p1.y - p2.x p2.y'
puntos = linea.split(' - ') #['p1.x p1.y','p2.x p2.y']
coordenadas = [puntos[0].split(), puntos[1].split()
] #[['p1.x','p1.y'],['p2.x','p2.y']
punto1 = (int(coordenadas[0][0]), int(coordenadas[0][1]))
punto2 = (int(coordenadas[1][0]), int(coordenadas[1][1]))
peso = distancia(punto1, punto2)
grafo.agregar_arista(punto1, punto2, peso)
if (nroLinea == lineaEspia1):
pos_espia_1 = punto1
if (nroLinea == lineaEspia2):
pos_espia_2 = punto1
if (nroLinea == lineaAeropuerto):
pos_aeropuerto = punto1
nroLinea += 1
except IOError, e:
print MSJ_ERROR, e
print MSJ_IOERROR, archivoMapa
raise IOError
def arbol_tendido_minimo(grafo):
'''
Obtiene un arbol de tendido minimo de un arbol.
grafo: el grafo fue creado.
Devuelve un nuevo grafo que representa un arbol de tendido
minimo del original.
'''
inicio = grafo.obtener_vertice_aleatorio()
visitados = {}
visitados[inicio] = True
heap = []
arbol = Grafo(True)
for v in grafo.obtener_adyacentes(inicio):
peso_arista = grafo.obtener_peso_union(inicio, v)
heappush(heap, (peso_arista, (inicio, v)))
for v in grafo:
arbol.agregar_vertice(v)
while heap:
dato = heappop(heap)
peso_arista = dato[PESO]
actual = dato[VERTICE][ACTUAL]
proximo = dato[VERTICE][PROXIMO]
if proximo in visitados:
continue
arbol.agregar_arista(actual, proximo, peso_arista)
visitados[proximo] = True
for u in grafo.obtener_adyacentes(proximo):
heappush(heap,
(grafo.obtener_peso_union(proximo, u), (proximo, u)))
return arbol
def arbol_tendido_minimo(grafo):
"""Devuelve un nuevo grafo que representa un arbol de tendido minimo.
- Pre-condicion: recibe un grafo conexo."""
inicio = grafo.obtener_vertice_aleatorio()
visitados = set()
visitados.add(inicio)
heap = Heap()
for adyacente in grafo.obtener_vertices_adyacentes(inicio):
heap.encolar((inicio, adyacente),
grafo.obtener_peso_arista(inicio, adyacente))
arbol = Grafo()
for vertice in grafo.obtener_vertices():
arbol.agregar_vertice(vertice)
while not heap.esta_vacio():
[(vertice, adyacente), peso_arista] = heap.desencolar()
if adyacente in visitados:
continue
arbol.agregar_arista(vertice, adyacente, peso_arista)
visitados.add(adyacente)
for vecino in grafo.obtener_vertices_adyacentes(adyacente):
heap.encolar((adyacente, vecino),
grafo.obtener_peso_arista(adyacente, vecino))
return arbol
def main():
if len(sys.argv) != 3:
print("Cantidad de parámetros errónea")
return
flycombi = Grafo(no_dirigido)
with open(sys.argv[1], 'r') as aeropuertos:
reader = csv.reader(aeropuertos, delimiter=',')
for linea in reader:
if linea[0] in ciudades:
ciudades[linea[0]].append(linea[1])
else:
ciudades[linea[0]] = [linea[1]]
flycombi.agregar_vertice(linea[1])
flycombi.agregar_dato(linea[1], 'ciudad', linea[0])
with open(sys.argv[2], 'r') as vuelos:
reader = csv.reader(vuelos, delimiter=',')
for linea in reader:
peso = biblioteca_grafo.Peso(linea[2], linea[3], linea[4])
flycombi.agregar_arista(linea[0], linea[1], peso)
for operacion in sys.stdin:
if operacion[-1] == '\n':
operacion = operacion[:-1]
comando = operacion.split(" ", 1)
if not identificar_operacion(comando, flycombi):
print("Error en comando", comando[0])
return
def grafo_crear(nombre_archivo):
"""
Crea un grafo de conexiones de actores a partir de un archivo de datos.
PRE: Recibe el nombre de un archivo separado por comas que contenga de lineas:
actor,pelicula,pelicula,pelicula
que equivalen a: vertice,arista,arista,arista
POST: Devuelve un grafo creado a partir de estos datos.
"""
grafo = Grafo()
aristas = grafo.get_aristas()
with open(nombre_archivo, "r", encoding='utf-8', newline='\n') as csvfile:
actores_csv = csv.reader(csvfile)
for linea in actores_csv:
actor = linea[0]
grafo.agregar_vertice(actor)
for pelicula in linea[1:]:
actores = aristas.get(pelicula)
if actores:
for aux in actores:
grafo.agregar_arista(actor, aux, pelicula)
else:
aristas[pelicula] = [actor]
return grafo
def itinerario(grafo_sedes, archivo_recomendaciones, mapa_kml):
"""Recibe un itinerario que nos indica cuales son las sedes que debemos
visitar antes que otras, y con ellas hace un nuevo grafo con el que
llama a orden topologico, para luego imprimir su reccorrido segun el
itinerario pasado."""
try:
with open(archivo_recomendaciones, "r") as recomendaciones:
lector = csv.reader(recomendaciones)
grafo_recomendaciones = Grafo()
for sede_1,sede_2 in lector:
if not grafo_recomendaciones.vertice_pertenece(sede_1):
grafo_recomendaciones.agregar_vertice(sede_1)
if not grafo_recomendaciones.vertice_pertenece(sede_2):
grafo_recomendaciones.agregar_vertice(sede_2)
if grafo_sedes.vertices_conectados(sede_1, sede_2):
grafo_recomendaciones.agregar_arista(sede_1, sede_2, grafo_sedes.obtener_peso_arista(sede_1, sede_2))
except OSError:
print("No se pudo abrir el archivo {}".format(archivo_recomendaciones))
return
recorrido = orden_topologico(grafo_recomendaciones)
if (recorrido): imprimir_recorrido(grafo_sedes, recorrido, 0)
crear_kml(grafo_sedes, "itinerario {}".format(archivo_recomendaciones), recorrido, mapa_kml)
def parse(file):
''' Parsea un archivo .pjk (que posee labels y pesos) a una estructura Grafo.
Primero se agregan los vértices, siendo:
- line[0] el número de vértices,
- line[1] el label.
Luego se agregan las aristas, siendo:
- line[0] el vértice origen,
- line[1] el vértice destino,
- line[2] el peso.
Devuelve el grafo.
'''
grafo = Grafo()
vert_dict = {
} # Diccionario de vértices con su número de vértice usado para
with open(
file,
"r") as f: # luego agregar las aristas según el número de vértice.
vertices = int(f.readline().split(' ')[1]) # Cantidad de vertices
for line in f: # Agrega los vertices
line = line.split('"')
grafo[line[1]] = {}
vert_dict[int(line[0])] = line[1]
if int(
line[0]
) == vertices: # Corta cuando llega al número de vertices predefinido
break
f.readline()
for line in f: # Agrega las aristas
line = line.split(' ')
line = [int(i) for i in line]
grafo.agregar_arista(vert_dict[line[0]], vert_dict[line[1]],
line[2])
return grafo
def database(ruta_aeropuertos, ruta_vuelos):
"""
Recibe rutas de aeropuertos y vuelos para procesar la información y guardarla en memoria.
Devuelve el grafo ya armado.
"""
with open(ruta_aeropuertos) as aeropuertos, open(ruta_vuelos) as vuelos:
lector_aeropuertos = csv.reader(aeropuertos)
lector_vuelos = csv.reader(vuelos)
grafo_general = Grafo()
datos_aeropuertos = {
} #Ciudad y posición geográfica de cada aeropuerto.
aeropuertos_de_ciudades = {
} #Cuando me pasan por comando la ciudad busco los aeropuertos que tiene acá.
for ciudad, codigo, latitud, longitud in lector_aeropuertos:
grafo_general.agregar_vertice(codigo)
datos_aeropuertos[codigo] = datos_aeropuertos.get(
codigo, [ciudad, latitud, longitud])
aeropuertos_de_ciudades[ciudad] = aeropuertos_de_ciudades.get(
ciudad, [])
aeropuertos_de_ciudades[ciudad].append(codigo)
for origen, destino, tiempo, precio, cant_vuelos in lector_vuelos:
#Arista con formato (precio,tiempo,cant_vuelos)
grafo_general.agregar_arista(origen, destino,
(precio, tiempo, cant_vuelos))
grafo_general.agregar_arista(destino, origen,
(precio, tiempo, cant_vuelos))
return grafo_general, datos_aeropuertos, aeropuertos_de_ciudades
def grafo_crear(nombre_archivo):
"""
Crea un grafo de conexiones de actores a partir de un archivo de datos.
PRE: Recibe el nombre de un archivo separado por comas que contenga de lineas:
actor,pelicula,pelicula,pelicula
que equivalen a: vertice,arista,arista,arista
POST: Devuelve un grafo creado a partir de estos datos.
"""
grafo_peliculas = Grafo()
with open(nombre_archivo) as archivo:
archivo_reader = csv.reader(archivo, delimiter=",")
for linea in archivo_reader:
nombre_actor = linea[NOMBRE_ACTOR]
for i in range(1, len(linea)):
if not grafo_peliculas.esta_arista(linea[i]):
grafo_peliculas.agregar_arista(linea[i])
grafo_peliculas.agregar_vertice(nombre_actor, linea[i])
return grafo_peliculas
def prim_flycombi(grafo,peso,vertice = None):
if vertice == None:
vertice = grafo.vertice_random()
costo = 0
visitados = set()
visitados.add(vertice)
heap = []
for w in grafo.adyacentes(vertice):
arista = grafo.peso(vertice,w)
if peso == "tiempo":
heapq.heappush(heap,(int(arista.tiempo),vertice,w,arista))
elif peso == "precio":
heapq.heappush(heap,(int(arista.precio),vertice,w,arista))
arbol = Grafo()
while len(heap) > 0:
p,v,w,a = heapq.heappop(heap)
if w in visitados: continue
arbol.agregar_arista(v,w,a)
costo += int(p)
visitados.add(w)
for x in grafo.adyacentes(w):
if x not in visitados:
arista = grafo.peso(w,x)
if peso == "tiempo":
heapq.heappush(heap,(int(arista.tiempo),w,x,arista))
elif peso == "precio":
heapq.heappush(heap,(int(arista.precio),w,x,arista))
return arbol,costo
def cargar_archivo(ruta):
g = Grafo()
with open(ruta) as archivo:
arch = csv.reader(archivo, delimiter='\t')
for linea in arch:
v1, v2 = linea[0], linea[1]
g.agregar_arista(v1, v2)
return g
def crear_grafo_paginas(grafo, paginas):
grafo_paginas = Grafo(True)
for v in paginas:
grafo_paginas.agregar_vertice(v)
for v in grafo_paginas.obtener_vertices():
for w in grafo.obtener_adyacentes(v):
if w in paginas:
grafo_paginas.agregar_arista(w, v)
return grafo_paginas
def main():
if len(sys.argv) != 3:
print("Cantidad de parámetros errónea")
return
flycombi = Grafo(no_dirigido)
'''vertices = []
aristas = []'''
with open(sys.argv[1], 'r') as aeropuertos:
reader = csv.reader(aeropuertos, delimiter=',')
for linea in reader:
#clave = linea[1]+","+linea[0]
if linea[0] in ciudades: #ciudades.__contains__(linea[0]):
ciudades[linea[0]].append(linea[1])
else:
ciudades[linea[0]] = [linea[1]]
#vertices.append(linea[1])#guardo solo los aeropuertos
#vertices.append(linea[1])
flycombi.agregar_vertice(linea[1])
flycombi.agregar_dato(linea[1], 'ciudad', linea[0])
with open(sys.argv[2], 'r') as vuelos:
reader = csv.reader(vuelos, delimiter=',')
for linea in reader:
peso = biblioteca_grafo.Peso(linea[2], linea[3], linea[4])
#aristas.append((linea[0],linea[1],peso))
flycombi.agregar_arista(linea[0], linea[1], peso)
'''for linea in vuelos:
vue = linea.split(',')
peso = biblioteca_grafo.Peso(vue[2],vue[3],vue[4])
aristas.append((vue[0],vue[1],peso))'''
#flycombi = Grafo(no_dirigido,vertices,aristas)
'''for i in ciudades:
for j in ciudades[i]:
flycombi.agregar_dato(j,'ciudad',i)'''
'''for comando in fileinput.input():
comandos = linea'''
operacion = input()
#comando = readline
while operacion and operacion != "exit": #mientras siga habiendo lineas para procesar
comando = operacion.split(" ", 1)
if not identificar_operacion(comando, flycombi):
print("Error en comando", comando[0])
operacion = input()
''' datos = input()
archivos = datos.split(" ")
print(datos)'''
'''for s in archivos:
print (s,len(s))
for linea in fileinput.input():
comandos = linea'''
return
def itinerario(aeropuertos, vuelos, nombre_ruta):
grafo = Grafo(True)
with open (nombre_ruta, "r") as archivo:
archivo_csv = csv.reader(archivo)
ciudades = next(archivo_csv)
for ciudad in ciudades: grafo.agregar_vertice(ciudad)
for linea in archivo_csv: grafo.agregar_arista(linea[0],linea[1],0)
orden = orden_topo(grafo)
print(", ".join(orden))
for i in range(len(orden) - 1):
camino_escalas(aeropuertos, vuelos, orden[i], orden[i+1])
def main():
"""Funcion principal. Se encarga de la lectura de parametros en la
inea de comando y del llamado de la funcion a ejecutar segun cual
sea ese comando."""
if len(sys.argv) != 3:
raise TypeError("Cantidad de parametros pasados erronea.")
try:
with open(sys.argv[1], "r") as sedes:
lector_sedes = csv.reader(sedes)
grafo_sedes = Grafo()
cantidad_sedes = int(next(lector_sedes, [0])[0])
for i in range(cantidad_sedes):
sede, latitud, longitud = next(lector_sedes)
grafo_sedes.agregar_vertice(sede, latitud, longitud)
cantidad_aristas = int(next(lector_sedes, [0])[0])
for i in range(cantidad_aristas):
sede_1, sede_2, tiempo = next(lector_sedes)
grafo_sedes.agregar_arista(sede_1, sede_2, tiempo)
except OSError:
print("No se pudo abrir el archivo {}".format(sys.argv[1]))
return
comandos = {
"ir": camino_minimo_entre_sedes,
"viaje": viaje,
"itinerario": itinerario,
"reducir_caminos": reducir_caminos
}
while True:
try:
linea = input()
except EOFError as error:
break
if ',' in linea:
comando, param = linea.split(",")
comando_ = comando.split()
comando = comando_[0]
opcion = " ".join(comando_[1:])
comandos[comando](grafo_sedes, opcion, param.lstrip().rstrip(),
sys.argv[2])
#print( comando, param, opcion)
else:
comando, param = linea.split()
comandos[comando](grafo_sedes, param.lstrip().rstrip(),
sys.argv[2])
def copiar_grafo(grafo):
grafo_copia = Grafo(True)
for v in grafo.obtener_todos_los_vertices():
grafo_copia.agregar_vertice(v, grafo.ver_dato_vertice(v))
for v in grafo.obtener_todos_los_vertices():
for w in grafo.obtener_adyacentes(v):
if w == v: continue #elimino bucles
grafo_copia.agregar_arista(v, w, grafo.ver_peso_arista(v, w))
#buscar y modificar los ciclos de largo 2.
modificar_ciclo_largo_2(grafo, grafo_copia)
return grafo_copia
def main():
if len(sys.argv) == 7:
archivo_ciudades = open(sys.argv[1], "r")
archivo_rutas = open(sys.argv[2], "r")
archivo_imperio1 = open(sys.argv[3], "r")
archivo_imperio2 = open(sys.argv[4], "r")
archivo_ataque1 = open(sys.argv[5], "r")
archivo_ataque2 = open(sys.argv[6], "r")
mapa = Grafo()
for linea in archivo_ciudades.readlines():
(ciudad, capacidad) = linea.split(',')
mapa.agregar_vertice(ciudad)
for linea in archivo_rutas.readlines():
(ciudad1, ciudad2, capacidad) = linea.split(',')
mapa.agregar_arista(ciudad1, ciudad2, int(capacidad))
imperio1 = {}
for linea in archivo_imperio1.readlines():
(ciudad, ejercitos) = linea.split(',')
imperio1[ciudad] = int(ejercitos)
imperio2 = {}
for linea in archivo_imperio2.readlines():
(ciudad, ejercitos) = linea.split(',')
imperio2[ciudad] = int(ejercitos)
ataque1 = {}
for linea in archivo_ataque1.readlines():
(ciudad_atacante, ciudad_objetivo, ejercitos) = linea.split(',')
ataque1[ciudad_atacante, ciudad_objetivo] = int(ejercitos)
ataque2 = {}
for linea in archivo_ataque2.readlines():
(ciudad_atacante, ciudad_objetivo, ejercitos) = linea.split(',')
ataque2[ciudad_atacante, ciudad_objetivo] = int(ejercitos)
contienda(mapa, imperio1, imperio2, ataque1, ataque2)
actualizar_imperio(sys.argv[3], imperio1)
actualizar_imperio(sys.argv[4], imperio2)
archivo_ciudades.close()
archivo_rutas.close()
archivo_imperio1.close()
archivo_imperio2.close()
archivo_ataque1.close()
archivo_ataque2.close()
else:
print('Se necesitan 6 parametros: Archivo de ciudades, Archivo de rutas, Archivo de imperio 1, Archivo de imperio 2, Archivo de ataque de imperio 1, Arhivo de ataque de imperio 2')
def procesar_archivos():
aeropuertos = {}
vuelos = Grafo(False)
with open(sys.argv[1]) as a:
a_csv = csv.reader(a)
for linea in a_csv:
aeropuertos[linea[0]] = aeropuertos.get(linea[0], []) + [linea[1]]
with open(sys.argv[2]) as v:
v_csv = csv.reader(v)
for origen, destino, tiempo, precio, cant_vuelos in v_csv:
vuelos.agregar_arista(origen, destino, (int(tiempo), int(precio), int(cant_vuelos)))
return aeropuertos, vuelos
def main():
if len(sys.argv) == 8:
jugador = sys.argv[1]
archivo_ciudades = open(sys.argv[2], "r")
archivo_rutas = open(sys.argv[3], "r")
archivo_imperio1 = open(sys.argv[4], "r")
archivo_cosecha1 = open(sys.argv[5], "r")
archivo_imperio2 = open(sys.argv[6], "r")
archivo_cosecha2 = open(sys.argv[7], "r")
mapa = Grafo()
ciudades = {}
for linea in archivo_ciudades.readlines():
(ciudad, capacidad) = linea.split(',')
mapa.agregar_vertice(ciudad)
ciudades[ciudad] = int(capacidad)
for linea in archivo_rutas.readlines():
(ciudad1, ciudad2, capacidad) = linea.split(',')
mapa.agregar_arista(ciudad1, ciudad2, int(capacidad))
imperio1 = {}
(metropoli1, ejercitos1) = archivo_imperio1.readline().split(',')
imperio1[metropoli1] = int(ejercitos1)
for linea in archivo_imperio1.readlines():
(ciudad, ejercitos) = linea.split(',')
imperio1[ciudad] = int(ejercitos)
imperio2 = {}
(metropoli2, ejercitos2) = archivo_imperio2.readline().split(',')
imperio2[metropoli2] = int(ejercitos2)
for linea in archivo_imperio2.readlines():
(ciudad, ejercitos) = linea.split(',')
imperio2[ciudad] = int(ejercitos)
open("ataque" + str(jugador) + ".txt", "w")
tactica(jugador, mapa, ciudades, imperio1, imperio2, metropoli1,
metropoli2)
archivo_ciudades.close()
archivo_rutas.close()
archivo_imperio1.close()
archivo_cosecha1.close()
archivo_imperio2.close()
archivo_cosecha2.close()
else:
print(
'Se necesitan 7 parametros: Numero de jugador, Archivo de ciudades, Archivo de rutas, Archivo de imperio 1, Archivo de cosecha de imperio 1, Archivo de imperio 2, Archivo de cosecha de imperio 2'
)
def construir_grafo_auxiliar(grafo, parametros):
"""Funcion auxiliar para calcular orden valido de lectura.
Recibe como parametro un grafo y una lista con vertices del grafo.
Retorna un grafo con los vertices y conexiones entre los vertices pasados por parametro
(invertidas según aparecen en el grafo original)."""
grafo_aux = Grafo(True)
for v in parametros:
grafo_aux.agregar_vertice(v)
for w in grafo.obtener_adyacentes(v):
if w in parametros:
grafo_aux.agregar_vertice(w)
grafo_aux.agregar_arista(w, v)
return grafo_aux
def grafo_init(ruta):
grafo = Grafo(True)
with open(ruta, 'r') as file:
for linea in file:
paginas = linea.rstrip("\n").split("\t")
grafo.agregar_vertice(paginas[0])
contador = 1
while contador < len(paginas):
grafo.agregar_vertice(paginas[contador])
grafo.agregar_arista(paginas[0], paginas[contador])
contador += 1
return grafo
def prueba_bfs():
grafo1 = Grafo(True)
vertices = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
for v in vertices:
grafo1.agregar_vertice(v)
grafo1.agregar_arista(vertices[0], vertices[1])
grafo1.agregar_arista(vertices[0], vertices[2])
grafo1.agregar_arista(vertices[1], vertices[2])
grafo1.agregar_arista(vertices[2], vertices[3])
grafo1.agregar_arista(vertices[3], vertices[4])
grafo1.agregar_arista(vertices[3], vertices[5])
grafo1.agregar_arista(vertices[4], vertices[1])
recorrido = bfs(grafo1, vertices[0])
padres = recorrido[0]
orden = recorrido[1]
print_test("Prueba BFS el padre del origen es None",
not padres[vertices[0]])
print_test("Prueba BFS el orden del origen es 0", orden[vertices[0]] == 0)
print_test("Prueba BFS el padre del vertice 'B' es el correcto",
padres[vertices[1]] == vertices[0])
print_test("Prueba BFS el orden del vertice 'B' es el correcto",
orden[vertices[1]] == 1)
print_test("Prueba BFS el padre del vertice sin aristas es el correcto",
not padres[vertices[6]])
print_test("Prueba BFS el orden del vertice sin aristas es el correcto",
orden[vertices[6]] == 0)
def procesar_itinerario(recomendaciones,coordenadas,kml): #recomendaciones es el nombre de un archivo .csv
grafo_recomendaciones=Grafo(True)
with open(recomendaciones,"r") as archivo_csv:
for linea in archivo_csv:
lista_campos=linea.rstrip("\n").split(",")
for cuidad in lista_campos:
grafo_recomendaciones.agregar_vertice(cuidad)#no importa si hay repetido , no los vuelve a copiar
with open(recomendaciones,"r") as archivo_csv:
for linea in archivo_csv:
lista_campos=linea.rstrip("\n").split(",")
grafo_recomendaciones.agregar_arista(lista_campos[0],lista_campos[1],0)
lista_orden_topologico=biblioteca.orden_topologico(grafo_recomendaciones)
_imprimir_camino(lista_orden_topologico)
escrbir_kml(kml,"recomendaciones.csv","",coordenadas,CUARTO_COMANDO,lista_orden_topologico)
def mst_kruskal(grafo):
"""Pre: el grafo es no dirigido.
Retorna un arbol de tendido minimo."""
conjuntos = UnionFind(grafo.obtener_todos_los_vertices())
#ordenar las aristas de forma ascendente por peso.
aristas = sorted(grafo.obtener_todas_las_aristas(), key=itemgetter(2))
arbol = Grafo(False)
for v in grafo.obtener_todos_los_vertices():
arbol.agregar_vertice(v, grafo.ver_dato_vertice(v))
for v, w, p in aristas:
if conjuntos.find(v) == conjuntos.find(w): continue
arbol.agregar_arista(v, w, p)
conjuntos.union(v, w)
return arbol
def main():
if len(sys.argv) == 8:
ronda = int(sys.argv[1])
archivo_ciudades = open(sys.argv[2], "r")
archivo_rutas = open(sys.argv[3], "r")
archivo_imperio1 = open(sys.argv[4], "r")
archivo_cosecha1 = open(sys.argv[5], "r")
archivo_imperio2 = open(sys.argv[6], "r")
archivo_cosecha2 = open(sys.argv[7], "r")
mapa = Grafo()
for linea in archivo_ciudades.readlines():
(ciudad, capacidad) = linea.split(',')
mapa.agregar_vertice(ciudad)
for linea in archivo_rutas.readlines():
(ciudad1, ciudad2, capacidad) = linea.split(',')
mapa.agregar_arista(ciudad1, ciudad2, int(capacidad))
imperio1 = {}
(metropoli1, ejercitos) = archivo_imperio1.readline().split(',')
for linea in archivo_imperio1.readlines():
(ciudad, ejercitos) = linea.split(',')
imperio1[ciudad] = int(ejercitos)
imperio2 = {}
(metropoli2, ejercitos) = archivo_imperio2.readline().split(',')
for linea in archivo_imperio2.readlines():
(ciudad, ejercitos) = linea.split(',')
imperio2[ciudad] = int(ejercitos)
cosecha1 = int(archivo_cosecha1.readline())
cosecha2 = int(archivo_cosecha2.readline())
procesar(ronda, mapa, imperio1, metropoli1, cosecha1, imperio2,
metropoli2, cosecha2)
archivo_ciudades.close()
archivo_rutas.close()
archivo_imperio1.close()
archivo_cosecha1.close()
archivo_imperio2.close()
archivo_cosecha2.close()
else:
print(
'Se necesitan 7 parametros: Numero de ronda, Archivo de ciudades, Archivo de rutas, Archivo de imperio 1, Archivo de cosecha 1, Archivo de imperio 2, Archivo de cosecha 2'
)
def lectura(grafo,paginas):
grafo_aux = Grafo(True)
for v in paginas: #O(n)
grafo_aux.agregar_vertice(v)
for v in grafo_aux:
for w in grafo.adyacentes(v):
if w in paginas:
#print(f"{w}: está en los adyacentes de {v} y tmb esta en paginas")
grafo_aux.agregar_arista(w,v)
orden = biblioteca.orden_topologico(grafo_aux)
if orden:
print(*orden, sep=', ')
else:
print("No existe forma de leer las paginas en orden")
def creador_grafo_itinerario(lector_itinerario):
"""
Crea un grafo a partir de las condiciones dadas por el archivo csv recibido.
Realiza un orden topológico y luego devuelve una lista con el orden el cual
se debe realizar el viaje.
"""
linea_cero = 0
grafo_itinerario = Grafo()
for linea in lector_itinerario:
if linea_cero == 0:
a_agregar = linea[::]
random.shuffle(a_agregar)
grafo_itinerario.crear(a_agregar)
linea_cero += 1
grafo_itinerario.agregar_arista(linea[0], linea[1], 0)
itinerario_ordenado = repo.orden_topologico_bfs(grafo_itinerario)
return itinerario_ordenado
def cargar_set_datos(nombre_archivo_ciudades):
"""El archivo debe contener sus encabezados correspondiente, los cuales son las cantidad de vertice y arista"""
grafo = Grafo(False)
coordenadas = {}
estoy_en = ""
with open(nombre_archivo_ciudades, "r") as archivo_csv:
for linea in archivo_csv:
lista_campos=linea.rstrip("\n").split(",")
if len(lista_campos) == 1:
estoy_en =_invertir_centinela(estoy_en)
continue
if estoy_en == CUIDAD and len(lista_campos) == 3:
grafo.agregar_vertice(lista_campos[0])
coordenadas[lista_campos[0]]=(lista_campos[1],lista_campos[2])
if estoy_en == RUTA and len(lista_campos) == 3:
costo=int(lista_campos[2])
grafo.agregar_arista(lista_campos[0],lista_campos[1],costo)
return grafo,coordenadas
def _extraer_datos(handler):
"""Recibe: archivo, Devuelve: 2 grafos
Extrae los datos del archivo y los devuelve"""
#variables
fila = []
nodos_cant = 0
calles_cant = 0
i = 0 #indice generico
info_nodo = {} #donde guardo la informacion de los nodos
grafo_nodos = Grafo()
grafo_calles = Grafo()
#Cargo el manejador de csv
contenido_csv = csv.reader(handler, delimiter=",")
#obtengo la primer linea, que me dice cuantos -NODOS- son
fila = contenido_csv.next()
nodos_cant = int(fila[0])
#avanzo para obtener la primer fila de -NODOS-
fila = contenido_csv.next()
#obtengo los datos de los -NODOS-
for i in range(nodos_cant-1):
#guardo la info del nodo
info_nodo[ int(fila[0]) ] = {'x': float(fila[1]), 'y': float(fila[2]), 'lon': float(fila[4]),'lat': float(fila[3])}
#avanzo una posicion si no estoy en el ultimo -NODO-
if i != nodos_cant:
fila = contenido_csv.next()
#obtengo la cantidad de -CALLES-
fila = contenido_csv.next()
calles_cant = int(fila[0])
#avanzo para obtener la primer fila de -CALLES-
fila = contenido_csv.next()
#obtengo los datos de las -CALLES-
for i in range(calles_cant-1):
if int(int(fila[4])) not in grafo_nodos:
grafo_nodos.agregar_vertice(int(fila[4]))
if texto(fila[1]) not in grafo_calles:
grafo_calles.agregar_vertice(texto(fila[1]))
#Agrego las aristas
grafo_nodos.agregar_arista(int(fila[4]),int(fila[5]),int(fila[2]))
grafo_calles.agregar_arista(texto(fila[1]),int(fila[4]),int(fila[5]))
#Cuando son mano unica
if int(fila[3]) == 0:
if int(fila[5]) not in grafo_nodos:
grafo_nodos.agregar_vertice(int(fila[5]))
grafo_nodos.agregar_arista(int(fila[5]),int(fila[4]),int(fila[2]))
#devuelvo los grafos e info_nodo
if i != calles_cant:
fila = contenido_csv.next()
return grafo_nodos, grafo_calles ,info_nodo
class Sistema(object):
"""Sistema de consultas para una red de musicos."""
def __init__(self, archivo):
"""Inicializa el Sistema. Recibe el archivo del grafo.
El archivo debe tener el sig. formato:
"<Cantidad_de_vertices>"
"<id_vertice> <nombre_vertice>"
"............................."
"<Cantidad_de_aristas>"
"<id_arista> <id_vertice_inicial> <id_vertice_final>"
"..................................................."
"""
self.comando = None
self.parametros = []
self.funciones_asociadas = {
"recomendar": self.comando_recomendar,
"difundir": self.comando_difundir,
"centralidad": self.comando_centralidad,
"debilidad": self.comando_debilidad,
"camino": self.comando_camino,
"diametro": self.comando_diametro,
"agrupamiento": self.comando_agrupamiento,
"distancias": self.comando_distancias,
"subgrupos": self.comando_subgrupos,
"articulacion": self.comando_articulacion
}
self.grafo = None
self.musico_a_id_vertice = {}
self._crear_grafo_desde_archivo(archivo)
def _crear_grafo_desde_archivo(self, archivo):
"""Crea el grafo y le carga la configuracion del archivo."""
self.grafo = Grafo()
try:
with open(archivo,"r") as f:
#agregado de vertices
for i in xrange(int(f.readline())):
args = f.readline().split()
self.musico_a_id_vertice[args[1]] = args[0]
self.grafo.agregar_vertice(args[0], dato_vertice=args[1])
#agregado de aristas
for i in xrange(int(f.readline())):
args = f.readline().split()
self.grafo.agregar_arista(args[1], args[2])
except IOError:
raise ArchivoInvalidoError("Error de archivo")
except ValueError:
raise ArchivoInvalidoError("Las cantidades no son numeros")
except IndexError:
raise ArchivoInvalidoError("Formato inadecuado")
except GrafoError:
raise ArchivoInvalidoError("Forma un grafo inadecuado")
def _obtener_id_vertice(self, musico):
try:
return self.musico_a_id_vertice[musico]
except KeyError:
raise ParametroInvalidoError\
("El musico %s no existe" % str(musico))
def _obtener_cantidad(self, numero_en_str):
if not numero_en_str.isdigit():
raise ParametroInvalidoError\
("La cantidad debe ser un numero entero mayor a 0")
return int(numero_en_str)
def _verificar_cant_parametros(self, f_operador, cantidad):
"""Compara utilizando la funcion_operador la cantidad de
parametros recibidos con la cantidad (rec. por parametro).
Si es falsa la comparacion levanta ParametroInvalidoError.
"""
if f_operador(len(self.parametros), cantidad):
return
raise ParametroInvalidoError\
("La cantidad de paremetros no es la esperada")
def _leer_entrada(self):
"""Lee la entrada del usuario y la formatea.
Devuelve False si no recibio nada o recibio EOF,
True en otro caso.
"""
try:
entrada = raw_input()
except EOFError:
return False
#Ya que puede venir con comas
self.parametros = entrada.split(",")
entrada = " ".join(self.parametros) #agrego whitespace
self.parametros = entrada.split() #me saca todo.
try:
self.comando = self.parametros.pop(0)
except IndexError:
return False
return True
def _ejecutar_comando(self):
"""Ejecuta el comando leido desde la entrada estandar."""
try:
self.funciones_asociadas[self.comando]()
except KeyError:
raise ComandoInvalidoError\
("El comando %s no es un comando valido" % self.comando)
def ejecutar(self):
"""Ejecuta el programa."""
while self._leer_entrada():
try:
self._ejecutar_comando()
except SistemaError, e:
print e
