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()