def main():
parser = argparse.ArgumentParser()
parser.add_argument("-g", "--game", help="Specify the game number, e.g. --game 4",
type=int)
parser.add_argument("-b", "--bfs", help="Run program using breadth first search.",
action="store_true")
parser.add_argument("-a", "--astar", help="Run program using A star algortihm.",
action="store_true")
parser.add_argument("-d", "--depth", help="Depth of the a star algorithm.",
type=int)
parser.add_argument("-n", "--not_admissable", help="Set this flag, if you want a not addmissable a start algorithm.",
action="store_true")
parser.add_argument("-i", "--interactive", help="Run program with interactive freezing.",
action="store_true")
args = parser.parse_args()
if args.bfs:
breath_search(games[args.game - 1], math.inf)
elif args.astar:
a_star_search(games[args.game - 1], args.depth, not args.not_admissable)
elif args.interactive:
interactive_search(args.game)
else:
print("Please add either the --bfs flag or --astar flag.")
def main(arg):
initial_state = []
goal = [0, 1, 2, 3, 4, 5, 6, 7, 8]
with open(arg, "r") as file:
line = file.readline()
for val in line.split(" "):
initial_state.append(int(val))
if set(goal) != set(initial_state):
sys.exit("ERROR: input is not valid, it must have numbers from 0 to 8")
elif len(goal) != len(initial_state):
sys.exit(
"ERROR: invalid input, it must have nine numbers, from 0 to 8")
start = timer()
final_state, explored_set, size = a_star_search(initial_state, goal)
end = timer()
if final_state != None:
print("=" * 20)
print("Solution depth or cost: %d" % len(final_state.path))
print("=" * 20)
print("Number of visited nodes: %d" % len(explored_set))
print("=" * 20)
print("Running time: %f sec" % (end - start))
print("=" * 20)
print("Bytes per node: %d" % sys.getsizeof(final_state))
print("Used memory: %d bytes" % size)
print("=" * 20)
print("This are the movements to solve the puzzle:")
print("-" * 20)
print(*final_state.path, sep=' => ')
else:
print("It has no solution :(")
def solve():
initial_state = get_initial_state()
if not initial_state:
tkinter.messagebox.showerror('错误', '非法初始状态')
return
goal_state = get_goal_state()
if not goal_state:
tkinter.messagebox.showerror('错误', '非法目标状态')
return
choice = var.get()
path = []
if choice == 1:
path = bfs.breadth_first_search(initial_state, goal_state)
elif choice == 2:
path = dfs.depth_first_search(initial_state, goal_state)
elif choice == 3:
path = iddfs.iterative_deepening_dfs(initial_state, goal_state)
elif choice == 4:
path = best_first.best_first_search(initial_state, goal_state)
elif choice == 5:
path = bidirectional.bidirectional_search(initial_state, goal_state)
elif choice == 6:
path = a_star.a_star_search(initial_state, goal_state)
elif choice == 7:
path = ida_star.iterative_deepening_a_star(initial_state, goal_state)
output.delete(1.0, END)
output.insert(1.0, auxiliary.path_to_str(path))
def test_maze_1(self):
maze = GridWithWeights(4,4)
walls = [(1,1),(2,2)]
maze.walls = walls
weights = {(1,0):20,(3,0) : 2}
maze.weights = weights
my_solution = [(3,0),(3,1),(3,2),(3,3),(2,3),(1,3),(1,2),(0,2)]
end = (3,0)
start = (0,2)
# Call the A* algorithm and get the frontier
frontier = a_star.a_star_search(graph = maze, start=start, end=end)
solution = list(backtrack(frontier.visited,start,end))
self.assertTrue( solution == my_solution )
def test_maze_1(self):
maze = GridWithWeights(4, 4)
walls = [(1, 1), (2, 2)]
maze.walls = walls
weights = {(1, 0): 20, (3, 0): 2}
maze.weights = weights
my_solution = [(3, 0), (3, 1), (3, 2), (3, 3), (2, 3), (1, 3), (1, 2),
(0, 2)]
end = (3, 0)
start = (0, 2)
# Call the A* algorithm and get the frontier
frontier = a_star.a_star_search(graph=maze, start=start, end=end)
solution = list(backtrack(frontier.visited, start, end))
self.assertTrue(solution == my_solution)
def plan(start, goals, problem, states, algorithm='a-star'):
if goals is None or len(goals) == 0:
return [], sys.maxsize
# if a-star search is used
if algorithm == 'a-star':
results = [
a_star_search(start, State(goal), problem, states)
for goal in goals if goal is not None
]
results = sorted(results, key=lambda x: x[1])
return results[0]
# if depth-limited is used
if algorithm == 'depth-limited':
return depth_limited_search(start, goals, problem)
raise ValueError
def test_weights_instead_of_walls(self):
maze = GridWithWeights(4, 4)
walls = []
maze.walls = walls
weights = {(1, 1): 300, (1, 2): 300, (1, 3): 300}
maze.weights = weights
start = (0, 3)
end = (3, 3)
my_solution = [(3, 3), (2, 3), (2, 2), (2, 1), (2, 0), (1, 0), (0, 0),
(0, 1), (0, 2), (0, 3)]
# Call the A* algorithm and get the frontier
frontier = a_star.a_star_search(graph=maze, start=start, end=end)
solution = list(backtrack(frontier.visited, start, end))
self.assertTrue(solution == my_solution)
def test_weights_instead_of_walls(self):
maze = GridWithWeights(4,4)
walls = []
maze.walls = walls
weights = { (1,1):300, (1,2): 300, (1,3):300}
maze.weights = weights
start = (0,3)
end = (3,3)
my_solution = [(3, 3), (2, 3), (2, 2), (2, 1),
(2, 0), (1, 0), (0, 0), (0, 1),
(0, 2), (0, 3)]
# Call the A* algorithm and get the frontier
frontier = a_star.a_star_search(graph = maze, start=start, end=end)
solution = list(backtrack(frontier.visited,start,end))
self.assertTrue( solution == my_solution )
def _query(self, start, goal):
'''
Queries current PRM to find path between start and goal.
Alters the map. Returns path as list of states.
'''
#add start and goal to the map
s_node = Node(start)
g_node = Node(goal)
self.T.add_node(s_node)
self.T.add_node(g_node)
#Add neighbors for the two nodes
for nb in self.T.find_k_nearest(self.num_neighbors, start):
self.try_connect(s_node, nb)
for nb in self.T.find_k_nearest(self.num_neighbors, goal):
self.try_connect(g_node, nb)
#Run A* pathfinding to get path
return a_star.a_star_search(s_node, g_node)
def main():
parser = argparse.ArgumentParser(
description="Solve a maze problem with genetic algorithm")
parser.add_argument("maze",
help="The maze file to run the algorithm",
type=str)
parser.add_argument("-p",
"--population",
help="Population size (must be an odd number)",
type=int)
parser.add_argument(
"-m",
"--mutation",
help="The mutation chance (must be between 0 and 1)",
type=float,
)
parser.add_argument("-ml",
"--move",
help="Number of moves allowed to the chromosome",
type=int)
parser.add_argument(
"-i",
"--iterations",
help=
"Number of iterations the algorithm will execute to try to find the exit",
type=int,
)
args = parser.parse_args()
if not args.population:
population = 501
else:
if args.population % 2 == 0:
population = args.population + 1
print("Population must be an odd number. Rounding up to " +
str(population))
else:
population = args.population
if not args.mutation:
mutation = 0.5
else:
if args.mutation > 1:
mutation = 0.5
print("Mutation must be between 0 and 1. Setting to " +
str(mutation))
else:
mutation = args.mutation
if not args.move:
move = 40
else:
move = args.move
if not args.iterations:
iterations = 5000
else:
iterations = args.iterations
print("Starting maze")
print("Maze solving started with variables population=" + str(population) +
", mutation=" + str(mutation) + ", moves=" + str(move) +
", iterations=" + str(iterations))
genetic_algorithm = GA(move, population, mutation, args.maze)
route = genetic_algorithm.search_optional_moves(
genetic_algorithm.population, iterations)
if route is None:
print("Solution not found")
else:
print("Exit found!")
print("Chromosome with moves: " + str(route[0]))
print("Start: " + str(route[1][0]) + " End: " + str(route[1][1]))
print("List of coordinates that player moved: " + str(route[2]))
print("Starting A*")
print("Creating graph")
graph = Graph(genetic_algorithm.current_maze.Board)
print("Graph created")
print("Starting algorithm processing")
came_from, cost_so_far = a_star_search(graph, route[1][0], route[1][1])
best_path = reconstruct_path(came_from, route[1][0], route[1][1])
print("Best path found! It's:")
print(best_path)
194, 201, 202, 203, 204, 205, 213, 214, 223,
224, 243, 244, 253, 254, 273, 274, 283, 284,
303, 304, 313, 314, 333, 334, 343, 344, 373,
374, 403, 404, 433, 434]]
# Instantiate a grid of 10 x 10
graph = GridWithWeights(10, 10)
# Set the walls of the grid
graph.walls = set(WALLS)
# Set the weighs of some points in the maze
graph.weights = {location: random.randint(1,10) for location in [(3, 4), (3, 5), (4, 1), (4, 2),
(4, 3), (4, 4), (4, 5), (4, 6),
(4, 7), (4, 8), (5, 1), (5, 2),
(5, 3), (5, 4), (5, 5), (5, 6),
(5, 7), (5, 8), (6, 2), (6, 3),
(6, 4), (6, 5), (6, 6), (6, 7),
(7, 3), (7, 4), (7, 5)]}
# Call the A* algorithm and get the frontier
frontier = a_star.a_star_search(graph = graph, start=(1, 4), end=(7, 8))
# Print the results
graph.draw(width=5, point_to = frontier.visited, start=(1, 4), goal=(7, 8))
print()
graph.draw(width=5, number = frontier.costs, start=(1, 4), goal=(7, 8))
def solve():
solution = a_star.a_star_search(start, goal, size, heuristic_cost_estimate, get_neighbors, get_edge_weight)
print(solution)
print("moves: " + str(len(solution)-1))
break
if not args[1][i][1] in args[0]:
fail = 1
break
if args[1][i][2] and args[1][i][2].isdigit():
args[1][i][2] = float(args[1][i][2])
else:
fail = 1
break
if fail:
print("[Failed] Test #{}. {}".format(test_number, line.strip()))
else:
matrix = a_star.create_matrix(list(), args[0], args[1])
index = 0
a_star.list_vertex = args[0]
ans = a_star.a_star_search(matrix, args[2][0], args[2][1])
add = args[2][1]
string = add
while add != args[2][0]:
add = ans[add]
string += add
string = string[::-1]
if string == outp:
print("[OK] Test #{}. {}".format(test_number, line.strip()))
else:
print("[Failed] Test #{}. {}".format(test_number, line.strip()))
test_number += 1
def applyAStar(head, foodCoord):
tupleHead = tuple(head)
tupleFood = tuple(foodCoord)
movePath = a_star.a_star_search(settings.getMap(), tupleHead, tupleFood)
return movePath
254, 273, 274, 283, 284, 303, 304, 313, 314, 333, 334, 343, 344,
373, 374, 403, 404, 433, 434
]
]
# Instantiate a grid of 10 x 10
graph = GridWithWeights(10, 10)
# Set the walls of the grid
graph.walls = set(WALLS)
# Set the weighs of some points in the maze
graph.weights = {
location: random.randint(1, 10)
for location in [(3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (
4, 5), (4, 6), (4, 7), (4, 8), (5, 1), (5, 2), (5, 3), (
5, 4), (5, 5), (5, 6), (5, 7), (5, 8), (6, 2), (6, 3), (
6, 4), (6, 5), (6, 6), (6, 7), (7, 3), (7, 4), (7, 5)]
}
# Call the A* algorithm and get the frontier
frontier = a_star.a_star_search(graph=graph, start=(1, 4), end=(7, 8))
# Print the results
graph.draw(width=5, point_to=frontier.visited, start=(1, 4), goal=(7, 8))
print()
graph.draw(width=5, number=frontier.costs, start=(1, 4), goal=(7, 8))
