def search_path_with_waypoints(waypoints):
if waypoints and len(waypoints) > 1:
initial_state = waypoints[0]
for i in range(len(waypoints)-1):
print(initial_state)
final_state = waypoints[i+1]
MapPathProblemWaypoints=probee.ProblemaEspacioEstados(actions,initial_state,[final_state])
solution=busqee.BúsquedaÓptima().buscar(MapPathProblemWaypoints)
if solution:
print(solution)
initial_state=waypoints[i+1]
else:
print("No solution found")
start_time1 = time()
statusChange = auxiliar.Auxiliar.adjacent_triplet(status)
statusChangeTras = [[
statusChange[j][i] for j in range(len(statusChange))
] for i in range(len(statusChange[0]))]
# statuschange2 = auxiliar.Auxiliar.pair_induction(statusChange, statusChangeTras)
statusTry2Next = auxiliar.Auxiliar.twoNext(statusChange)
# newStateMultipleCopy = copy.deepcopy(statusTry2Next)
res = auxiliar.Auxiliar.multipleCero(statusTry2Next)
while res:
res = auxiliar.Auxiliar.multipleCero(statusTry2Next)
pom = hitori(statusTry2Next)
hitori_resolver = probee.ProblemaEspacioEstados(
pom.acciones, pom.estado_inicial)
numberRepeats = 0
numberRepeats = auxiliar.Auxiliar.repeatsNumber(statusTry2Next)
finish_time1 = time()
execute_time1 = finish_time1 - start_time1
# print(statusChange)
# print(statusChangeTras)
# print(statuschange2)
# print(statusTry2Next)
# print(newStateMultipleCopy)
# print(len(pom.acciones))
# print(pom.acciones)
# print("numberRepeats")
desplazamientoArriba = probe.Acción(
"Moverse hacia arriba", puedeArriba, mueveArriba, suma
) #Comprueba que puede moverse a la izquierda, se mueve y obtiene el valor de la casilla
#-----------------------------------------------------------
def puedeIzquierda(
estado
): #Devuelve true si al moverse a la izquierda no se sale del mapa y a la izquierda no hay una casilla de agua.
return estado[1] > 0 and mapaEjemplo.tipoCelda(
estado[0],
estado[1] - 1) != 0 #Ponemos un "-" pues va hacia la izquierda
def mueveIzquierda(estado): #nuevo estado
return estado[0], estado[1] - 1 # Se pone "-" por la misma razón
desplazamientoIzquierda = probe.Acción(
"Moverse hacia la izquierda", puedeIzquierda, mueveIzquierda, suma
) #Comprueba que puede moverse a la izquierda, se mueve y obtiene el valor de la casilla
problemaEstados = probe.ProblemaEspacioEstados([
desplazamientoAbajo, desplazamientoDerecha, desplazamientoArriba,
desplazamientoIzquierda
], posInicial, [posFinal])
solucionOptima = buse.BúsquedaÓptima()
print("\n")
print(solucionOptima.buscar(problemaEstados))
def poner_disco(self, estado, varilla, disco):
estado[varilla - 1].add(disco)
def aplicar(self, estado):
nuevo_estado = copy.deepcopy(estado)
disco = self.quitar_disco(nuevo_estado, self.varilla_de)
self.poner_disco(nuevo_estado, self.varilla_a, disco)
return nuevo_estado
acciones = [
MoverDisco(i, j) for i in range(1, 4) for j in range(1, 4) if i != j
]
estado_inicial = [{1, 2}, set(), set()]
estado_final = [set(), set(), {1, 2}]
Torres_Hanoi_2 = probee.ProblemaEspacioEstados(acciones, estado_inicial,
[estado_final])
pathAnchura = busqee.BúsquedaEnAnchura(detallado=True).buscar(Torres_Hanoi_2)
print(pathAnchura)
class TorresHanoi(probee.ProblemaEspacioEstados):
def __init__(self, n):
acciones = [
MoverDisco(i, j) for i in range(1, 4) for j in range(1, 4)
if i != j
]
estado_inicial = [set(range(1, n + 1)), set(), set()]
super().__init__(acciones, estado_inicial)
self.n = n
def es_estado_final(self, estado):
moveLeft = probee.Acción("Left", applicabilityL, applyL, cost)
def applicabilityR(state):
(i, j) = state
return (j < map.tamaño_hor()-1) and map.tipo_celda(i, j+1) != 0
def applyR(state):
(i, j) = state
return (i, j+1)
moveRight = probee.Acción("Right", applicabilityR, applyR, cost)
actions=[moveUp,moveDown,moveLeft,moveRight]
MapPathProblem = probee.ProblemaEspacioEstados(actions,e_ini,[e_fin])
import math
def h(node): #Basic heuristic
res=None
(i,j)=node.estado
for final_state in [e_fin]:
aux=math.sqrt((i-final_state[0])**2 + (j-final_state[1])**2)
if res == None:
res = aux
elif aux < res:
res = aux