def bfs(problem): start_time = time.time() #print("next problem") search.breadth_first_tree_search(problem) #problem.display(problem.infer_assignment()) csp.AC3(problem) #problem.display(problem.infer_assignment()) solution = problem.infer_assignment() end_time = time.time() elapsed_time = end_time-start_time file_sudoku_print("BFS", elapsed_time, solution)
def solve_fn(self): # make a copy of the puzzle to determine the moves sp = Sliding_puzzle(self.n, # number of rows self.m, # number of columns goal = list(range(1, self.m*self.n))+[0] , initial = self.board) # sol_ts : goal leaf node of the solution tree search print ('** Starting the breadth_first_tree_search **') t0 = time.time() sol_ts = search.breadth_first_tree_search(sp) ## sol_ts = breadth_first_search_v0(sp) t1 = time.time() sp.print_solution(sol_ts) print ("Solver took ",t1-t0, ' seconds') # The actions are 'U','D','L' and 'R' (move the blank tile up, down, left right) # b = self.board.index(0) # position index of the blank tile # p = b + offsetDict[cmd] is the index of the tile to move offsetDict = {'U':-self.m, 'D':self.m, 'L':-1 , 'R':1} for node in sol_ts.path(): if node.action: # root action is None and should be skipped assert node.action in ['U','D','L','R'] p = self.board.index(0) + offsetDict[node.action] self.move(p) while self.moving is not None: time.sleep(0.1) self.solve_button.configure(text='Solve', command=self.solve)
def sudokuSolver(line,algor): puzzle = csp.Sudoku(line) puzzle.display(puzzle.infer_assignment()) if search != "backtracking": if len(line) == 16: size = 4 else: size = 9 board = [] c = 0 for i in range(size): board.append([0]*size) for j in range(size): if line[c] == '.': board[i][j] = 0 else: board[i][j] = int(line[c]) c = c+1 if len(line) == 16: sudoku = search.Problem(board,[1,2,3,4]) else: sudoku = search.Problem(board,[1, 2, 3, 4, 5, 6, 7, 8, 9]) if algor == "bfs": pie = search.breadth_first_tree_search(sudoku) else: pie = search.depth_first_tree_search(sudoku) for row in pie.state: print(row)
def main(): problem = MissionariesAndCannibals([3, 3, 0], [0, 0, 1]) startTime = time.time() result = breadth_first_tree_search(problem) #result = depth_first_tree_search(problem) endTime = time.time() print('걸린 시간 : ', endTime - startTime) printPathAndSolution(result)
def huarong_pass_search(desired_search_strategy): """The function returns a list of actions that when applied to the initial state lead to the goal state.""" initTime = datetime.datetime.now() problem = HuarongPass() if desired_search_strategy == "BFS": s = search.breadth_first_tree_search(problem) elif desired_search_strategy == "DFS": s = search.depth_first_graph_search(problem) elif desired_search_strategy == "IDS": s = search.iterative_deepening_search(problem) else: print "Desired search strategy not found!" endTime = datetime.datetime.now() print "Time taken", endTime - initTime return s.solution()
def main(): # ----------------------------------- Water Jug Problem -------------------------------------- # water_jug_prob = P1.WaterJugProblem((0, 0), (2, 0), (4, 3)) t0 = time.time() src1 = search.breadth_first_tree_search(water_jug_prob) t1 = time.time() src2 = search.astar_search(water_jug_prob) dt2 = time.time() - t1 dt1 = t1 - t0 print(src1.solution()) print(src2.solution()) print( "Uninformed search time: {0:.4f} seconds\nInformed search time: {1:.4f} seconds" .format(dt1, dt2)) # -------------------------------------------------------------------------------------------- # # ----------------------------------- N-Puzzle Problem: -------------------------------------- # puzzle_prob = P2.NPuzzleProblem((5, 1, 2, 4, 7, 6, 3, 8, 9, 14, 10, 12, 13, 0, 11, 15), \ (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0), 4) t0 = time.time() src1 = search.astar_search(puzzle_prob, puzzle_prob.h1) t1 = time.time() src2 = search.astar_search(puzzle_prob, puzzle_prob.h2) dt2 = time.time() - t1 dt1 = t1 - t0 print(src1.solution()) print(src2.solution()) print( "Heuristic 1 search time: {0:.4f} seconds\nHeuristic 2 search time: {1:.4f} seconds" .format(dt1, dt2))
def solve_sokoban_elem(warehouse): ''' This function should solve using elementary actions the puzzle defined in a file. @param warehouse: a valid Warehouse object @return A list of strings. If puzzle cannot be solved return ['Impossible'] If a solution was found, return a list of elementary actions that solves the given puzzle coded with 'Left', 'Right', 'Up', 'Down' For example, ['Left', 'Down', Down','Right', 'Up', 'Down'] If the puzzle is already in a goal state, simply return [] ''' #if SokobanPuzzle(warehouse).goal_test(warehouse.boxes): # return [] steps = breadth_first_tree_search(SokobanPuzzle(warehouse)) #if check_action_seq(warehouse, steps.actions()) is "Failure": # return "Impossible" return steps '''
def sudokuSolver(grid, algorithm): sudoku = Sudoku2(grid) f = open("sudoku.txt", "w") if algorithm == "bfs": inittime = time.time() info = search.breadth_first_tree_search(sudoku) finaltime = time.time() solution = sudoku.display(dict(info[0].state)) f.write("BFS Algorithm Solution For " + grid + ":\n") f.write(solution + "\n") f.write("Nodes generated: " + str(info[1]) + "; Maximum nodes stored: " + str(info[2]) + "\n") f.write("Runtime: " + str(finaltime - inittime) + " seconds\n") f.write("\n") print("Finished breadth first search") elif algorithm == "dfs": inittime = time.time() info = search.depth_first_tree_search(sudoku) info[2] = info[2] + grid.count('.') finaltime = time.time() solution = sudoku.display(dict(info[0].state)) f.write("DFS Algorithm Solution For " + grid + ":\n") f.write(solution + "\n") f.write("Nodes generated: " + str(info[1]) + "; Maximum nodes stored: " + str(info[2]) + "\n") f.write("Runtime: " + str(finaltime - inittime) + " seconds\n") f.write("\n") print("Finished depth first search") elif algorithm == "backtracking": inittime = time.time() result, num = csp.backtracking_search(sudoku, None) finaltime = time.time() solution = sudoku.display(dict(result)) f.write("Backtracking Algorithm Solution For " + grid + ":\n") f.write(solution + "\n") f.write("Assignments made: " + str(num) + "\n") f.write("Runtime: " + str(finaltime - inittime) + " seconds\n") f.write("\n") print("Finished regular backtracking search") elif algorithm == "backtracking-ordered" or algorithm == "backtracking-noOrdering" or \ algorithm == "backtracking-reverse": inittime = time.time() result, num = csp.backtracking_search(sudoku, algorithm) finaltime = time.time() solution = sudoku.display(dict(result)) print(str(finaltime) + " " + str(inittime)) f.write(algorithm + " Algorithm Solution For " + grid + ":\n") f.write(solution + "\n") f.write("Assignments made: " + str(num) + "\n") f.write("Runtime: " + str(finaltime - inittime) + " seconds\n") f.write("\n") f.close() print("Finished " + algorithm)
def pathExistsDFS(array, start, end, visited): for d in directions: i = start[0] + d[0] j = start[1] + d[1] next = [i, j] if i == end[0] and j == end[1]: return True if inBounds(array, next) and array[i][j] == '.' and not visited[i][j]: visited[i][j] = 1 exists = pathExistsDFS(array, next, end, visited) if exists: return True return False def inBounds(array, pos): #renvoie si on est toujours dans le state.array return 0 <= pos[0] and pos[0] < len( array) and 0 <= pos[1] and pos[1] < len(array[0]) ##################### # Launch the search # ##################### tic = time.process_time() problem = NumberLink(sys.argv[1]) solution = search.breadth_first_tree_search(problem) for n in solution.path(): print(n.state) toc = time.process_time() print("Le programme s'est exécuté en " + str(toc - tic) + " secondes.")
# Search methods import search ab = search.GPSProblem('U', 'C', search.romania) print search.breadth_first_tree_search(ab)[0].path() print search.breadth_first_tree_search(ab)[1] #print search.depth_first_graph_search(ab).path() #print search.iterative_deepening_search(ab).path() #print search.depth_limited_search(ab).path() print search.branch_and_bound_tree_search(ab)[0].path() print search.branch_and_bound_tree_search(ab)[1] print search.branch_and_bound_h_tree_search(ab)[0].path() print search.branch_and_bound_h_tree_search(ab)[1] #print search.astar_search(ab).path() # Result: # [<Node B>, <Node P>, <Node R>, <Node S>, <Node A>] : 101 + 97 + 80 + 140 = 418 # [<Node B>, <Node F>, <Node S>, <Node A>] : 211 + 99 + 140 = 450
) def result(self, s, a): """Devuelve el estado resultante de aplicar una accion a un estado determinado.""" # el estado resultante tiene la canoa en el lado opuesto, y con las # cantidades de misioneros y canibales actualizadas segun la cantidad # que viajaron en la canoa if s[2] == 0: return (s[0] - a[1][0], s[1] - a[1][1], 1) else: return (s[0] + a[1][0], s[1] + a[1][1], 0) # creamos un problema a partir de nuestra formalizacion de ProblemaMisioneros # como parametros le pasamos el estado inicial, y el estado meta que esperamos p1 = ProblemaMisioneros((3, 3, 0), (0, 0, 1)) # le decimos a aima que resuelva nuestro problema con el metodo de busqueda en # amplitud r = breadth_first_tree_search(p1) # esto nos devuelve el nodo meta del arbol. Podemos recorrer sus padres para # tener todo el camino de acciones camino_acciones = [] while r: if r.action: camino_acciones.append(r.action[0]) r = r.parent print " ".join(reversed(camino_acciones))
# Initial initial = Point(50, 20) goal = Point(10, 60) matrix = init_matrix(initial, goal) plot_result(matrix, initial, goal, 'Mapa do ambiente inicial') # BFS initial = Point(50, 20) goal = Point(10, 60) matrix = init_matrix(initial, goal) search_problem = MatrixProblem(initial, goal, matrix) start = time.time() node = breadth_first_tree_search(search_problem) end = time.time() paint_solution(node, matrix) print(''.join(['BFS search time: ', str(end - start)])) plot_result( matrix, initial, goal, ''.join(['Busca em expansão (t = ', str(round(end - start, 4)), ' s)'])) # DFS initial = Point(50, 20) goal = Point(10, 60) matrix = init_matrix(initial, goal) search_problem = MatrixProblem(initial, goal, matrix) start = time.time()
node.state.board.targetPos) + node.state.board.getDistance( robot_pos3, node.state.board.targetPos) + node.state.board.getDistance( robot_pos4, node.state.board.targetPos) def output(self, node: Node): actions = node.solution() print(len(actions)) for action in actions: print(action[0] + " " + action[1]) if __name__ == "__main__": # Ler o ficheiro de input de sys.ar gv[1], board = parse_instance(sys.argv[1]) # Usar uma técnica de procura para resolver a instância, problem = RicochetRobots(board) inst = InstrumentedProblem(problem) # Retirar a solução a partir do nó resultante, start = time.time() #solution_node = astar_search(inst) solution_node = breadth_first_tree_search(inst) end = time.time() print(end - start) #print(len(solution_node.path())) #print(len(solution_node.expand(problem))) #states = gerados, succs = expandidos, goal_tests = testados como solução print("expandidos: ", inst.states) print("gerados: ", inst.succs) # Imprimir para o standard output no formato indicado. #problem.output(solution_node)
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #______________________________________________________________________________ # if __name__ == "__main__": sp = Sliding_puzzle(nr=3, nc=8, N=6) t0 = time.time() sol_ts = search.breadth_first_tree_search(sp) t1 = time.time() sp.print_solution(sol_ts) print ("Solver took ",t1-t0, ' seconds') # + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + # CODE CEMETARY # + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + # if self.nr*self.nc<10: # if t>0: # print (t,end=' ') # else:
import search ab = search.GraphProblem('A', 'B', search.romania) print search.breadth_first_tree_search(ab).solution()
def astar_tree_search(problem, h=None, display=False): h = memoize(h or problem.h, 'h') return best_first_tree_search(problem, lambda n: n.path_cost + h(n), display) if __name__ == "__main__": input_file = sys.argv[1] algo = sys.argv[2] map_dict, heuristic, start, goal = parse(input_file) problem = MapProblem(start, goal, map_dict, heuristic) if algo == 'BFTS': goal_node = breadth_first_tree_search(problem) elif algo == 'DFTS': goal_node = depth_first_tree_search(problem) elif algo == 'DFGS': goal_node = depth_first_graph_search(problem) elif algo == 'BFGS': goal_node = breadth_first_graph_search(problem) elif algo == 'UCTS': goal_node = uniform_cost_tree_search(problem) elif algo == 'UCGS': goal_node = uniform_cost_search(problem) elif algo == 'GBFTS': goal_node = greedy_best_first_tree_search(problem) elif algo == 'GBFGS': goal_node = greedy_best_first_graph_search(problem, problem.h) elif algo == 'ASTS':
def romania_problem_test(): problem = GraphProblem('Arad', 'Bucharest', romania_map) s = breadth_first_tree_search(problem) assert s.state == "Bucharest"