def aStarSearch(problem, heuristic=nullHeuristic):
"""Search the node that has the lowest combined cost and heuristic first."""
"*** YOUR CODE HERE ***"
print("The problem is:", problem)
closed=[]
fringe=[]
state=problem.getStartState()
start_forward_Cost=searchAgents.manhattanHeuristic(state,problem)
fringe.append((state,[],start_forward_Cost))
# print("The min index is: ", popindex, "for the following item: ", fringe[popindex])
while fringe:
# print("The fringe is:", fringe)
minimum = min(fringe, key=lambda x: x[2])
popindex = fringe.index(minimum)
# print("The minimum value is apparently:", minimum, " and it has the index in fringe of: ", popindex)
node,actions,Back_Cost=fringe.pop(popindex)
# print("This is what we chose to pop:", node,actions,cost)
# input('')
if problem.isGoalState(node):
return actions
if node not in closed:
closed.append(node)
for child in problem.getSuccessors(node):
Forward_cost=searchAgents.manhattanHeuristic(child[0],problem)
fringe.append((child[0],actions+[child[1]],Back_Cost+Forward_cost+child[2]))
if not fringe:
print("the fringe is empty cuz")
def aStarSearch(problem, heuristic=nullHeuristic):
"""Search the node that has the lowest combined cost and heuristic first."""
"*** YOUR CODE HERE ***"
visited = dict() #keep on track of the visited nodes for astar algorithm
node = {} #node
node["parent"] = None
node["action"] = None
node["state"] = problem.getStartState()
node["cost"] = 0
frontier = util.PriorityQueue() #for astar frontier is priority queue
heuristicN = node["cost"] + searchAgents.manhattanHeuristic(
node["state"],
problem) #manattan heuristic *********************************
#heuristicN=1 # hn=1 heuristic *************** to change through heurictic functions plese toggle the comment symbol
frontier.push(node, heuristicN) # init frontier
while frontier:
node = frontier.pop() #returns node with least cost
if visited.has_key(node["state"]): #if exist in visited go to loop
continue
visited[node["state"]] = True #set visited true
if problem.isGoalState(node["state"]): #if goal break
break
for child in problem.getSuccessors(
node["state"]): #successor odes of currentnode
if not visited.has_key(
child[0]
): #if child not in visited add to visited as well as frotier
NodeChild = {}
NodeChild["parent"] = node
NodeChild["action"] = child[1]
NodeChild["state"] = child[0]
NodeChild["cost"] = node["cost"] + 1
heuristicN = node["cost"] + searchAgents.manhattanHeuristic(
node["state"], problem
) #manattan heuristic *********************************
#heuristicN=1 # hn=1 heuristic ******** to change through heurictic functions plese toggle the comment symbol
frontier.push(NodeChild, heuristicN)
actions = []
while node[
"action"] != None: #construct path by iterating through parents of goal state
actions.insert(0, node["action"])
node = node["parent"]
return actions
util.raiseNotDefined()
def getAction(self, state):
problem = PositionSearchProblem(
state) #Mapeia todos os estados do jogo
problem.goal = state.getPacmanPosition(
) #Mapeia o estado atual do pacman
problem.startState = state.getGhostPosition(
self.index) #Mapeia o estado atual do objeto do fantasma
frontier = util.PriorityQueue() #Cria uma fila de prioridade
frontier.push(
problem.getStartState(),
manhattanHeuristic(problem.getStartState(),
problem)) #coloca na heap o primeiro estado
explored = [] #Nos expandidos
paths = {} #Todos os estados que foram percorridos
totalCost = {} #Custo total
paths[problem.getStartState()] = list()
totalCost[problem.getStartState()] = 0
def isBestCostforState(cost, state):
for n in frontier.heap:
if n[1] == state:
if (n[1] in totalCost.keys()) and (totalCost[n[1]] > cost):
frontier.heap.remove(n)
return True
else:
return False
return True
while not frontier.isEmpty():
s = frontier.pop()
if problem.isGoalState(s):
return paths.popitem()[1][0]
explored.append(s)
successors = problem.getSuccessors(s)
for successor in successors:
successorState = successor[0]
move = successor[1]
cost = successor[2]
if (successorState not in explored and isBestCostforState(
totalCost[s] + cost, successorState)):
paths[successorState] = list(paths[s]) + [move]
totalCost[successorState] = totalCost[s] + cost
frontier.push(
successorState,
manhattanHeuristic(successorState, problem) +
totalCost[successorState])
return []
def searchF(route, g, threshold, problem):
currState = route.pop()
route.push(currState) #only make sure there is at least node in the stack
node, action, cost, path = currState
f = g + searchAgents.manhattanHeuristic(node,problem)
if f > threshold:
# in idaStarSearch, this larger f would become the new threshold
return f
if problem.isGoalState(node):
return FOUND
succStates = problem.getSuccessors(node)
min = float("inf")
for succState in succStates: #find the smallerst f cost of children
#recursive call with next node as current node for depth search
if True: #no cycle check here
succNode, succAction, succCost = succState
newstate = (succNode, succAction, cost + succCost, path + [(node, action)])
route.push(newstate)
temp = searchF(route, g+1, threshold, problem) #cost between node is 1
# searchF will continu to explore to the deeper of this branch.
# searchF will stop goind deeper when f>threshold is found
if (temp == FOUND):
return FOUND
if (temp < min):
min = temp
route.pop() #Due to FIFO, there will be only on node left eventually
return min
def nullHeuristic(state, problem=None):
"""
A heuristic function estimates the cost from the current state to the nearest
goal in the provided SearchProblem. This heuristic is trivial.
"""
from searchAgents import manhattanHeuristic
return manhattanHeuristic(state, problem)
def aStarSearch(problem, heuristic=nullHeuristic):
"Search the node that has the lowest combined cost and heuristic first."
"*** YOUR CODE HERE ***"
#util.raiseNotDefined()
#util.raiseNotDefined()
node = ((problem.getStartState(),'',0),[],0)
explored = []
path = []
fringe = []
fringe.append(node)
while (not problem.isGoalState(node[0][0])):
for i in problem.getSuccessors(node[0][0]):
if i[0] not in explored:
tmpPath = node[1][:]
tmpPath.append(i[1])
fringe.append(((i), tmpPath,node[2]+i[2]))
fringe = sorted(fringe, key=lambda fringe:( fringe[0][2] + searchAgents.manhattanHeuristic(fringe[0][0],problem)))
explored.append(node[0][0])
fringe.remove(node)
if len(fringe) == 0:
break
node = fringe[0]
return node[1]
def nullHeuristic(state, problem=None): """ A heuristic function estimates the cost from the current state to the nearest goal in the provided SearchProblem. This heuristic is trivial. """ from searchAgents import manhattanHeuristic return manhattanHeuristic(state,problem)
def improve(state0,problem):
node0, action0, cost0, path0 = state0
myQueue = util.Queue()
myQueue.push(state0)
visited = set()
while not myQueue.isEmpty():
popState = myQueue.pop()
node, action, cost, path = popState
if node not in visited:
visited.add(node)
if searchAgents.manhattanHeuristic(node,problem) < searchAgents.manhattanHeuristic(node0,problem):
return popState #return the current state to be the new startState for ehc
succStates = problem.getSuccessors(node)
for succState in succStates:
succNode, succAction, succCost = succState
newstate = (succNode, succAction, cost + succCost, path + [(node, action)])
myQueue.push(newstate)
return popState
def aStarSearch(problem, heuristic=nullHeuristic):
"""Search the node that has the lowest combined cost and heuristic first."""
"*** YOUR CODE HERE ***"
from searchAgents import manhattanHeuristic
import re
closed = []
from util import PriorityQueue
fringe = PriorityQueue()
fringe.push((problem.getStartState(), [], 1.0), 0)
print fringe.isEmpty()
result = []
"print type(fringe)"
while (fringe.isEmpty() == False):
node = fringe.pop()
#print
#print node
x = node[0]
if x == (5, 1, [((1, 1), False), ((1, 12), False), ((28, 1), False),
((28, 12), False)]):
#print "Here",x
result = aStarSearch1(problem)
return result
result = node[1]
cost = node[2]
if problem.isGoalState(node[0]):
return result
if node[0] not in closed:
"""
print "Inloop",node[0]
print type(node[1])
print result
print node[1]
print result
"""
closed.append(node[0])
temp = problem.getSuccessors(node[0])
#print temp
#print cost
for child_node in temp:
if (type(node[0]) == tuple):
h = manhattanHeuristic(child_node[0], problem)
else:
h = nullHeuristic(child_node, node, problem)
fringe.push((child_node[0], result + [child_node[1]],
child_node[2] + cost), child_node[2] + cost + h)
return []
util.raiseNotDefined()
def idaStarSearch(problem, heuristic=nullHeuristic):
"""COMP90054 your solution to part 2 here """
startState = (problem.getStartState(), '', 0, [])
threshold = searchAgents.manhattanHeuristic(startState[0],problem)
route = util.Stack()
route.push(startState)
while True:
temp = searchF(route,0,threshold,problem) #at first state, the g is 0
if temp == FOUND:
finalState = route.pop()
fnode, faction, fcost, fpath = finalState
fpath = fpath + [(fnode, faction)]
actions = [faction[1] for faction in fpath]
del actions[0]
return actions
if temp == float("inf"):
return Fail
threshold = temp
def aStarSearch(problem, heuristic=nullHeuristic):
"""Search the node that has the lowest combined cost and heuristic first."""
"*** YOUR CODE HERE ***"
visited = dict()
node = {}
node["parent"] = None
node["action"] = None
node["state"] = problem.getStartState()
node["cost"] = 0
frontier = util.PriorityQueue()
heuristicN = node["cost"] + searchAgents.manhattanHeuristic(
node["state"], problem)
heuristicN = 1
frontier.push(node, heuristicN)
while frontier:
node = frontier.pop()
if visited.has_key(node["state"]):
continue
visited[node["state"]] = True
if problem.isGoalState(node["state"]):
break
for child in problem.getSuccessors(node["state"]):
if not visited.has_key(child[0]):
NodeChild = {}
NodeChild["parent"] = node
NodeChild["action"] = child[1]
NodeChild["state"] = child[0]
NodeChild["cost"] = node["cost"] + 1
#heuristicN = node["cost"] + searchAgents.manhattanHeuristic(node["state"], problem)
heuristicN = 1
frontier.push(NodeChild, heuristicN)
actions = []
while node["action"] != None:
actions.insert(0, node["action"])
node = node["parent"]
return actions
util.raiseNotDefined()
def manhattanHeuristic(state, problem):
"""
A heuristic function estimates the cost from the current state to the nearest
goal in the provided SearchProblem. Using the manhattan distance betwen this 2 points
"""
return searchAgents.manhattanHeuristic(state, problem)
def __init__(self, path, dad, action):
self.path = path
self.dad = dad
self.action = action
self.cost = manhattanHeuristic(path, problem.goal)
def manhattanHeuristic(state, problem):
"""
A heuristic function estimates the cost from the current state to the nearest
goal in the provided SearchProblem. Using the manhattan distance betwen this 2 points
"""
return searchAgents.manhattanHeuristic(state, problem)
