def aStarSearch(problem, heuristic=nullHeuristic): """Search the node that has the lowest combined cost and heuristic first.""" "*** YOUR CODE HERE ***" # Define a funcao que define o custo da lista de acoes def ordenaCustos(no): acoes = [] # Cria lista de acoes if no is None: return # Retorna se caminho estiver vazio (estado inicial) acoes = list(no[2]) # Clona lista de acoes do caminho custoAcoes = problem.getCostOfActions(acoes) custoHeuristico = heuristic(no[0], problem) return custoAcoes + custoHeuristico # Retorna custos final (custo real + custo herusitica) # ordenaCustos = lambda path: problem.getCostOfActions([x[1] for x in path][1:]) # Initializa fila de prioridade com o callback filaPrioridade = util.PriorityQueueWithFunction(ordenaCustos) # Array de coordenadas ja visitadas coordVisitados = [] # No de inicio (coordenada do no, direcao, caminho percorrido ate este no) noInicial = (problem.getStartState(), None, []) # Insere o primeiro inicial na lista de nos filaPrioridade.push(noInicial) # Itera ate que a fila esteja vazia while not filaPrioridade.isEmpty(): atual = filaPrioridade.pop() # Remove o no do topo da fila atualCoord = atual[0] # Guarda a coordenada do no atual # atualAcao = atual[1] # Guarda a acao (direcao) pela qual se chegou no no atual atualCaminho = atual[ 2] # Guarda o caminho ate ter chegado neste no atual if (atualCoord not in coordVisitados ): # Se o no atual ainda nao foi visitado, continuar coordVisitados.append( atualCoord) # Adiciona a coord do atual na lista de visitados if (problem.isGoalState(atualCoord) ): # Se eh o objetivo, retorna o caminho ate chegar neste no return atualCaminho sucessores = problem.getSuccessors( atualCoord) # Encontrar todos os nos vizinhos (sucessores) for sucessor in sucessores: # Expande os nos vizinhos, na sequencia da lista if sucessor[ 0] not in coordVisitados: # Se o vizinho ainda nao foi visitado, coloca na lista filaPrioridade.push((sucessor[0], sucessor[1], atualCaminho + [sucessor[1]])) return []
def uniformCostSearch(problem): "Search the node of least total cost first. " "*** YOUR CODE HERE ***" print("Start:", problem.getStartState()) print("Is the start a goal?", problem.isGoalState(problem.getStartState())) print("Start's successors:", problem.getSuccessors(problem.getStartState())) explored = [] cost = lambda apath: problem.getCostOfActions(x[1] for x in apath) fringe = util.PriorityQueueWithFunction(cost) #fringe = util.PriorityQueueWithFunction(len) #if cost =1 # define the fringe as a Stack. You can check util.py ## fringe.push([(problem.getStartState(), "Stop", 0) ]) # adding the first node into the fringe # please note that each node is represented using the path from the starting node to the it while not fringe.isEmpty(): # print ("fringe: ", fringe.heap) path = fringe.pop( ) # pop a node from the fringe ## # print "path len: ", len(path) # print "path: ", path s = path[len(path) - 1] s = s[0] # print "s: ", s if problem.isGoalState(s): # print "FOUND SOLUTION: ", [x[1] for x in path] return [x[1] for x in path][1:] if s not in explored: explored.append( s) # append the state to explored ## # print "EXPLORING: ", s for successor in problem.getSuccessors(s): # print "SUCCESSOR: ", successor if successor[0] not in explored: successorPath = path[:] successorPath.append(successor) # print "successorPath: ", successorPath fringe.push( successorPath ) # push the sucessor Path into fringe ## # else: # print successor[0], " IS ALREADY EXPLORED!!" return [] util.raiseNotDefined()
def aStarSearch(problem, heuristic=nullHeuristic): "that's my task Search project" "Search the node that has the lowest combined cost and heuristic first." "*** YOUR CODE HERE ***" print("Start:", problem.getStartState()) print("Is the start a goal?", problem.isGoalState(problem.getStartState())) print("Start's successors:", problem.getSuccessors(problem.getStartState())) explored = [] # cost function fn = lambda path: problem.getCostOfActions(x[1] for x in path) + heuristic(x[1] for x in path) fringe = util.PriorityQueueWithFunction(fn) # adding the first node into the fringe fringe.push([(problem.getStartState(), "Stop", 0)]) # please note that each node is represented using the path from the starting node to the it while not fringe.isEmpty(): # print ("fringe: ", fringe.heap) path = fringe.pop() # pop a node from the fringe # print "path len: ", len(path) # print "path: ", path # print(path) # print(len(path)) print(fringe) s = path[len(path) - 1] s = s[0] # print "s: ", s if problem.isGoalState(s): # print "FOUND SOLUTION: ", [x[1] for x in path] return [x[1] for x in path][1:] if s not in explored: explored.append(s) # append the state to explored # print "EXPLORING: ", s for successor in problem.getSuccessors(s): # print "SUCCESSOR: ", successor if successor[0] not in explored: successorPath = path[:] successorPath.append(successor) # print "successorPath: ", successorPath # push the sucessorPath into fringe fringe.push(successorPath) # else: # print successor[0], " IS ALREADY EXPLORED!!" return [] util.raiseNotDefined()
def AStar_search(problem, heuristic=nullHeuristic): """ Search the node that has the lowest combined cost and heuristic first. Return the route as a list of nodes(Int) iterated through starting from the first to the final. """ def f(node): return node.path_cost + heuristic(node.state,problem) start_no = problem.getStartState() start_node = Node(start_no,start_no,0,start_no,0) frontier = util.PriorityQueueWithFunction(f) frontier.push(start_node) expanded_list = [] while(not frontier.isEmpty()): current_node = frontier.pop() if current_node.state in expanded_list: continue if(problem.isGoalState(current_node.state)): goal_node = current_node break else: expanded_list.append(current_node.state) succesors = problem.getSuccessors(current_node.state) for s in succesors: if s[0] in expanded_list: continue else: frontier.push(Node(s[0],s[0],current_node.path_cost+s[2],current_node,0)) # now extract the list from the goal node solution = [] temp = goal_node current_no = temp.state while(current_no != start_no): solution.append(current_no) temp = temp.parent_node current_no = temp.state solution.append(start_no) solution.reverse() return solution # util.raiseNotDefined()
def uniformCostSearch(problem): """Search the node of least total cost first. python pacman.py -l mediumMaze -p SearchAgent -a fn=ucs python pacman.py -l mediumDottedMaze -p StayEastSearchAgent python pacman.py -l mediumScaryMaze -p StayWestSearchAgent """ # TODO Problem 3: UCS """ For Uniform Cost Search, a Priority Queue is used as the container with a function that gets the cost of going through the route from the start state to the state of that node. Utilizes the second element of each successor. """ def cost_function(node): return problem.getCostOfActions(node[1]) container = util.PriorityQueueWithFunction(cost_function) return search(problem, container)
def aStarSearch(problem, heuristic=nullHeuristic): "Search the node that has the lowest combined cost and heuristic first." frontier = util.PriorityQueueWithFunction(lambda x: x[1]+heuristic(x[0], problem)) visited = set(problem.getStartState()) frontier.push((problem.getStartState(),0, [])) solution_found = False while not solution_found: expand_element, previous_cost, movelist = frontier.pop() if problem.isGoalState(expand_element): return movelist else: successors = problem.getSuccessors(expand_element) for successor_state, action, cost in successors: if successor_state not in visited: visited.add(successor_state) frontier.push((successor_state, previous_cost + cost, movelist + [action]))
def aStarSearch(problem, heuristic=nullHeuristic): "Search the node that has the lowest combined cost and heuristic first." func = lambda x: heuristic(x[0], problem) q = util.PriorityQueueWithFunction(func) current_state = problem.getStartState() q.push((current_state, [])) visited = [] while not q.isEmpty(): current_state, path = q.pop() visited.append(current_state) if problem.isGoalState(current_state): return path for i in problem.getSuccessors(current_state): if not i[0] in visited: q.push((i[0], path + [i[1]]))
def aStarSearch(problem, heuristic=nullHeuristic): """Search the node that has the lowest combined cost and heuristic first.""" "*** YOUR CODE HERE ***" #util.raiseNotDefined() def cost_astar(current_node): # here the heuristic which is used to compute Astar (Manhattan/ Euclidean dist) is used from searchAgents package # which takes two parameters the position and the problem cost = problem.getCostOfActions(current_node[1]) + heuristic( current_node[0], problem) return cost nodeDataStructure = util.PriorityQueueWithFunction(cost_astar) path = commonSearch(problem, nodeDataStructure) #print "PATH:",path return path
def uniformCostSearch(problem): """Search the node of least total cost first.""" "*** YOUR CODE HERE ***" def calculateUniformSearchCost(pathCost): start = 3 totalCost = 0.0 length = len(pathCost) while start < length: y = pathCost[start] totalCost += y[2] start += 1 return totalCost return graphSearch( problem, util.PriorityQueueWithFunction(calculateUniformSearchCost))
def uniformCostSearch(problem): """Search the node of least total cost first.""" "*** YOUR CODE HERE ***" current, cost = problem.getStartState(), 0 costfunction = lambda state: path[state][2] + cost fringe, explored, path = util.PriorityQueueWithFunction( costfunction), set(), { current: [None, None, 0] } fringe.push(current) while not fringe.isEmpty(): current = fringe.pop() # check if current is goal if problem.isGoalState(current): state = current # get current's parent and action required from dict actions, parent = [path[state][0]], path[state][1] # parent is None only at the starting state while parent is not None and path[parent][0] is not None: # append each action required and get an upper parent actions.append(path[parent][0]) parent = path[parent][1] # went backwards so actions should be parsed in reverse actions.reverse() return actions if current not in explored: explored.add(current) nearStates = problem.getSuccessors(current) for state in nearStates: child, direction, cost = state fringenodes = [node[2] for node in fringe.heap] if child not in explored and child not in fringenodes: # add child to dict with action required, parent and its path cost path[child] = [direction, current, costfunction(current)] # add child in priority queue with priority its path cost fringe.push(child) elif child in fringenodes: # child exists in fringe, another path is found with cost newcost # newcost is equal to the parent's cost plus the cost of the new action newcost = costfunction(current) # checks if child's cost in dict is greater than the new if path[child][2] > newcost: # replace the child's cost with the better newcost in dict and fringe path[child] = [direction, current, newcost] fringe.update(child, newcost) util.raiseNotDefined() return False
def aStarSearch(problem, heuristic=nullHeuristic): "Search the node that has the lowest combined cost and heuristic first." "*** YOUR CODE HERE ***" if(problem.isGoalState(problem.getStartState())): return ['Stop'] fila = util.PriorityQueueWithFunction(lambda x: x[2] + heuristic(x[0], problem)) final = None inicial = problem.getStartState() caminho = [] predecessores = {} visitados = {} visitados[inicial] = True fila.push((inicial, None, 0)) while fila.isEmpty() == False: aux = fila.pop() u = aux[0] if(problem.isGoalState(u)): final = aux break for adj in problem.getSuccessors(u): v = adj[0] if not(v in visitados): fila.push((adj[0], adj[1], aux[2]+adj[2])) visitados[v] = True if not(v in predecessores): predecessores[v] = aux it = final[0] caminho.insert(0, final[1]) while predecessores[it][0] != inicial: caminho.insert(0, predecessores[it][1]) it = predecessores[it][0] return caminho
def aStarSearch(self, startPosition, gameState, goalPositions, avoidPositions=[], returnPosition=False): """ This is Astar function which returns the path to the goal positons and avoiding the avoid positions """ walls = gameState.getWalls() walls = walls.asList() actions = [Directions.NORTH, Directions.SOUTH, Directions.EAST, Directions.WEST] actionVec = [Actions.directionToVector(action) for action in actions] actionVec = [tuple(int(number) for number in vector) for vector in actionVec] # Each node of the graph is stored as a tuple (Position, path, total cost)_ currentPos, currentPath, currentCost = startPosition, [], 0 # we use the priority queue with the implemented huesristic : sum of distances to goals and 100 times distance to avoid positon queue = util.PriorityQueueWithFunction(lambda x: x[2] + # Total cost so far (100) * self.getMazeDistance(startPosition, x[0]) if x[0] in avoidPositions else 0 + # Avoid enemy locations sum([self.getMazeDistance(x[0], Pos) for Pos in goalPositions])) # we put all visited locations in an open list visited = set([currentPos]) while currentPos not in goalPositions: possiblePos = [((currentPos[0] + vector[0], currentPos[1] + vector[1]), action) for vector, action in zip(actionVec, actions)] legalPositions = [(position, action) for position, action in possiblePos if position not in walls] for position, action in legalPositions: if position not in visited: visited.add(position) queue.push((position, currentPath + [action], currentCost + 1)) if len(queue.heap) == 0: return None else: currentPos, currentPath, currentCost = queue.pop() if returnPosition: return currentPath, currentPos else: return currentPath
def aStarSearch(problem, heuristic=nullHeuristic): """Search the node that has the lowest combined cost and heuristic first.""" # Closed nodes, initially empty astarClosed = [] # Frontier nodes, initialize with start State astarFrontier = util.PriorityQueueWithFunction( lambda state: state.getAccumulatedCost() + heuristic(state.getState(), problem) ) astarFrontier.push( SearchNode() .setState(problem.getStartState()) ) while True: # If Frontier is Empty -> return failure if astarFrontier.isEmpty(): goalState = None break # Pop Node from Frontier currentState = astarFrontier.pop() # If Node is goal state -> return Node if (problem.isGoalState(currentState.getState())): goalState = currentState break # If currentState was not already closed, add to closed and explore (add its successors to frontier) if currentState not in astarClosed: astarClosed.append(currentState) for successor in problem.getSuccessors(currentState.getState()): astarFrontier.push( SearchNode() .setState(successor[0]) .setAction(successor[1]) .setParent(currentState) .setAccumulatedCost(currentState.getAccumulatedCost() + successor[2]) ) # If there's a solution, return actions, otherwise exit if goalState: return getActionsFromGoalState(goalState) else: print("This problem is not solvable") exit(0)
def aStarSearch(grid, dictionary, heuristic=nullHeuristic, choiceMult=1, choiceMin=1): visited = [] # Swapped to dict for faster accessing sorter = util.PriorityQueueWithFunction(heuristic) sorter.push((grid, 0)) iterations = 0 times_visited = 0 while not sorter.isEmpty(): gridState, depth = sorter.pop() iterations += 1 #if iterations > 2: # break # print(f"iteration {iterations}: testing state at depth {depth} with grid:") # print(str(gridState)) if gridState in visited: times_visited += 1 continue visited.append(gridState) #print(f"Scanning {gridState}", end='\t') if gridState.isComplete() and gridState.isValid( dictionary ): # fine to test it this way since the python and statement will only test the second case if the first one is true #print("DONE") #h = hpy() #print(h.heap()) #print(f'Found same state {times_visited} times.') return gridState, iterations successors = gridState.getNextGridStates( dictionary, int(choiceMult * (depth + 1)) + choiceMin) random.shuffle(successors) #print(f"Expanding from {gridState}") for newState in successors: #print(newState) if newState.isValid(dictionary): sorter.push((newState, depth + 1)) else: del (newState) #del(gridState) #print(f'Found same state {times_visited} times.') return None, iterations
def aStarSearch(problem, heuristic=nullHeuristic): """Search the node that has the lowest combined cost and heuristic first.""" def priorityFunction(node): return heuristic(node[0], problem)+node[2] closed = [] fringe = util.PriorityQueueWithFunction(priorityFunction) fringe.push((problem.getStartState(),list(),0)) while not fringe.isEmpty(): node = fringe.pop() if problem.isGoalState(node[0]): return node[1] elif node[0] not in closed: closed.append(node[0]) for child_node in problem.getSuccessors(node[0]): temp_node = (child_node[0], node[1] + [child_node[1]], node[2] + child_node[2]) fringe.push(temp_node) return []
def uniformCostSearch(problem): "Search the node of least total cost first. " explored = set() frontier = util.PriorityQueueWithFunction(lambda node: node.pathCost) frontier.push(util.Node((problem.getStartState(), None, None))) while not frontier.isEmpty(): node = frontier.pop() state = node.state if problem.isGoalState(state): return node.getPath() if state in explored: continue explored.add(state) for successor in problem.getSuccessors(state): if successor[0] not in explored: frontier.push(util.Node(successor, node)) return []
def aStarSearch(problem, heuristic=nullHeuristic): "Search the node that has the lowest combined cost and heuristic first." "*** YOUR CODE HERE ***" def aStarHeuristic(item): position, direction, totalCost, parent = item return totalCost + heuristic( position, problem ) #combines actual cost of getting to node with cost of heuristic(manhatten) pQWF = util.PriorityQueueWithFunction(aStarHeuristic) return findGoal(problem, pQWF) "Bonus assignment: Adjust the getSuccessors() method in CrossroadSearchAgent class" "in searchAgents.py and test with:" "python pacman.py -l bigMaze -z .5 -p CrossroadSearchAgent -a fn=astar,heuristic=manhattanHeuristic "
def aStarSearch(problem, heuristic=nullHeuristic): """Search the node that has the lowest combined cost and heuristic first.""" "*** YOUR CODE HERE ***" def priority_func(path): act_cost_gn = problem.getCostOfActions(path[1]) est_cost_fn = heuristic(path[0], problem) return act_cost_gn + est_cost_fn frontier = util.PriorityQueueWithFunction( priority_func) # Priority Queue with priority function based on # cost of path. closed = set( ) # Initialize a visited set that contain the visited nodes during traversal. start = problem.getStartState() # Get the start state of agent. frontier.push((start, [])) # push the start state into the Priority Queue. return execute_common_search_logic(frontier, closed, problem)
def depthFirstSearch(problem): """ Search the deepest nodes in the search tree first. Your search algorithm needs to return a list of actions that reaches the goal. Make sure to implement a graph search algorithm. To get started, you might want to try some of these simple commands to understand the search problem that is being passed in: print "Start:", problem.getStartState() print "Is the start a goal?", problem.isGoalState(problem.getStartState()) print "Start's successors:", problem.getSuccessors(problem.getStartState()) """ "*** YOUR CODE HERE ***" fringeStrategy = util.PriorityQueueWithFunction(lambda x: -len(x[1])) return graphSearch(problem, fringeStrategy, nullHeuristic)
def aStarSearch(problem, heuristic=nullHeuristic): """Search the node that has the lowest combined cost and heuristic first.""" "*** YOUR CODE HERE ***" def pushByCostHeuristic(collection, element, heuristic=heuristic, problem=problem): fn = element[2] + heuristic(element[0], problem) collection.push(((element[0], element[1], element[2]), fn)) def priorityFunction(stateSpace): return stateSpace[1] collection = util.PriorityQueueWithFunction(priorityFunction) result = search(problem, collection, pushByCostHeuristic) return result
def closetPosition(fromPosition, positions): if len(positions) == 0: return None def fn((pos, dis)): return dis # let the PriorityQueueWithFunction do the sort options = util.PriorityQueueWithFunction(fn) for position in positions: # calc the cost euclidean_distance = euclideanDistance(fromPosition, position) # push with the cost options.push((position, euclidean_distance)) # get the top that is the lowest distance return options.pop()
def aStarSearch(problem, heuristic=nullHeuristic): """ Search the node that has the lowest combined cost and heuristic first. python pacman.py -l bigMaze -z .5 -p SearchAgent -a fn=astar,heuristic=manhattanHeuristic """ # TODO Problem 4: A*S """ For A* search, a Priority Queue is used as the container with a function that gets the cost of going through the route from the start state to the state of that node, as UCS, but also adds the Heuristic of the successor state. """ def cost_function(node): return problem.getCostOfActions(node[1]) + heuristic( node[0][0], problem) container = util.PriorityQueueWithFunction(cost_function) return search(problem, container)
def aStarSearch(problem, heuristic=nullHeuristic): """Search the node that has the lowest combined cost and heuristic first.""" "*** YOUR CODE HERE ***" start_state = problem.getStartState() pqueue = util.PriorityQueueWithFunction(lambda x: x[2]+heuristic(x[0],problem)) #same as UCS. Just added heuristic to pqueue.push((start_state, None, 0)) #cost to reach the state. So if x is that state cost = 0 #then x[2] is the cost to reach that state, and heuristic(state,problem) is the heuristic. visited = [] #Hint to Heuristic function parameters got from nullHeuristic function definition above path = [] parentSeq = {} parentSeq[(start_state, None, 0)] = None while pqueue.isEmpty() == False: current_fullstate = pqueue.pop() # print current_fullstate if (problem.isGoalState(current_fullstate[0])): break else: current_state = current_fullstate[0] if current_state not in visited: visited.append(current_state) else: continue successors = problem.getSuccessors(current_state) for state in successors: cost = current_fullstate[2] + state[2]; # print state,cost if state[0] not in visited: pqueue.push((state[0], state[1],cost)) # parentSeq[state] = current_fullstate parentSeq[(state[0], state[1])] = current_fullstate child = current_fullstate while (child != None): path.append(child[1]) if child[0] != start_state: child = parentSeq[(child[0], child[1])] else: child = None path.reverse() return path[1:] return [] util.raiseNotDefined()
def uniformCostSearch(problem): """Search the node of least total cost first.""" "*** YOUR CODE HERE ***" def priorityFunctionForUniformCostSearch(n): actions = [] for element in n: act = element[1] if act != "Stop": actions.append(act) totalCost = problem.getCostOfActions(actions) return totalCost open = util.PriorityQueueWithFunction(priorityFunctionForUniformCostSearch) open.push([(problem.getStartState(), "Stop", 0)]) visited = [] while not open.isEmpty(): n = open.pop() lastTuple = n[len(n) - 1] currentState = lastTuple[0] actions = [] if problem.isGoalState(currentState): actions = [] for element in n: act = element[1] if act != "Stop": actions.append(act) return actions if currentState not in visited: visited.append(currentState) successors = problem.getSuccessors(currentState) for state, action, cost in successors: if state not in visited: listOfSuccessors = [] for item in n: listOfSuccessors.append(item) listOfSuccessors.append((state, action, cost)) open.push(listOfSuccessors) return False
def aStarSearch(problem, heuristic=gpHeuristic): "Search the node that has the lowest combined cost and heuristic first." "*** YOUR CODE HERE ***" # f(x) = g(x) + h(x). f(x) is stored in the fringe. def costPlusHeuristic(node): g = node.getTotalCost() state = node.getState() h = heuristic(state, problem) return g + h fringe = util.PriorityQueueWithFunction( costPlusHeuristic) # stores NODES that we encounter firstNode = Node(state=problem.getStartState()) fringe.push(firstNode) explored = [] # stores STATES that have been explored while not fringe.isEmpty(): currentNode = fringe.pop() currentState = currentNode.getState() isNew = True # skip node if we have already explored it for e in explored: if len(currentState) == len(e) and all( [p in e for p in currentState]): isNew = False if isNew: # if at a goal state, backtrace parent nodes to get complete path taken to goal if problem.isGoalState(currentState): path = deque() while currentNode.getParent(): path.appendleft(currentNode.getPrevAction()) currentNode = currentNode.getParent() return path # if not at goal state, mark current state as explored and add successors to fringe else: explored.append(currentState) for successors in problem.getSuccessors(currentState): (successor, action) = (successors[0], successors[1]) node = Node(state=successor, parent=currentNode, prevAction=action, pathCost=1) fringe.push(node)
def aStarSearch(problem, heuristic=nullHeuristic): """Search the node that has the lowest combined cost and heuristic first.""" "*** YOUR CODE HERE ***" from game import Directions, Actions pacmanPriorityQueueWithFunction = util.PriorityQueueWithFunction(lambda x: x[2] + heuristic(x[0],problem)) positionList = {} positionListFinal = {} currentState = (problem.getStartState(),[],0) FoundGoal = problem.isGoalState(currentState[0]) pacmanPriorityQueueWithFunction.push(currentState) positionList[currentState[0]] = 0 while(FoundGoal != True): currentState = pacmanPriorityQueueWithFunction.pop() if(problem.isGoalState(currentState[0])): FoundGoal = True break succ = problem.getSuccessors(currentState[0]) for i in range(0,len(succ)): successor = succ[i][0] action = succ[i][1] totalPath = currentState[1] + [action] totalPathCost = heuristic(successor,problem) + problem.getCostOfActions(totalPath) if(not (successor in positionList)): pacmanPriorityQueueWithFunction.push((succ[i][0],totalPath,totalPathCost)) positionListFinal[successor] = (currentState[0],action) positionList[successor] = totalPathCost elif(totalPathCost < positionList[successor]): pacmanPriorityQueueWithFunction.push((successor,totalPath,totalPathCost)) positionList[successor] = totalPathCost positionListFinal[successor] = (currentState[0], action) endList = [] currentState = positionListFinal[currentState[0]] while(currentState[0] != problem.getStartState()): endList.insert(0,currentState[1]) currentState = positionListFinal[currentState[0]] endList.insert(0,currentState[1]) return endList
def aStarSearch(self, startPosition, gameState, goalPositions, avoidPositions=[], returnPosition=False): """ Finds the distance between the agent with the given index and its nearest goalPosition """ walls = gameState.getWalls() width = walls.width height = walls.height walls = walls.asList() actions = [Directions.NORTH, Directions.SOUTH, Directions.EAST, Directions.WEST] actionVectors = [Actions.directionToVector(action) for action in actions] # Change action vectors to integers so they work correctly with indexing actionVectors = [tuple(int(number) for number in vector) for vector in actionVectors] # Values are stored a 3-tuples, (Position, Path, TotalCost) currentPosition, currentPath, currentTotal = startPosition, [], 0 # Priority queue uses the maze distance between the entered point and its closest goal position to decide which comes first queue = util.PriorityQueueWithFunction(lambda entry: entry[2] + # Total cost so far width * height if entry[0] in avoidPositions else 0 + # Avoid enemy locations like the plague min(util.manhattanDistance(entry[0], endPosition) for endPosition in goalPositions)) # Keeps track of visited positions visited = set([currentPosition]) while currentPosition not in goalPositions: possiblePositions = [((currentPosition[0] + vector[0], currentPosition[1] + vector[1]), action) for vector, action in zip(actionVectors, actions)] legalPositions = [(position, action) for position, action in possiblePositions if position not in walls] for position, action in legalPositions: if position not in visited: visited.add(position) queue.push((position, currentPath + [action], currentTotal + 1)) # This shouldn't ever happen...But just in case... if len(queue.heap) == 0: return None else: currentPosition, currentPath, currentTotal = queue.pop() if returnPosition: return currentPath, currentPosition else: return currentPath
def aStarSearch(problem, heuristic=nullHeuristic): """ Searches the node that has the lowest combined cost and heuristic first. """ def sortingFn(path): """ Returns the cost of a path, that will ultimately be used to sort the Priority Queue. Computes cost function for a set of actions in a path combined with the heuristic estimate. """ actions = [action for _,action,_ in path][1:] # disregards first action STOP for the initial node cur_state,_,_ = path[-1] # State to use for determining heuristic return problem.getCostOfActions(actions) + heuristic(cur_state, problem) # Overall cost = Cost so far + heuristic priority_q = util.PriorityQueueWithFunction(sortingFn) # Initializes a PriorityQueue with a sorting key function return generalSearch(problem=problem, structure=priority_q)
def uniformCostSearch(problem): """ Searches the node of least total cost first. Employs a Priority Queue that takes a sorting function. The sorting function ensures nodes with least cost functions are visited first """ def sortingFn(path): """ Returns the cost of a path, that will ultimately be used to sort the Priority Queue. Computes cost function for a set of actions in a path. """ actions = [action for _,action,_ in path][1:] # disregards first action STOP for the initial node return problem.getCostOfActions(actions) priority_q = util.PriorityQueueWithFunction(sortingFn) # Initializes a PriorityQueue with a sorting key function return generalSearch(problem=problem, structure=priority_q)
def uniformCostSearch(problem): """ uniform cost function = cost of previous action """ # define costFunction def costFunction(tuState): return problem.getCostOfActions(tuState[1]) # create priority queue with cost function RoutePQ = util.PriorityQueueWithFunction(costFunction) # push initial state tuple:(position, list:Route) tuStart = problem.getStartState() RoutePQ.push((tuStart, [])) # call genericSearch with problem and data structure return genericSearch(problem, RoutePQ)