716 lines
28 KiB
Python
Executable File
716 lines
28 KiB
Python
Executable File
# searchAgents.py
|
||
# ---------------
|
||
# Licensing Information: You are free to use or extend these projects for
|
||
# educational purposes provided that (1) you do not distribute or publish
|
||
# solutions, (2) you retain this notice, and (3) you provide clear
|
||
# attribution to UC Berkeley, including a link to http://ai.berkeley.edu.
|
||
#
|
||
# Attribution Information: The Pacman AI projects were developed at UC Berkeley.
|
||
# The core projects and autograders were primarily created by John DeNero
|
||
# (denero@cs.berkeley.edu) and Dan Klein (klein@cs.berkeley.edu).
|
||
# Student side autograding was added by Brad Miller, Nick Hay, and
|
||
# Pieter Abbeel (pabbeel@cs.berkeley.edu).
|
||
|
||
|
||
"""
|
||
This file contains all of the agents that can be selected to control Pacman. To
|
||
select an agent, use the '-p' option when running pacman.py. Arguments can be
|
||
passed to your agent using '-a'. For example, to load a SearchAgent that uses
|
||
depth first search (dfs), run the following command:
|
||
|
||
> python pacman.py -p SearchAgent -a fn=depthFirstSearch
|
||
|
||
Commands to invoke other search strategies can be found in the project
|
||
description.
|
||
|
||
Please only change the parts of the file you are asked to. Look for the lines
|
||
that say
|
||
|
||
"*** YOUR CODE HERE ***"
|
||
|
||
The parts you fill in start about 3/4 of the way down. Follow the project
|
||
description for details.
|
||
|
||
Good luck and happy searching!
|
||
"""
|
||
|
||
from typing import List, Tuple, Any
|
||
from game import Directions
|
||
from game import Agent
|
||
from game import Actions
|
||
import util
|
||
import time
|
||
import search
|
||
import pacman
|
||
|
||
class GoWestAgent(Agent):
|
||
"An agent that goes West until it can't."
|
||
|
||
def getAction(self, state):
|
||
"The agent receives a GameState (defined in pacman.py)."
|
||
if Directions.WEST in state.getLegalPacmanActions():
|
||
return Directions.WEST
|
||
else:
|
||
return Directions.STOP
|
||
|
||
#######################################################
|
||
# This portion is written for you, but will only work #
|
||
# after you fill in parts of search.py #
|
||
#######################################################
|
||
|
||
class SearchAgent(Agent):
|
||
"""
|
||
This very general search agent finds a path using a supplied search
|
||
algorithm for a supplied search problem, then returns actions to follow that
|
||
path.
|
||
|
||
As a default, this agent runs DFS on a PositionSearchProblem to find
|
||
location (1,1)
|
||
|
||
Options for fn include:
|
||
depthFirstSearch or dfs
|
||
breadthFirstSearch or bfs
|
||
|
||
|
||
Note: You should NOT change any code in SearchAgent
|
||
"""
|
||
|
||
def __init__(self, fn='depthFirstSearch', prob='PositionSearchProblem', heuristic='nullHeuristic'):
|
||
# Warning: some advanced Python magic is employed below to find the right functions and problems
|
||
|
||
# Get the search function from the name and heuristic
|
||
if fn not in dir(search):
|
||
raise AttributeError(fn + ' is not a search function in search.py.')
|
||
func = getattr(search, fn)
|
||
if 'heuristic' not in func.__code__.co_varnames:
|
||
print('[SearchAgent] using function ' + fn)
|
||
self.searchFunction = func
|
||
else:
|
||
if heuristic in globals().keys():
|
||
heur = globals()[heuristic]
|
||
elif heuristic in dir(search):
|
||
heur = getattr(search, heuristic)
|
||
else:
|
||
raise AttributeError(heuristic + ' is not a function in searchAgents.py or search.py.')
|
||
print('[SearchAgent] using function %s and heuristic %s' % (fn, heuristic))
|
||
# Note: this bit of Python trickery combines the search algorithm and the heuristic
|
||
self.searchFunction = lambda x: func(x, heuristic=heur)
|
||
|
||
# Get the search problem type from the name
|
||
if prob not in globals().keys() or not prob.endswith('Problem'):
|
||
raise AttributeError(prob + ' is not a search problem type in SearchAgents.py.')
|
||
self.searchType = globals()[prob]
|
||
print('[SearchAgent] using problem type ' + prob)
|
||
|
||
def registerInitialState(self, state):
|
||
"""
|
||
This is the first time that the agent sees the layout of the game
|
||
board. Here, we choose a path to the goal. In this phase, the agent
|
||
should compute the path to the goal and store it in a local variable.
|
||
All of the work is done in this method!
|
||
|
||
state: a GameState object (pacman.py)
|
||
"""
|
||
if self.searchFunction == None: raise Exception("No search function provided for SearchAgent")
|
||
starttime = time.time()
|
||
problem = self.searchType(state) # Makes a new search problem
|
||
self.actions = self.searchFunction(problem) # Find a path
|
||
if self.actions == None:
|
||
self.actions = []
|
||
totalCost = problem.getCostOfActions(self.actions)
|
||
print('Path found with total cost of %d in %.1f seconds' % (totalCost, time.time() - starttime))
|
||
if '_expanded' in dir(problem): print('Search nodes expanded: %d' % problem._expanded)
|
||
|
||
def getAction(self, state):
|
||
"""
|
||
Returns the next action in the path chosen earlier (in
|
||
registerInitialState). Return Directions.STOP if there is no further
|
||
action to take.
|
||
|
||
state: a GameState object (pacman.py)
|
||
"""
|
||
if 'actionIndex' not in dir(self): self.actionIndex = 0
|
||
i = self.actionIndex
|
||
self.actionIndex += 1
|
||
if i < len(self.actions):
|
||
return self.actions[i]
|
||
else:
|
||
return Directions.STOP
|
||
|
||
class PositionSearchProblem(search.SearchProblem):
|
||
"""
|
||
A search problem defines the state space, start state, goal test, successor
|
||
function and cost function. This search problem can be used to find paths
|
||
to a particular point on the pacman board.
|
||
|
||
The state space consists of (x,y) positions in a pacman game.
|
||
|
||
Note: this search problem is fully specified; you should NOT change it.
|
||
"""
|
||
|
||
def __init__(self, gameState, costFn = lambda x: 1, goal=(1,1), start=None, warn=True, visualize=True):
|
||
"""
|
||
Stores the start and goal.
|
||
|
||
gameState: A GameState object (pacman.py)
|
||
costFn: A function from a search state (tuple) to a non-negative number
|
||
goal: A position in the gameState
|
||
"""
|
||
self.walls = gameState.getWalls()
|
||
self.startState = gameState.getPacmanPosition()
|
||
if start != None: self.startState = start
|
||
self.goal = goal
|
||
self.costFn = costFn
|
||
self.visualize = visualize
|
||
if warn and (gameState.getNumFood() != 1 or not gameState.hasFood(*goal)):
|
||
print('Warning: this does not look like a regular search maze')
|
||
|
||
# For display purposes
|
||
self._visited, self._visitedlist, self._expanded = {}, [], 0 # DO NOT CHANGE
|
||
|
||
def getStartState(self):
|
||
return self.startState
|
||
|
||
def isGoalState(self, state):
|
||
isGoal = state == self.goal
|
||
|
||
# For display purposes only
|
||
if isGoal and self.visualize:
|
||
self._visitedlist.append(state)
|
||
import __main__
|
||
if '_display' in dir(__main__):
|
||
if 'drawExpandedCells' in dir(__main__._display): #@UndefinedVariable
|
||
__main__._display.drawExpandedCells(self._visitedlist) #@UndefinedVariable
|
||
|
||
return isGoal
|
||
|
||
def getSuccessors(self, state):
|
||
"""
|
||
Returns successor states, the actions they require, and a cost of 1.
|
||
|
||
As noted in search.py:
|
||
For a given state, this should return a list of triples,
|
||
(successor, action, stepCost), where 'successor' is a
|
||
successor to the current state, 'action' is the action
|
||
required to get there, and 'stepCost' is the incremental
|
||
cost of expanding to that successor
|
||
"""
|
||
|
||
successors = []
|
||
for action in [Directions.NORTH, Directions.SOUTH, Directions.EAST, Directions.WEST]:
|
||
x,y = state
|
||
dx, dy = Actions.directionToVector(action)
|
||
nextx, nexty = int(x + dx), int(y + dy)
|
||
if not self.walls[nextx][nexty]:
|
||
nextState = (nextx, nexty)
|
||
cost = self.costFn(nextState)
|
||
successors.append( ( nextState, action, cost) )
|
||
|
||
# Bookkeeping for display purposes
|
||
self._expanded += 1 # DO NOT CHANGE
|
||
if state not in self._visited:
|
||
self._visited[state] = True
|
||
self._visitedlist.append(state)
|
||
|
||
return successors
|
||
|
||
def getCostOfActions(self, actions):
|
||
"""
|
||
Returns the cost of a particular sequence of actions. If those actions
|
||
include an illegal move, return 999999.
|
||
"""
|
||
if actions == None: return 999999
|
||
x,y= self.getStartState()
|
||
cost = 0
|
||
for action in actions:
|
||
# Check figure out the next state and see whether its' legal
|
||
dx, dy = Actions.directionToVector(action)
|
||
x, y = int(x + dx), int(y + dy)
|
||
if self.walls[x][y]: return 999999
|
||
cost += self.costFn((x,y))
|
||
return cost
|
||
|
||
class StayEastSearchAgent(SearchAgent):
|
||
"""
|
||
An agent for position search with a cost function that penalizes being in
|
||
positions on the West side of the board.
|
||
|
||
The cost function for stepping into a position (x,y) is 1/2^x.
|
||
"""
|
||
def __init__(self):
|
||
self.searchFunction = search.uniformCostSearch
|
||
costFn = lambda pos: .5 ** pos[0]
|
||
self.searchType = lambda state: PositionSearchProblem(state, costFn, (1, 1), None, False)
|
||
|
||
class StayWestSearchAgent(SearchAgent):
|
||
"""
|
||
An agent for position search with a cost function that penalizes being in
|
||
positions on the East side of the board.
|
||
|
||
The cost function for stepping into a position (x,y) is 2^x.
|
||
"""
|
||
def __init__(self):
|
||
self.searchFunction = search.uniformCostSearch
|
||
costFn = lambda pos: 2 ** pos[0]
|
||
self.searchType = lambda state: PositionSearchProblem(state, costFn)
|
||
|
||
def manhattanHeuristic(position, problem, info={}):
|
||
"The Manhattan distance heuristic for a PositionSearchProblem"
|
||
xy1 = position
|
||
xy2 = problem.goal
|
||
return abs(xy1[0] - xy2[0]) + abs(xy1[1] - xy2[1])
|
||
|
||
def euclideanHeuristic(position, problem, info={}):
|
||
"The Euclidean distance heuristic for a PositionSearchProblem"
|
||
xy1 = position
|
||
xy2 = problem.goal
|
||
return ( (xy1[0] - xy2[0]) ** 2 + (xy1[1] - xy2[1]) ** 2 ) ** 0.5
|
||
|
||
#####################################################
|
||
# This portion is incomplete. Time to write code! #
|
||
#####################################################
|
||
|
||
class CornersProblem(search.SearchProblem):
|
||
"""
|
||
This search problem finds paths through all four corners of a layout.
|
||
|
||
You must select a suitable state space and successor function
|
||
"""
|
||
|
||
def __init__(self, startingGameState: pacman.GameState):
|
||
"""
|
||
Stores the walls, pacman's starting position and corners.
|
||
"""
|
||
self.walls = startingGameState.getWalls()
|
||
self.startingPosition = startingGameState.getPacmanPosition()
|
||
top, right = self.walls.height-2, self.walls.width-2
|
||
self.corners = ((1,1), (1,top), (right, 1), (right, top))
|
||
for corner in self.corners:
|
||
if not startingGameState.hasFood(*corner):
|
||
print('Warning: no food in corner ' + str(corner))
|
||
self._expanded = 0 # DO NOT CHANGE; Number of search nodes expanded
|
||
|
||
def getStartState(self):
|
||
"""
|
||
Returns the start state (in your state space, not the full Pacman state
|
||
space)
|
||
"""
|
||
# 状态表示为：(当前位置, 已访问的角落元组)
|
||
# 已访问的角落用四个布尔值表示，分别对应四个角落是否已被访问
|
||
# 初始状态下，只有起始位置被访问，没有角落被访问
|
||
cornersVisited = tuple([corner == self.startingPosition for corner in self.corners])
|
||
return (self.startingPosition, cornersVisited)
|
||
|
||
def isGoalState(self, state: Any):
|
||
"""
|
||
Returns whether this search state is a goal state of the problem.
|
||
"""
|
||
# 目标状态是所有四个角落都已被访问
|
||
# 状态的第二个元素是一个元组，表示四个角落的访问状态
|
||
# 如果所有四个值都为True，表示所有角落都已访问
|
||
_, cornersVisited = state
|
||
return all(cornersVisited)
|
||
|
||
def getSuccessors(self, state: Any):
|
||
"""
|
||
Returns successor states, the actions they require, and a cost of 1.
|
||
|
||
As noted in search.py:
|
||
For a given state, this should return a list of triples, (successor,
|
||
action, stepCost), where 'successor' is a successor to the current
|
||
state, 'action' is the action required to get there, and 'stepCost'
|
||
is the incremental cost of expanding to that successor
|
||
"""
|
||
|
||
successors = []
|
||
# 从当前状态中提取当前位置和角落访问状态
|
||
currentPosition, cornersVisited = state
|
||
|
||
for action in [Directions.NORTH, Directions.SOUTH, Directions.EAST, Directions.WEST]:
|
||
# 计算移动后的位置
|
||
x, y = currentPosition
|
||
dx, dy = Actions.directionToVector(action)
|
||
nextx, nexty = int(x + dx), int(y + dy)
|
||
|
||
# 检查是否会撞墙
|
||
if not self.walls[nextx][nexty]:
|
||
# 创建新的角落访问状态列表
|
||
nextPosition = (nextx, nexty)
|
||
newCornersVisited = list(cornersVisited)
|
||
|
||
# 检查新位置是否是某个角落，如果是，标记为已访问
|
||
for i, corner in enumerate(self.corners):
|
||
if nextPosition == corner and not newCornersVisited[i]:
|
||
newCornersVisited[i] = True
|
||
|
||
# 创建后继状态：(新位置, 新的角落访问状态)
|
||
successorState = (nextPosition, tuple(newCornersVisited))
|
||
|
||
# 将后继状态、动作和代价（固定为1）添加到后继列表中
|
||
successors.append((successorState, action, 1))
|
||
|
||
self._expanded += 1 # DO NOT CHANGE
|
||
return successors
|
||
|
||
def getCostOfActions(self, actions):
|
||
"""
|
||
Returns the cost of a particular sequence of actions. If those actions
|
||
include an illegal move, return 999999. This is implemented for you.
|
||
"""
|
||
if actions == None: return 999999
|
||
x,y= self.startingPosition
|
||
for action in actions:
|
||
dx, dy = Actions.directionToVector(action)
|
||
x, y = int(x + dx), int(y + dy)
|
||
if self.walls[x][y]: return 999999
|
||
return len(actions)
|
||
|
||
|
||
def cornersHeuristic(state: Any, problem: CornersProblem):
|
||
"""
|
||
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).
|
||
"""
|
||
# 从状态中提取当前位置和角落访问状态
|
||
currentPosition, cornersVisited = state
|
||
corners = problem.corners
|
||
walls = problem.walls
|
||
|
||
# 如果所有角落都已访问，返回0
|
||
if all(cornersVisited):
|
||
return 0
|
||
|
||
# 找出所有未访问的角落
|
||
unvisitedCorners = []
|
||
for i, corner in enumerate(corners):
|
||
if not cornersVisited[i]:
|
||
unvisitedCorners.append(corner)
|
||
|
||
# 如果没有未访问的角落，返回0
|
||
if not unvisitedCorners:
|
||
return 0
|
||
|
||
# 启发式策略：计算当前位置到最远未访问角落的曼哈顿距离
|
||
# 这是一个可接受的启发式，因为曼哈顿距离是实际最短路径的下界
|
||
maxDistance = 0
|
||
for corner in unvisitedCorners:
|
||
distance = util.manhattanDistance(currentPosition, corner)
|
||
maxDistance = max(maxDistance, distance)
|
||
|
||
# 为了改进启发式，我们还可以考虑未访问角落之间的最大距离
|
||
# 这样可以更好地估计访问所有剩余角落所需的总距离
|
||
maxCornerDistance = 0
|
||
for i in range(len(unvisitedCorners)):
|
||
for j in range(i + 1, len(unvisitedCorners)):
|
||
distance = util.manhattanDistance(unvisitedCorners[i], unvisitedCorners[j])
|
||
maxCornerDistance = max(maxCornerDistance, distance)
|
||
|
||
# 返回两个距离中的较大值作为启发式估计
|
||
# 这确保了启发式是可接受的（不会高估实际代价）
|
||
return max(maxDistance, maxCornerDistance)
|
||
|
||
class AStarCornersAgent(SearchAgent):
|
||
"A SearchAgent for FoodSearchProblem using A* and your foodHeuristic"
|
||
def __init__(self):
|
||
self.searchFunction = lambda prob: search.aStarSearch(prob, cornersHeuristic)
|
||
self.searchType = CornersProblem
|
||
|
||
class FoodSearchProblem:
|
||
"""
|
||
A search problem associated with finding the a path that collects all of the
|
||
food (dots) in a Pacman game.
|
||
|
||
A search state in this problem is a tuple ( pacmanPosition, foodGrid ) where
|
||
pacmanPosition: a tuple (x,y) of integers specifying Pacman's position
|
||
foodGrid: a Grid (see game.py) of either True or False, specifying remaining food
|
||
"""
|
||
def __init__(self, startingGameState: pacman.GameState):
|
||
self.start = (startingGameState.getPacmanPosition(), startingGameState.getFood())
|
||
self.walls = startingGameState.getWalls()
|
||
self.startingGameState = startingGameState
|
||
self._expanded = 0 # DO NOT CHANGE
|
||
self.heuristicInfo = {} # A dictionary for the heuristic to store information
|
||
|
||
def getStartState(self):
|
||
return self.start
|
||
|
||
def isGoalState(self, state):
|
||
return state[1].count() == 0
|
||
|
||
def getSuccessors(self, state):
|
||
"Returns successor states, the actions they require, and a cost of 1."
|
||
successors = []
|
||
self._expanded += 1 # DO NOT CHANGE
|
||
for direction in [Directions.NORTH, Directions.SOUTH, Directions.EAST, Directions.WEST]:
|
||
x,y = state[0]
|
||
dx, dy = Actions.directionToVector(direction)
|
||
nextx, nexty = int(x + dx), int(y + dy)
|
||
if not self.walls[nextx][nexty]:
|
||
nextFood = state[1].copy()
|
||
nextFood[nextx][nexty] = False
|
||
successors.append( ( ((nextx, nexty), nextFood), direction, 1) )
|
||
return successors
|
||
|
||
def getCostOfActions(self, actions):
|
||
"""Returns the cost of a particular sequence of actions. If those actions
|
||
include an illegal move, return 999999"""
|
||
x,y= self.getStartState()[0]
|
||
cost = 0
|
||
for action in actions:
|
||
# figure out the next state and see whether it's legal
|
||
dx, dy = Actions.directionToVector(action)
|
||
x, y = int(x + dx), int(y + dy)
|
||
if self.walls[x][y]:
|
||
return 999999
|
||
cost += 1
|
||
return cost
|
||
|
||
class AStarFoodSearchAgent(SearchAgent):
|
||
"A SearchAgent for FoodSearchProblem using A* and your foodHeuristic"
|
||
def __init__(self):
|
||
self.searchFunction = lambda prob: search.aStarSearch(prob, foodHeuristic)
|
||
self.searchType = FoodSearchProblem
|
||
|
||
def foodHeuristic(state: Tuple[Tuple, List[List]], problem: FoodSearchProblem):
|
||
"""
|
||
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
|
||
|
||
# 获取所有剩余食物的位置
|
||
foodList = foodGrid.asList()
|
||
|
||
# 如果没有剩余食物，返回0
|
||
if not foodList:
|
||
return 0
|
||
|
||
# 使用保守但可接受的启发式策略
|
||
# 策略1：计算到最远食物的曼哈顿距离
|
||
# 这是一个可接受的启发式，因为曼哈顿距离是实际最短路径的下界
|
||
maxDistance = 0
|
||
for food in foodList:
|
||
distance = util.manhattanDistance(position, food)
|
||
maxDistance = max(maxDistance, distance)
|
||
|
||
# 策略2：计算食物之间的最大距离
|
||
# 这提供了一个访问所有食物所需路径的下界估计
|
||
maxFoodDistance = 0
|
||
if len(foodList) > 1:
|
||
for i in range(len(foodList)):
|
||
for j in range(i + 1, len(foodList)):
|
||
distance = util.manhattanDistance(foodList[i], foodList[j])
|
||
maxFoodDistance = max(maxFoodDistance, distance)
|
||
|
||
# 策略3：使用食物数量作为基础代价
|
||
# 每个食物至少需要一步来吃掉
|
||
foodCount = len(foodList)
|
||
|
||
# 返回三个策略中的最大值，确保启发式是可接受的
|
||
# 这样可以更好地估计总代价，同时保持可接受性和一致性
|
||
return max(maxDistance, maxFoodDistance, foodCount)
|
||
|
||
def mstHeuristic(position, foodList):
|
||
"""
|
||
计算基于最小生成树的启发式值
|
||
使用Prim算法的简化版本计算连接Pacman和所有食物点的最小生成树
|
||
"""
|
||
if not foodList:
|
||
return 0
|
||
|
||
# 将Pacman位置添加到食物列表中
|
||
allPoints = [position] + foodList
|
||
n = len(allPoints)
|
||
|
||
# Prim算法计算最小生成树
|
||
visited = [False] * n
|
||
minDistances = [float('inf')] * n
|
||
minDistances[0] = 0 # 从Pacman位置开始
|
||
totalDistance = 0
|
||
|
||
for _ in range(n):
|
||
# 找到未访问节点中距离最小的节点
|
||
minDist = float('inf')
|
||
minIndex = -1
|
||
for i in range(n):
|
||
if not visited[i] and minDistances[i] < minDist:
|
||
minDist = minDistances[i]
|
||
minIndex = i
|
||
|
||
if minIndex == -1:
|
||
break
|
||
|
||
visited[minIndex] = True
|
||
totalDistance += minDist
|
||
|
||
# 更新相邻节点的最小距离
|
||
for i in range(n):
|
||
if not visited[i]:
|
||
distance = util.manhattanDistance(allPoints[minIndex], allPoints[i])
|
||
if distance < minDistances[i]:
|
||
minDistances[i] = distance
|
||
|
||
return totalDistance
|
||
|
||
def calculateMSTDistance(foodList, position):
|
||
"""
|
||
计算连接Pacman位置和所有食物点的最小生成树的近似总距离
|
||
使用Prim算法的简化版本
|
||
"""
|
||
if not foodList:
|
||
return 0
|
||
|
||
# 将Pacman位置添加到食物列表中
|
||
allPoints = [position] + foodList
|
||
n = len(allPoints)
|
||
|
||
# Prim算法计算最小生成树
|
||
visited = [False] * n
|
||
minDistances = [float('inf')] * n
|
||
minDistances[0] = 0 # 从Pacman位置开始
|
||
totalDistance = 0
|
||
|
||
for _ in range(n):
|
||
# 找到未访问节点中距离最小的节点
|
||
minDist = float('inf')
|
||
minIndex = -1
|
||
for i in range(n):
|
||
if not visited[i] and minDistances[i] < minDist:
|
||
minDist = minDistances[i]
|
||
minIndex = i
|
||
|
||
if minIndex == -1:
|
||
break
|
||
|
||
visited[minIndex] = True
|
||
totalDistance += minDist
|
||
|
||
# 更新相邻节点的最小距离
|
||
for i in range(n):
|
||
if not visited[i]:
|
||
distance = util.manhattanDistance(allPoints[minIndex], allPoints[i])
|
||
if distance < minDistances[i]:
|
||
minDistances[i] = distance
|
||
|
||
return totalDistance
|
||
|
||
class ClosestDotSearchAgent(SearchAgent):
|
||
"Search for all food using a sequence of searches"
|
||
def registerInitialState(self, state):
|
||
self.actions = []
|
||
currentState = state
|
||
while(currentState.getFood().count() > 0):
|
||
nextPathSegment = self.findPathToClosestDot(currentState) # The missing piece
|
||
self.actions += nextPathSegment
|
||
for action in nextPathSegment:
|
||
legal = currentState.getLegalActions()
|
||
if action not in legal:
|
||
t = (str(action), str(currentState))
|
||
raise Exception('findPathToClosestDot returned an illegal move: %s!\n%s' % t)
|
||
currentState = currentState.generateSuccessor(0, action)
|
||
self.actionIndex = 0
|
||
print('Path found with cost %d.' % len(self.actions))
|
||
|
||
def findPathToClosestDot(self, gameState: pacman.GameState):
|
||
"""
|
||
Returns a path (a list of actions) to the closest dot, starting from
|
||
gameState.
|
||
"""
|
||
# Here are some useful elements of the startState
|
||
startPosition = gameState.getPacmanPosition()
|
||
food = gameState.getFood()
|
||
walls = gameState.getWalls()
|
||
problem = AnyFoodSearchProblem(gameState)
|
||
|
||
# 使用广度优先搜索找到最近的食物点
|
||
# BFS保证找到最短路径（步数最少）
|
||
path = search.bfs(problem)
|
||
|
||
return path
|
||
|
||
class AnyFoodSearchProblem(PositionSearchProblem):
|
||
"""
|
||
A search problem for finding a path to any food.
|
||
|
||
This search problem is just like the PositionSearchProblem, but has a
|
||
different goal test, which you need to fill in below. The state space and
|
||
successor function do not need to be changed.
|
||
|
||
The class definition above, AnyFoodSearchProblem(PositionSearchProblem),
|
||
inherits the methods of the PositionSearchProblem.
|
||
|
||
You can use this search problem to help you fill in the findPathToClosestDot
|
||
method.
|
||
"""
|
||
|
||
def __init__(self, gameState):
|
||
"Stores information from the gameState. You don't need to change this."
|
||
# Store the food for later reference
|
||
self.food = gameState.getFood()
|
||
|
||
# Store info for the PositionSearchProblem (no need to change this)
|
||
self.walls = gameState.getWalls()
|
||
self.startState = gameState.getPacmanPosition()
|
||
self.costFn = lambda x: 1
|
||
self._visited, self._visitedlist, self._expanded = {}, [], 0 # DO NOT CHANGE
|
||
|
||
def isGoalState(self, state: Tuple[int, int]):
|
||
"""
|
||
The state is Pacman's position. Fill this in with a goal test that will
|
||
complete the problem definition.
|
||
"""
|
||
x,y = state
|
||
|
||
# 目标状态是Pacman到达任何食物的位置
|
||
# 检查当前位置是否有食物
|
||
return self.food[x][y]
|
||
|
||
def mazeDistance(point1: Tuple[int, int], point2: Tuple[int, int], gameState: pacman.GameState) -> int:
|
||
"""
|
||
Returns the maze distance between any two points, using the search functions
|
||
you have already built. The gameState can be any game state -- Pacman's
|
||
position in that state is ignored.
|
||
|
||
Example usage: mazeDistance( (2,4), (5,6), gameState)
|
||
|
||
This might be a useful helper function for your ApproximateSearchAgent.
|
||
"""
|
||
x1, y1 = point1
|
||
x2, y2 = point2
|
||
walls = gameState.getWalls()
|
||
assert not walls[x1][y1], 'point1 is a wall: ' + str(point1)
|
||
assert not walls[x2][y2], 'point2 is a wall: ' + str(point2)
|
||
prob = PositionSearchProblem(gameState, start=point1, goal=point2, warn=False, visualize=False)
|
||
return len(search.bfs(prob))
|