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 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 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 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 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 _actores():
actores_por_pelicula = {}
actores = set()
with open("actores_test.csv") as f:
for l in f:
splitted = l.strip().split(",")
actor = splitted[0]
actores.add(actor)
peliculas = splitted[1:]
for peli in peliculas:
if peli not in actores_por_pelicula:
actores_por_pelicula[peli] = []
actores_por_pelicula[peli].append(actor)
g = Grafo()
for peli in actores_por_pelicula:
if len(actores_por_pelicula[peli]) < 2:
continue
for i in range(len(actores_por_pelicula[peli])):
for j in range(i + 1, len(actores_por_pelicula[peli])):
if actores_por_pelicula[peli][i] not in g:
g.agregar_vertice(actores_por_pelicula[peli][i])
if actores_por_pelicula[peli][j] not in g:
g.agregar_vertice(actores_por_pelicula[peli][j])
g.arista(actores_por_pelicula[peli][i],
actores_por_pelicula[peli][j])
return g
def test_vertice_pertenece(self):
#creo un grafo no dirigido
grafo = Grafo(False)
#le agrego un vértice
grafo.agregar_vertice("A")
#me fijo si el vértice pertenece o no al grafo
self.assertTrue(grafo.vertice_pertenece("A"))
def _n_reinas(n):
casillero = lambda i, j: str(i + 1) + chr(ord('a') + j)
g = Grafo()
for i in range(n):
for j in range(n):
g.agregar_vertice(casillero(i, j))
# Agrego adyacencia por fila
for i in range(n):
for j in range(n):
for k in range(j, n):
g.arista(casillero(i, j), casillero(i, k))
# Agrego por columnas
for j in range(n):
for i in range(n):
for k in range(i, n):
g.arista(casillero(i, j), casillero(k, j))
# agrego por diagonales
for i in range(n):
for j in range(n):
for k in range(n - max((i, j))):
g.arista(casillero(i, j), casillero(i + k, j + k))
for k in range(min(n - i, j)):
g.arista(casillero(i, j), casillero(i + k, j - k))
return g
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 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 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 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 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 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 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 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 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 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 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 lectura(grafo, params):
grafo_aux = Grafo(True)
for param in params:
grafo_aux.agregar_vertice(param)
for param in params:
for w in grafo.obtener_adyacentes(param):
if w in params:
grafo_aux.agregar_arista(w, param)
grados = {}
for v in grafo_aux:
grados[v] = 0
for v in grafo_aux:
for w in grafo_aux.obtener_adyacentes(v):
grados[w] += 1
q = deque()
for v in grafo_aux:
if grados[v] == 0:
q.append(v)
res = []
while len(q):
v = q.popleft()
res.append(v)
for w in grafo_aux.obtener_adyacentes(v):
grados[w] -= 1
if grados[w] == 0:
q.append(w)
print(grafo_aux)
for param in params:
if param not in res:
print("No existe forma de leer las paginas en orden")
return
params.reverse()
print(", ".join(params))
def hacer_grafo_2(datos):
"""Recibe los datos cargados del archivo tsv para armar dos grafos de los cuales se obtendrán las conclusiones en los distintos
comandos. Se armael grafo 2:
| G2 | --> Es un grafo no dirigido donde están conectadas todas las canciones que pertenezcan a una misma lista de reproducción.
Si una canción aparece en más de una playlist, sus adyacentes serán las canciones de ambas listas de reproducción.
Devuelve G2"""
G2 = Grafo(False, False)
for _, canciones in datos[2].items():
for cancion in canciones:
G2.agregar_vertice(cancion)
for cancion_1 in canciones:
for cancion_2 in canciones:
if cancion_1 == cancion_2:
continue
G2.agregar_arista(cancion_1, cancion_2)
return G2
def arbol_tendido_minimo(grafo): #mst_prim
inicio = grafo.obt_1_vertice()
visitados = set()
visitados.add(inicio)
heap = Heap(cmp_arista)
arbol = Grafo(True, True)
for v in grafo.obt_vertices():
arbol.agregar_vertice(v)
for v in grafo.obtener_vecinos(inicio):
heap.encolar((inicio, v, grafo.ver_peso(inicio, v)))
while not heap.esta_vacio():
arista = heap.desencolar()
v = arista[1]
if v in visitados:
continue
arbol.agregar_arista(arista[0], arista[1], arista[2])
visitados.add(v)
for w in grafo.obtener_vecinos(v):
heap.encolar((v, w, grafo.ver_peso(v, w)))
return arbol
def itinerario(vertices, n_archivo):
grafo = Grafo(True, False)
for v in vertices:
grafo.agregar_vertice(v)
with open(n_archivo) as archivo:
linea = archivo.readline()
linea = linea.rstrip("\n")
linea = linea.split(",")
grafo.agregar_arista(linea[0], linea[1])
res = orden_topologico(grafo)
cant_res = len(res)
peso = 0
for i in range(1, cant_res):
peso += grafo.ver_peso(res[i - 1], res[i])
stdout_flechas(res, cant_res, peso)
return res
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
