A* 回溯解路径 python
[英]A* retracing solution path python
问题描述
我无法理解面向 Object 的编程是如何工作的。 我想为我的代码追溯找到最佳解决方案的路径，但我不知道该怎么做。 我猜有一些关于制作 class 节点并使用它来获取父节点的东西，但我不太明白，也不知道如何实现它。！ 任何和所有的帮助表示赞赏。
'''
#################################
# Libraries...
#################################
import numpy as np
from heapq import *
import copy
import time
#############################################################################
# Classes...
#############################################################################
class puzzle:
def __init__(self, passed_map):
"""Class Construction for initializing the board
NOTE: The 0 tile is the EMPTY tile that can be used
for swapping.
Parameters
----------
init_state : list
Initial position of the board obtained from user
"""
self.passed_map = passed_map
self.grid_map = self.grid_transform(self.passed_map)
self.indicator = 0
self.total_path = []
# def rebuild_path(self, current):
# path = [current]
# state = current.parent
# while state.parent:
# path.append(state)
# state = state.parent
# return path
def grid_transform(self, puzzle:list):
"""Class Construction for initializing the board
NOTE: The 0 tile is the EMPTY tile that can be used
for swapping.
Parameters
----------
init_state : list
Initial position of the board obtained from user
"""
puzzle = np.array([puzzle])
puzzle = puzzle.reshape((3,3))
return puzzle
def null_pos(self,puzzle):
"""Detects the null within the puzzle.
Parameters
----------
puzzle : list
8 puzzle matrix form
Returns
-------
position : list
List which contains the coordinates y and x respectively.
"""
position = np.where(puzzle == self.indicator)
position = np.array([position[0],position[1]]).T
return position
def goal_test(self, puzzle):
"""Class method to test if goal state is reached and
appends the particular board configuration to the list
of explored states. Returns true if goal state is reached.
Parameters
----------
node : list
Board configuration obtained from the search tree
Returns
-------
boolean
Returns true if the passed configuration is equal to
goal configuration
"""
goal = np.array([[0,1,2],[3,4,5],[6,7,8]])
# Checks the current puzzle matches with goal puzzle.
if np.allclose(puzzle,goal) == True:
print('I AM AT GOAL STATE')
return True
else:
print('I AM NOT AT GOAL STATE')
return False
def misplaced_tiles(self,current_puzzle):
"""Function to implement misplaced tiles heuristic in
combination with no_of_misplaced_tiles() for each of
the search algorithms
Parameters
----------
current_puzzle : list
puzzle
Return
------
num_misp_tiles : int
number of misplaced tiles
"""
num_misp_tiles = 0
reference = [[0,1,2],[3,4,5],[6,7,8]]
for i in range(3):
for j in range(3):
if current_puzzle[i][j] != reference[i][j]:
num_misp_tiles+=1
# print(num_misp_tiles, 'Number of Misplaced Tiles')
return num_misp_tiles
def get_manhattan_distance(self,current_puzzle):
"""Function to calculate the manhattan distance for a
particular configuration.
Parameters
----------
current_puzzle : list
puzzle
Return
------
manh_dist : int
Manhattan Distance
"""
manh_dist = 0
for i in range(3):
for j in range(3):
# We get quoitent x and remainder y while 3 is the dividing factor
# We take 3 as dividing factor to take advantange of the fact that
# the goal state is [[0,1,2],[3,4,5],[6,7,8]] so using the divmod
# on a sample matrix [[0,1,2],[5,4,3],[6,7,8]], For position three
# in which 5 is swapped with 3 and they are in the wrong spot So from
# divmod(5,3) we get (1,2) (index location [1:0])and putting this in the
# manhattan distance manh_dist += abs(1-1)+abs(2-0) will result in 2
# manhattan distance for this number!!! Similarly we get for other points.
# It only works with the reference matrix, cannot work with other configs
x, y = divmod(current_puzzle[i][j], 3)
manh_dist += abs(x-i) + abs(y-j)
print(manh_dist,'Manhattan Distance')
return manh_dist
class node:
def __init__(self):
"""Class Construction for initializing the board
NOTE: The 0 tile is the EMPTY tile that can be used
for swapping.
Parameters
----------
init_state : list
Initial position of the board obtained from user
"""
self.puzzle_size = 2
def get_possible_moves(self,position):
"""Function to check whether a move is possible in left,
right, up, down direction and store it.
Parameters
----------
node : [type]
[description]
board : [type]
[description]
Return
------
[type]
[description]
"""
# Gathering possible neighbour points
posu = self.move_up(position)
posd = self.move_down(position)
posl = self.move_left(position)
posr = self.move_right(position)
# Assigning them to a list
possibility = []
if posu != None:
possibility.append(posu)
if posd != None:
possibility.append(posd)
if posl != None:
possibility.append(posl)
if posr != None:
possibility.append(posr)
return possibility
def swapping(self,pos,puzzle):
# Getting Zero point index
zero = obj.null_pos(puzzle)
# Getting Index of varied position
var = puzzle[pos[0]][pos[1]]
#Swapping values
puzzle[zero[0,0],zero[0,1]] = var
puzzle[pos[0], pos[1]] = 0
new_puzzle = puzzle
return new_puzzle
def move_left(self,posl:list):
"""Function to move one position left in 8 puzzle if possible
Parameters
----------
position : [type]
[description]
Returns
-------
[type]
[description]
"""
if (posl[0,1]-1)<0 or (posl[0,1]-1)>self.puzzle_size:
return
l = posl[0,0],posl[0,1]-1
return l
def move_right(self,posr):
"""Function to move one position right in 8 puzzle if possible
Parameters
----------
position : [type]
[description]
Returns
-------
[type]
[description]
"""
if (posr[0,1]+1)<0 or (posr[0,1]+1)>self.puzzle_size:
return
r = posr[0,0],posr[0,1]+1
return r
def move_up(self,posu):
"""Function to move one position up in 8 puzzle if possible
Parameters
----------
position : [type]
[description]
Returns
-------
[type]
[description]
"""
if (posu[0,0]-1)<0 or (posu[0,0]-1)>self.puzzle_size:
return
u = posu[0,0]-1,posu[0,1]
return u
def move_down(self,posd):
"""Function to move one position down in 8 puzzle if possible
Parameters
----------
position : [type]
[description]
Returns
-------
[type]
[description]
"""
if (posd[0,0]+1)<0 or (posd[0,0]+1)>self.puzzle_size:
return
d = posd[0,0]+1,posd[0,1]
return d
class tracer:
def __init__(self,puzzle):
"""Class Construction for initializing the board
NOTE: The 0 tile is the EMPTY tile that can be used
for swapping.
Parameters
----------
init_state : list
Initial position of the board obtained from user
"""
self.parent = None
self.path = puzzle
def generate_solution_path(self):
if self.parent == None:
return path
else:
path.append(self)
return self.parent.generate_solution_path(path)
#############################################################################
# Searches Algorithm
#############################################################################
def A_star(board:list):
"""Function to implement A* with H(n) as misplaced Tiles.
Parameters
----------
puzzle : list
A list with the intial configuration of numbers.
"""
# Timing it
start = time.time()
counter = 0
# Getting Grid
current = obj.grid_transform(board)
# Temporary map to prevent distortion as class methods change the original list.
temp_map = copy.deepcopy(current)
# Intializing lists for queues, path building and storage.
open_set = []
came_from = []
closed_list = []
g_score = 0
h_score = obj.misplaced_tiles(temp_map)
f_score = g_score + h_score
# Creating a heap from list to store the nodes with the priority f_score
# Heaps have problems with numpy array so convert to list and back to array
current = current.tolist()
heappush(open_set, (f_score, g_score, h_score, current))
current = np.array(current)
# Iterating through each of the prioritized nodes to find optimal solution.
while len(open_set) > 0:
# STEP I
# Un-packing open set to get the best f_score candidate.
f_score, g_score, h_score,current = heappop(open_set)
current = np.array(current)
# STEP II
# Addining this to configuration to prevent repitition.
current = current.tolist()
closed_list.append(current)
# STEP III
# Checking if this is goal state.
if current == [[0,1,2],[3,4,5],[6,7,8]]:
print('I am at goal.')
print('I took this much time to reach to goal = ',time.time()-start)
print('This is the number of nodes visited', counter)
print('These are the puzzles i went through', len(came_from))
# obj.rebuild_path(came_from, current)
break
# STEP IV
# STEP III
# Getting all possible successors from current puzzle state
counter+=1
current = np.array(current)
temp_puz = copy.deepcopy(current)
child_node = nod.get_possible_moves(obj.null_pos(temp_puz))
# Setting Retraceable path
if cu came_from:
I am parent these are my children
I am child this my children
I am a child these are my children
came_from.append(current)
# STEP IV
# Iterating through each successor to get f_score and evaluate the viability of being put
# in the priority queue.
for i in range(len(child_node)):
temp_puz = copy.deepcopy(current)
swap_map = nod.swapping(child_node[i],temp_puz)
# STEP V
# Checking if they are in the storage.
swap_map = swap_map.tolist()
if swap_map in closed_list:
continue
swap_map = np.array(swap_map)
# STEP VI
# Assigning their scores
temp_puz = copy.deepcopy(swap_map)
child_g_score = g_score + 1
child_h_score = obj.misplaced_tiles(temp_puz)
child_f_score = child_g_score + child_h_score
print('\n',current,'fscore', f_score,'child f',child_f_score,'child h',child_h_score,'\n')
# STEP VII
# Adding them into the fringe
current = swap_map.tolist()
heappush(open_set, (child_f_score, child_g_score, child_h_score, current))
current = np.array(current)
return
if __name__ == '__main__':
# puzzle_8 = [0, 1, 2, 3, 4, 5, 8, 6, 7] # Initial Configuration for testing
# puzzle_8 = [8, 7, 6, 5, 1, 4, 2, 0, 3] # Second Configuration for testing
puzzle_8 = [1, 5, 7, 3, 6, 2, 0, 4, 8] # Final Configuration for testing
obj = puzzle(puzzle_8)
nod = node()
# Greedy_search_Mis(puzzle_8)
# A_star_mis(puzzle_8)
A_star(puzzle_8)
'''
0 个解决方案
如何在不回溯乌龟路径的情况下制作未填充的Polies？
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.