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