def foodHeuristic(state, problem):
"""
Your heuristic for the FoodSearchProblem goes here.
This heuristic must be consistent to ensure correctness. First, try to come up
with an admissible heuristic; almost all admissible heuristics will be consistent
as well.
If using A* ever finds a solution that is worse uniform cost search finds,
your heuristic is *not* consistent, and probably not admissible! On the other hand,
inadmissible or inconsistent heuristics may find optimal solutions, so be careful.
The state is a tuple ( pacmanPosition, foodGrid ) where foodGrid is a
Grid (see game.py) of either True or False. You can call foodGrid.asList()
to get a list of food coordinates instead.
If you want access to info like walls, capsules, etc., you can query the problem.
For example, problem.walls gives you a Grid of where the walls are.
If you want to *store* information to be reused in other calls to the heuristic,
there is a dictionary called problem.heuristicInfo that you can use. For example,
if you only want to count the walls once and store that value, try:
problem.heuristicInfo['wallCount'] = problem.walls.count()
Subsequent calls to this heuristic can access problem.heuristicInfo['wallCount']
"""
position, foodGrid = state
"*** YOUR CODE HERE ***"
h=0.0
x,y=position
food_state=foodGrid.data
walls=problem.walls
nrows=len(food_state)
ncols=len(food_state[0])
graph=util.PriorityQueue()
pacman_distances=[]
food_position=[]
for i in xrange(nrows):
for j in xrange(ncols):
if food_state[i][j]==True:
food_position.append((i,j))
manhattan=abs(x-i)+abs(y-j)
distance=manhattan
pacman_distances.append(distance)
food_count=len(food_position)
for i in xrange(food_count):
for j in xrange(i+1,food_count):
x1,y1=food_position[i]
x2,y2=food_position[j]
manhattan=abs(x1-x2)+abs(y1-y2)
distance=manhattan
graph.push(((x1,y1),(x2,y2),distance),distance)
mst_weight=mst.getWeightFromMST(graph,food_count)
if pacman_distances:
h+=min(pacman_distances)
h+=mst_weight
return h
def cornersHeuristic(state, problem):
"""
A heuristic for the CornersProblem that you defined.
state: The current search state
(a data structure you chose in your search problem)
problem: The CornersProblem instance for this layout.
This function should always return a number that is a lower bound
on the shortest path from the state to a goal of the problem; i.e.
it should be admissible (as well as consistent).
"""
"*** YOUR CODE HERE ***"
h=0
corners = problem.corners # These are the corner coordinates
walls = problem.walls # These are the walls of the maze, as a Grid (game.py)
graph=util.PriorityQueue()
pacman_distances=[]
position,food_state=state
x,y=position
food_position=[]
for i in xrange(len(food_state)):
if food_state[i]=="0":
food_position.append(corners[i])
food_x,food_y=corners[i]
manhattan=abs(x-food_x)+abs(y-food_y)
distance=manhattan
pacman_distances.append(distance)
food_count=len(food_position)
for i in xrange(food_count):
for j in xrange(i+1,food_count):
x1,y1=food_position[i]
x2,y2=food_position[j]
#manhattan=abs(x1-x2)+abs(y1-y2)
distance=manhattan
graph.push(((x1,y1),(x2,y2),distance),distance)
mst_weight=mst.getWeightFromMST(graph,food_count)
if pacman_distances:
h+=min(pacman_distances)
h+=mst_weight
return h