bp[dest] = orig # reconstruir camino hacia atras camino = [v] while v != bp[v]: v = bp[v] camino.append(v) camino.reverse() return camino if __name__ == '__main__': pasillos = [((0, 0), (0, 1)), ((0, 2), (0, 3)), ((1, 0), (1, 1)), ((1, 1), (1, 2)), ((2, 0), (2, 1)), ((2, 1), (2, 2)), ((2, 2), (2, 3)), ((0, 1), (1, 1)), ((0, 2), (1, 2)), ((0, 3), (1, 3)), ((1, 1), (2, 1)), ((1, 2), (2, 2))] lab = UndirectedGraph(E=pasillos) v_ini = (0, 0) v_tes = (1, 3) print(edge_path(lab, v_ini)) camino = recuperador_camino(edge_path(lab, v_ini), v_tes) print("Camino al v_tes {0}".format(camino)) lv = LabyrinthViewer(lab, canvas_width=600, canvas_height=400, margin=10) lv.add_path(camino) lv.run()
seen = set() aristas = [] recorre_profundidad(source, source) return recuperador_camino(aristas, target) def recuperador_camino(aristas, target): ##Problema2 dc = {} for u, v in aristas: dc[v] = u path = [] path.append(target) while target != dc[target]: target = dc[target] path.append(target) path.reverse() return path g = crea_laberinto(40, 40) camino = path(g, (0, 0), (39, 39)) camino2 = path_directo(g, (0, 0), (39, 39)) lv = LabyrinthViewer(g, canvas_width=600, canvas_height=400, margin=10) lv.add_path(camino, 'blue', -1) lv.add_path(camino2, 'red', 1) lv.run()
camino.reverse() return camino def shortest_path(g: UndirectedGraph, source: Vertex, target: Vertex) -> List[Vertex]: lista_aristas = recorredor_aristas_anchura(g, source) return recuperador_camino(lista_aristas, target) def path(g: UndirectedGraph, source: Vertex, target: Vertex) -> List[Vertex]: lista_aristas = recorredor_aristas_profundidad(g, source) return recuperador_camino(lista_aristas, target) if __name__ == "__main__": random.seed(1) num_rows = 60 num_cols = 80 g = create_labyrinth(num_rows, num_cols, 2000) camino_largo = path(g, (0, 0), (num_rows - 1, num_cols - 1)) camino = shortest_path(g, (0, 0), (num_rows - 1, num_cols - 1)) print(f"Camino largo: {len(camino_largo)}") print(f"Camino corto: {len(camino)}") lv = LabyrinthViewer(g, canvas_width=1200, canvas_height=800, margin=10) lv.add_path(camino_largo, 'blue') lv.add_path(camino, 'red') lv.run()
def execute_maze(*args): lab = UndirectedGraph( E=create_labyrinth(int(rowsInput.get()), int(colsInput.get()))) lv = LabyrinthViewer(lab, canvas_width=1000, canvas_height=1000, margin=10) lv.run()
for r, c in vertices: if r > 0: edges.append(((r, c), (r - 1, c))) if c > 0: edges.append(((r, c), (r, c - 1))) shuffle(edges) corridors: List[Edge] = [] for e in edges: (v, u) = e if mfs.find(v) != mfs.find(u): mfs.merge(v, u) corridors.append(e) else: if n > 0: corridors.append((u, v)) n -= 1 return UndirectedGraph(E=corridors) # Programa Principal if __name__ == "__main__": seed(42) graph = create_labyrinth(60, 80) lv = LabyrinthViewer(graph, canvas_width=1200, canvas_height=800, margin=10) lv.run()
#------ PRINTS del ejercicio: ------ if pared_seleccionada[1] < pared_seleccionada[2]: print(pared_seleccionada[1][0], pared_seleccionada[1][1], pared_seleccionada[2][0], pared_seleccionada[2][1]) else: print(pared_seleccionada[2][0], pared_seleccionada[2][1], pared_seleccionada[1][0], pared_seleccionada[1][1]) print(len(caminoSinTirarPared) - 1) print(pared_seleccionada[0]) #----------------------------------- # OPCIONAL: Opción '-g' muestra gráficamente el laberinto if len(sys.argv) == 3 and sys.argv[2] == '-g': lv = LabyrinthViewer(lab, canvas_width=1200, canvas_height=750, margin=6) lv.add_path(caminoSinTirarPared, 'green', 0) lv.add_marked_cell(pared_seleccionada[1], 'red') lv.add_marked_cell(pared_seleccionada[2], 'red') # Nuevo laberinto con el pasillo nuevo (al quitar un muro, tienes un nuevo pasillo) nuevo_vector = vectorPasillos.copy() nuevo_vector.append((pared_seleccionada[1], pared_seleccionada[2])) lab2 = UndirectedGraph(E=nuevo_vector) caminoConTirarPared = shortest_path(lab2, (0, 0), (rows - 1, cols - 1)) lv.add_path(caminoConTirarPared, 'blue', 4)
camino = [] v = target camino.append(v) while parent[v] != v: v = parent[v] camino.append(v) # Step 4 return camino if __name__ == '__main__': lab = load_labyrinth(sys.argv[1]) source = (0, 0) rec = recorredor_aristas_anchura(lab, source) t, target = rec[-1] # lab = UndirectedGraph(E=v) print(lab) camino = path(lab, source, target) v = LabyrinthViewer(lab, canvas_width=400, canvas_height=400) v.set_input_point(source) v.set_output_point(target) v.add_path(camino, 'blue') v.run()
##Celda mas alejada de u, edges contiene aristas para llegar de u a v v, edges, matrix = farthest_cell_from(lab, u, matrix) ##Distancia entre u y v cost = matrix[v[0]][v[1]] ##Aplicamos restricciones para la eleccion de la celda inicial y final if u[0] < v[0]: start = u last = v elif u[0] > v[0]: start = v last = u elif u[1] > v[1]: start = v last = u elif u[1] < v[1]: start = u last = v print(start[0], start[1]) print(last[0], last[1]) print(cost) if (len(sys.argv) == 3 and sys.argv[2] == '-g'): camino = path_recoverer(edges, v) lv = LabyrinthViewer(lab, canvas_width=600, canvas_height=400, margin=10) lv.set_input_point(start) lv.set_output_point(last) lv.add_path(camino, 'blue') lv.run()
((2, 5), (1, 5)), ((2, 5), (2, 4)), ((0, 3), (0, 2)), ((4, 0), (4, 1)), ((1, 2), (0, 2)), ((1, 2), (1, 1)), ((4, 9), (3, 9)), ((3, 3), (2, 3)), ((3, 3), (4, 3)), ((2, 9), (3, 9)), ((2, 9), (1, 9)), ((4, 4), (3, 4)), ((4, 4), (4, 3)), ((3, 6), (3, 5)), ((2, 2), (3, 2)), ((4, 1), (4, 2)), ((1, 1), (1, 0)), ((0, 1), (0, 2)), ((3, 2), (3, 1)), ((2, 6), (2, 7)), ((4, 5), (4, 6)), ((0, 4), (0, 5)), ((0, 4), (1, 4)), ((3, 9), (3, 8)), ((0, 5), (0, 6)), ((0, 7), (0, 6)), ((0, 7), (1, 7)), ((4, 2), (4, 3)), ((0, 8), (0, 9)), ((3, 5), (3, 4)), ((1, 8), (1, 7)), ((0, 9), (1, 9)), ((2, 3), (2, 4)) ] # Laberinto en forma de grafo no dirigido graph = UndirectedGraph(E=e) #Obligatorio: Crea un LabyrinthViewer pasándole el grafo del laberinto lv = LabyrinthViewer(graph, canvas_width=600, canvas_height=400, margin=10) #Opcional: Muestra el símbolo 'I' en la celda de entrada al laberinto lv.set_input_point((0, 0)) #Opcional: Visualiza el símbolo 'O' en la celda de salida del laberinto lv.set_output_point((4, 9)) #Opcional: marca una celda lv.add_marked_cell((3, 4), 'red') #Opcional: Visualiza un camino en azul path = [(0, 0), (1, 0), (1, 1), (1, 2), (0, 2), (0, 3), (1, 3), (1, 4), (0, 4), (0, 5), (0, 6), (0, 7), (1, 7), (1, 8), (2, 8), (2, 7), (2, 6), (1, 6), (1, 5), (2, 5), (2, 4), (2, 3), (3, 3), (4, 3), (4, 4), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9), (4, 9)]
def bien_formado(lab, vertices): return True if len(lab.E) == len(vertices) - 1 else False if __name__ == '__main__': random.seed(18) filas, columnas, paredes, aristas_p = load_file() aristas, vertices = create_labyrinth(filas, columnas) lab = UndirectedGraph(E=aristas) if bien_formado(lab, vertices): print(filas, columnas) print(len(aristas)) for u, v in lab.E: print(u[0], u[1], v[0], v[1]) else: print("NO ES POSIBLE CONSTRUIR EL LABERINTO") if len(sys.argv) == 3 and sys.argv[2] == "-g": print(filas, columnas) print(len(aristas)) for u, v in lab.E: print(u[0], u[1], v[0], v[1]) lv = LabyrinthViewer(lab, canvas_width=1300, canvas_height=1300, margin=10) lv.run()