def resolver(metodo_busqueda, posiciones_personas):
""" Devuelve un nodo resultado, a partir de una búqueda especificada.
Argumentos:
metodo_busqueda -- nombre de método a usar (string);
posiciones_personas -- lista de tuplas. Cada tupla representa la posicion
de una persona en la grilla (aún por rescatar).
"""
"""
Estado inicial: Lista compuesta de 4 posiciones:
1era posicion: Tupla. Posicion del robot en la grilla.
2da posicion: Lista de tuplas. Posiciones de la grilla que el robot va
hundiendo (inutilizando).
3era posicion: Lista de tuplas. Posiciones de la grilla donde se ubican
las personas aún no rescatadas.
4ta posicion: Booleano. Es True si el robot esta 'ocupado' (esta cargando
personas), caso contrario False.
"""
ESTADO_INICIAL = ((0, 0), (), posiciones_personas, False)
problema = RescatePersonas(ESTADO_INICIAL)
if metodo_busqueda == 'astar':
return astar(problema, graph_search=True)
elif metodo_busqueda == 'depth_first':
return depth_first(problema, graph_search=True)
elif metodo_busqueda == 'breadth_first':
return breadth_first(problema, graph_search=True)
elif metodo_busqueda == 'greedy':
return greedy(problema, graph_search=True)
def doDepthFirst(NEWMAP, problem, myviewer):
result = depth_first(problem, graph_search=True, viewer=myviewer)
path = [x[1] for x in result.path()]
# print(result.state)
# print(result.path())
print("Ruta realizada Profundidad:")
print(result.path())
print(printMap(NEWMAP, problem, path))
def DFS(SearchingProblem):
print("---Depth First Search---")
before = datetime.now()
search = depth_first(SearchingProblem,graph_search=(True))
#search = depth_first(SearchingProblem,graph_search=(True),viewer=my_viewer)
after = datetime.now()
print("Path -->",search.path())
print("Time -->", (after - before).total_seconds())
print("Path cost-->",search.cost)
print("-" * 40)
def main():
start_board = Board.board_from_file(sys.argv[1])
duplication_checks = sys.argv[2]
method = sys.argv[3]
heuristic = ''
check_duplicates = 'graph' in duplication_checks
if 'star' in method:
heuristic = sys.argv[4]
if heuristic == 'max_moves':
start_board.heuristic = heuristics.max_moves
elif heuristic == 'min_moves':
start_board.heuristic = heuristics.min_moves
elif heuristic == 'max_movable_pegs':
start_board.heuristic = heuristics.max_movable_pegs
elif heuristic == 'man':
start_board.heuristic = heuristics.manhattan_distance
else:
print('You did not pick a viable heuristic. Exiting...')
return
start = time.time()
if method == 'dfs':
result = depth_first(start_board, check_duplicates)
elif method == 'bfs':
result = breadth_first(start_board, check_duplicates)
elif method == 'astar':
result = astar(start_board, check_duplicates)
elif method == 'ildf':
result = iterative_limited_depth_first(start_board, check_duplicates)
else:
print('You must choose a valid search method. Exiting...')
return
end = time.time()
print("-" * 30)
print('Search:', sys.argv[2], 'on', sys.argv[3], sys.argv[4] if len(sys.argv) > 4 else '')
print('Input File:', sys.argv[1])
if result:
path = result.path()
for step in path:
print(step[0], '-->', Board.board_from_state(step[1]))
print('Duration: {0:.4f} seconds'.format(end - start))
print('Nodes Visited:', len(path))
else:
print("No solution found!")
print("-" * 30)
def resolver(metodo_busqueda, posicion_rey, controlar_estados_repetidos):
problema = HnefataflProblem(posicion_rey)
visor = BaseViewer()
if metodo_busqueda == "breadth_first":
resultado = breadth_first(problema, graph_search=controlar_estados_repetidos)
return resultado
if metodo_busqueda == "depth_first":
return depth_first(problema, graph_search=controlar_estados_repetidos)
if metodo_busqueda == "greedy":
return greedy(problema, graph_search=controlar_estados_repetidos)
if metodo_busqueda == "astar":
return astar(problema, graph_search=controlar_estados_repetidos)
def resolver(metodo_busqueda, posiciones_aparatos): Inicial = [(3,3)] for ap in posiciones_aparatos: Inicial.append((ap[0], ap[1], 300)) if metodo_busqueda == "breadth_first": return breadth_first(Problem(tuple(Inicial)), graph_search=True) if metodo_busqueda == "astar": return astar(Problem(tuple(Inicial)), graph_search=True) if metodo_busqueda == "greedy": return greedy(Problem(tuple(Inicial)), graph_search=True) if metodo_busqueda == "depth_first": return depth_first(Problem(tuple(Inicial)), graph_search=True)
def createProblem(listaSnake):
problem = SnakeGame((listaSnake[0].rect.x, listaSnake[0].rect.y), (food.rect.x, food.rect.y))
result = depth_first(problem, graph_search=True)
path = [x[1] for x in result.path()]
moves = result.path()
moves = moves[1:]
lm = []
for i in moves:
lm.append(i[0])
lm.reverse()
return lm
def resolver(metodo_busqueda):
visor = BaseViewer()
if metodo_busqueda == 'breadth_first':
result = breadth_first(entrega1tradicional(INITIAL), graph_search=True, viewer=visor)
if metodo_busqueda == 'depth_first':
result = depth_first(entrega1tradicional(INITIAL), graph_search=True, viewer=visor)
if metodo_busqueda == 'limited_depth_first':
result = iterative_limited_depth_first(entrega1tradicional(INITIAL),10, viewer=visor)
if metodo_busqueda == 'greedy':
result = greedy(entrega1tradicional(INITIAL), graph_search=True, viewer=visor)
if metodo_busqueda == 'astar':
result = astar(entrega1tradicional(INITIAL), graph_search=True, viewer=visor)
return result
def resolver(metodo_busqueda, posicion_rey, controlar_estados_repetidos):
INITIAL = posicion_rey
problema = HnefataflProblema(posicion_rey)
visor = BaseViewer()
#Busqueda en amplitud
if (metodo_busqueda == 'breadth_first'):
resultado = breadth_first(problema,
graph_search=controlar_estados_repetidos,
viewer=visor)
return resultado
#Busqueda en profundidad
if (metodo_busqueda == 'depth_first'):
resultado = depth_first(problema,
graph_search=controlar_estados_repetidos,
viewer=visor)
return resultado
#Busqueda avara
if (metodo_busqueda == 'greedy'):
resultado = greedy(problema,
graph_search=controlar_estados_repetidos,
viewer=visor)
return resultado
#Busqueda A Estrella
if (metodo_busqueda == 'astar'):
resultado = astar(problema,
graph_search=controlar_estados_repetidos,
viewer=visor)
return resultado
# for action, state in resultado.path():
# print action
# print resultado.path()
# print 'produndidad: ' + str(resultado.depth)
# print state
# print 'El costo es: ' + str(resultado.cost)
# print visor.stats
#if __name__ == '__main__':
# resolver('breadth_first', (5,3),True)
def resolver(metodo_busqueda, posiciones_personas):
inicial = GenerarEstado(posiciones_personas)
problema = RescateHieloProblem(inicial)
if metodo_busqueda == "breadth_first":
return breadth_first(problema,
graph_search=True,
viewer=ConsoleViewer())
if metodo_busqueda == "greedy":
return greedy(problema, graph_search=True, viewer=ConsoleViewer())
if metodo_busqueda == "depth_first":
return depth_first(problema, graph_search=True, viewer=ConsoleViewer())
if metodo_busqueda == "astar":
return astar(problema, graph_search=True, viewer=ConsoleViewer())
def main():
problem = GameWalkPuzzle(MAP)
#result = astar(problem, graph_search=True)
result = depth_first(problem, graph_search=True)
path = [x[1] for x in result.path()]
for y in range(len(MAP)):
for x in range(len(MAP[y])):
if (x, y) == problem.initial:
print("o", end='')
elif (x, y) == problem.goal:
print("x", end='')
elif (x, y) in path:
print("·", end='')
else:
print(MAP[y][x], end='')
print()
def resolver(metodo_busqueda, posiciones_personas):
state = ((0, 0), (posiciones_personas), ())
my_viewer = BaseViewer()
if 'astar':
result = astar(TpProblem(state), graph_search=True, viewer=my_viewer)
elif 'breadth_first':
result = breadth_first(TpProblem(state),
graph_search=True,
viewer=my_viewer)
elif 'depth_first':
result = depth_first(TpProblem(state),
graph_search=True,
viewer=my_viewer)
elif 'greedy':
result = greedy(TpProblem(state), graph_search=True, viewer=my_viewer)
return result
def resolver(metodo_busqueda, franceses, piratas):
viewer = None
letra = 0
franceses = list(franceses)
piratas = list(piratas)
for barcos in piratas:
if letra == 0:
piratas[0] = list(piratas[0])
piratas[0].insert(0, 'A')
piratas[0].append(0)
piratas[0].append(0)
piratas[0] = tuple(piratas[0])
if letra == 1:
piratas[1] = list(piratas[1])
piratas[1].insert(0, 'B')
piratas[1].append(0)
piratas[1].append(0)
piratas[1] = tuple(piratas[1])
if letra == 2:
piratas[2] = list(piratas[2])
piratas[2].insert(0, 'C')
piratas[2].append(0)
piratas[2].append(0)
piratas[2] = tuple(piratas[2])
letra = letra + 1
estado = ((tuple(piratas), tuple(franceses)))
problem = Barcos_Piratas(estado)
if metodo_busqueda == "breadth_first":
resultado = breadth_first(problem, graph_search=True, viewer = viewer)
elif metodo_busqueda == "greedy":
resultado = greedy(problem, graph_search=True, viewer = viewer)
elif metodo_busqueda == "depth_first":
resultado = depth_first(problem, graph_search=True, viewer = viewer)
elif metodo_busqueda == "astar":
resultado = astar(problem, graph_search=True, viewer = viewer)
elif metodo_busqueda == "uniform_cost":
resultado = uniform_cost(problem, graph_search=True, viewer = viewer)
return resultado
def createProblem(listaSnake, food, method, direction):
problem = SnakeGame((listaSnake[0].rect.x, listaSnake[0].rect.y), (food.rect.x, food.rect.y), listaSnake, direction)
if method == "astar":
result = astar(problem, graph_search=True)
elif method == "dfs":
result = depth_first(problem, graph_search=True)
else:
result = breadth_first(problem, graph_search=True)
if result == None:
return False
moves = result.path()
moves = moves[1:]
lm = []
for i in moves:
lm.append(i[0])
lm.reverse()
return lm
def resolver(metodo_busqueda, posicion_rey, controlar_estados_repetidos):
problema = HnefataflProblema(posicion_rey)
visor = BaseViewer()
#Busquedas, Grafo -> graph_search=True
if (metodo_busqueda == 'breadth_first'): # En amplitud
resultado = breadth_first(problema,
graph_search=controlar_estados_repetidos,
viewer=visor)
elif (metodo_busqueda == 'depth_first'): # Profundidad
resultado = depth_first(problema,
graph_search=controlar_estados_repetidos,
viewer=visor)
elif (metodo_busqueda == 'greedy'): # Avara
resultado = greedy(problema,
graph_search=controlar_estados_repetidos,
viewer=visor)
elif (metodo_busqueda == 'astar'): # Estrella
resultado = astar(problema,
graph_search=controlar_estados_repetidos,
viewer=visor)
print(visor.stats)
return resultado
def resolver(metodo_busqueda, posiciones_aparatos):
estado = [
(3, 3, 0),
]
nuevo_estado = ((), )
lista_aparatos = []
posiciones_aparatos = list(posiciones_aparatos)
for artefacto in posiciones_aparatos:
lista_artefacto = list(artefacto)
lista_aparatos.append(lista_artefacto)
posiciones_aparatos = tuple(posiciones_aparatos)
for aparato in lista_aparatos:
aparato.append(300)
for aparato in lista_aparatos:
tupla_aparato = tuple(aparato)
estado.append(tupla_aparato)
nuevo_estado = tuple(estado)
problema = BomerobotProblem(nuevo_estado)
if metodo_busqueda == 'breadth_first':
resultado = breadth_first(problema, graph_search=True)
return resultado
if metodo_busqueda == 'depth_first':
resultado = depth_first(problema, graph_search=True)
return resultado
if metodo_busqueda == 'greedy':
resultado = greedy(problema, graph_search=True)
return resultado
if metodo_busqueda == 'astar':
resultado = astar(problema, graph_search=True)
return resultado
def test_depth_first(self):
result = depth_first(self.problem)
self.assertEquals(result.state, GOAL)
return (action,
tuple([food_pos for food_pos in foods if food_pos != action]))
def heuristic(self, state):
rat_pos, foods = state
distances = [manhattan(rat_pos, EXIT)]
for food_pos in foods:
distances.append(
manhattan(rat_pos, food_pos) + manhattan(food_pos, EXIT))
return max(distances)
print('Searching for a solution...')
# result = astar(RatsProblem(INITIAL), graph_search=True,
# viewer=WebViewer())
viewer = BaseViewer()
# result = astar(RatsProblem(INITIAL), graph_search=True, viewer=viewer)
result = depth_first(RatsProblem(INITIAL), graph_search=True, viewer=viewer)
print('Solution found!')
print('State:', result.state)
print('Solution cost:', result.cost)
print('Stats:', viewer.stats)
print('Path from initial:')
for action, resulting_state in result.path():
print('action:', action)
print('state:', resulting_state)
print('-' * 40)
def is_goal(self, state):
"""
This method evaluates whether the specified state is the goal state.
state : The game state to test.
"""
return state == self.goal
#------------------------------------------------------------------------------------------------------------------
# Program
#------------------------------------------------------------------------------------------------------------------
# Create solver object\
print("Depth First search")
result = depth_first(MissionariesAndCannibals(), graph_search=True)
# Print results
for i, (action, state) in enumerate(result.path()):
print()
if action == None:
print('Initial configuration')
elif i == len(result.path()) - 1:
print('Movement: ' + str(i) + ' After moving', action,
'Goal achieved!')
else:
print('Movement: ' + str(i) + ' After moving', action)
print(state)
print("------------------------------------------------------")
elif state == [[0, 0], [3, 3, "B"]]:
return ["C2", "C1", "C1M1"]
elif state == [[1, 0, "B"], [2, 3]]:
return ["C1"]
else:
return []
def result(self, state, action):
'''Transition model'''
state = from_string_to_list_2(state)
if "B" in state[0]:
state[1] = state[1] + (list(state[0].pop()))
return from_list_to_string(actions_helper(state, action))
if "B" in state[1]:
state[0] = state[0] + (list(state[1].pop()))
return from_list_to_string(actions_helper(state, action, x=1, y=0))
def is_goal(self, state):
''' Checks if particular state is a goal state'''
return state == GOAL
problem = MissionriesCannibals(initial_state)
result = depth_first(problem, graph_search=True)
print(result.path())
print(result.state)
#for act, state in result.path():
# print("Action taken {}".format(act))
# print("resulting state {}".format(state))
# Starting point
INITIAL = '''1-e-2
6-3-4
7-5-8'''
# Create a cache for the goal position of each piece
goal_positions = {}
rows_goal = string_to_list(GOAL)
for number in '12345678e':
goal_positions[number] = get_location(rows_goal, number)
# Create the solver object
#result = astar(PuzzleSolver(INITIAL), graph_search=True)
#result = breadth_first(PuzzleSolver(INITIAL), graph_search=True)
#result = iterative_limited_depth_first(PuzzleSolver(INITIAL), graph_search=True)
result = depth_first(PuzzleSolver(INITIAL), graph_search=True)
#result = idastar(PuzzleSolver(INITIAL), graph_search=True)
# Print the results
for i, (action, state) in enumerate(result.path()):
print()
if action == None:
print('Initial configuration')
elif i == len(result.path()) - 1:
print('After moving', action, 'into the empty space. Goal achieved!')
else:
print('After moving', action, 'into the empty space')
print(state)
'''Returns true if a state is the goal state.'''
return state == GOAL
def cost(self, state1, action, state2):
'''Returns the cost of performing an action. No useful on this problem, i
but needed.
'''
return 1
def heuristic(self, state):
'''Returns an *estimation* of the distance from a state to the goal.
We are using the manhattan distance.
'''
rows = string_to_list(state)
distance = 0
row_c, col_c = find_location(rows, 'c')
row_c_goal, col_c_goal = goal_positions['c']
distance += abs(row_c - row_c_goal) + abs(col_c - col_c_goal)
return distance
result = depth_first(SnakeProblem(INITIAL),graph_search=True)
for action, state in result.path():
print('Move ', action)
print(state)
distancia = n*2 - state[ap][0] - state[ap][1] + abs(state[ap][0]-rx) + abs(state[ap][1]-ry)
for otroAp in range(1,len(state)):
if otroAp != ap:
distancia += (n*2 - state[otroAp][0] - state[otroAp][1])*2
if menor == 0 or menor > distancia:
menor = distancia
return menor
def resolver(metodo_busqueda, posiciones_aparatos):
Inicial = [(3,3)]
for ap in posiciones_aparatos:
Inicial.append((ap[0], ap[1], 300))
if metodo_busqueda == "breadth_first":
return breadth_first(Problem(tuple(Inicial)), graph_search=True)
if metodo_busqueda == "astar":
return astar(Problem(tuple(Inicial)), graph_search=True)
if metodo_busqueda == "greedy":
return greedy(Problem(tuple(Inicial)), graph_search=True)
if metodo_busqueda == "depth_first":
return depth_first(Problem(tuple(Inicial)), graph_search=True)
if __name__ == '__main__':
Inicial = ((3,3),(1,2,300),(2,0,300),(3,0,300))
print('Prueba depth_first')
visor = BaseViewer()
resultado = depth_first(Problem(Inicial), graph_search = True, viewer = visor)
#print(resultado.path())
print(resultado.state)
print(resultado.cost)
print(visor.stats)
