def h(self, node: Node): """ Função heuristica utilizada para a procura A*. """ b = node.state.board simplified_problem = SimplifiedRicochetRobots(b) solution_node = recursive_best_first_search(simplified_problem) aux = 0 counter = 0 if solution_node != None: for s in solution_node.solution(): if s[1] != aux: aux = s[1] counter += 1 else: counter = 3 return counter
start = generate_random_init(city_num) print(start) tsp = TSPProblem(start, cities=generate_random_cities(city_num, 100)) # compare the execution time start_time = time.time() node_astar = astar_search(tsp) depth = len(node_astar.path()) print("Execution time for A*: {}".format(time.time() - start_time)) print("Node number: {}".format(tsp.nodes_cnt)) print("Depth: {}".format(depth)) print("Effective branching factor: {}".format(effective_branching_factor(tsp.nodes_cnt, depth))) tsp.nodes_cnt = 0 start_time = time.time() node_rbfs = recursive_best_first_search(tsp) depth = len(node_rbfs.path()) print("Execution time for RBFS: {}".format(time.time() - start_time)) print("Node number: {}".format(tsp.nodes_cnt)) print("Depth: {}".format(depth)) print("Effective branching factor: {}".format(effective_branching_factor(tsp.nodes_cnt, depth))) print(node_astar.state) xs = [] ys = [] for i in range(len(node_astar.state)): xs.append(tsp.cities[node_astar.state[i]][0])
We are using the manhattan distance. ''' distance = 0 rows = string_to_list(self.state_str) for number in '12345678e': #print (node.state.index(number)) row_n, col_n = find_location(rows, number) row_n_goal, col_n_goal = goal_positions[number] distance += abs(row_n - row_n_goal) + abs(col_n - col_n_goal) return distance time1 = time.time() # result = astar_search(EigthPuzzleProblem(INITIAL)) result = recursive_best_first_search(EigthPuzzleProblem(INITIAL)) # if you want to use the visual debugger, use this instead: # result = astar(EigthPuzzleProblem(INITIAL), viewer=WebViewer()) time2 = time.time() print('time cost: {}'.format(time2-time1)) step_count = 0 print (result.state) for action in result.path(): print ('\nMove {}'.format(action.action)) print (action.state) step_count += 1 print('total steps is {}'.format(step_count))
cost = self.costs[0][self.nodes.index(ite)] if shortest_cost > cost: shortest_cost_starter = cost cs_idx_list = [self.nodes.index(x) for x in cs_list] mst_matrix = np.delete(self.costs, cs_idx_list, 0) mst_matrix = np.delete(mst_matrix, cs_idx_list, 1) X = csr_matrix(mst_matrix) Tcsr = minimum_spanning_tree(X) tcsr_matrix = Tcsr.toarray().astype(int) mst_cost_sum = np.sum(tcsr_matrix) return mst_cost_sum + shortest_cost + shortest_cost_starter def value(self, state): # print('state in value: {} \t initial: {}'.format(state, self.initial)) return -1 * self.costs[self.nodes.index( self.state[-1])][self.nodes.index(state[-1])] #return len(self.state) - len(self.nodes) # result = astar_search(TSPProblem(nodes, costs)) result = recursive_best_first_search(TSPProblem(nodes, costs)) step_count = 0 #print(result) for action in result.path(): print('\nMove {}'.format(action.action)) print(action.state) step_count += 1 print('total steps is {}'.format(step_count))
import search romania_problem = search.GraphProblem('Arad', 'Craiova', search.romania_map) #vacumm_world = search.GraphProblemStochastic('State_1', ['State_7', 'State_8'], vacumm_world) #LRTA_problem = search.OnlineSearchProblem('State_3', 'State_5', one_dim_state_space) eight_puzzle = search.EightPuzzle((1, 2, 3, 0, 4, 6, 7, 5, 8)) nqueens = search.NQueensProblem(8) print("\nBest first Search") print("\nSolution to Romania Problem Arad->Craiova") print(search.recursive_best_first_search(romania_problem).solution()) print("\nSolution to Eight Puzzle (1, 2, 3, 0, 4, 6, 7, 5, 8)") print(search.recursive_best_first_search(eight_puzzle).solution())
b._barriers, simplified=True) new_board.robot_action(action) return RRState(new_board) def h(self, node: Node): b = node.state.board robot_pos = b.robot_position(b.get_target()[0]) target_pos = b.get_target()[1] return manhattan_distance(robot_pos, target_pos) def output(node): print(len(node.solution())) for s in node.solution(): print(f"{s[0]} {s[1]}") if __name__ == "__main__": # Ler o ficheiro de input de sys.argv[1], board = parse_instance(sys.argv[1]) problem = RicochetRobots(board) solution_node = recursive_best_first_search(problem) output(solution_node)
eight_puzzle = EightPuzzleProblem(start, goal, random_h=False) # compare the execution time start_time = time.time() node_astar = astar_search(eight_puzzle) depth = len(node_astar.path()) print("Execution time for A*: {}".format(time.time() - start_time)) print("Node number: {}".format(eight_puzzle.nodes_cnt)) print("Depth: {}".format(depth)) print("Effective branching factor: {}".format( effective_branching_factor(eight_puzzle.nodes_cnt, depth))) eight_puzzle.nodes_cnt = 0 start_time = time.time() node_rbfs = recursive_best_first_search(eight_puzzle) depth = len(node_rbfs.path()) print("Execution time for RBFS: {}".format(time.time() - start_time)) print("Node number: {}".format(eight_puzzle.nodes_cnt)) print("Depth: {}".format(depth)) print("Effective branching factor: {}".format( effective_branching_factor(eight_puzzle.nodes_cnt, depth))) eight_puzzle = EightPuzzleProblem(start, goal, random_h=True) eight_puzzle.nodes_cnt = 0 start_time = time.time() node_rbfs = recursive_best_first_search(eight_puzzle) depth = len(node_rbfs.path()) print("Execution time for RBFS with random number: {}".format(time.time() - start_time)) print("Node number: {}".format(eight_puzzle.nodes_cnt))