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