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 ***" startState = problem.getStartState() visitedNodes = [] actions = [] fringe = util.Stack() cost = 0 if (problem.isGoalState(startState) == True ): #if startState is the goalState return actions else: # Data Type Format : (currentState,actions,cost) based on errors I got :\ fringe.push((startState, actions, cost)) while (fringe.isEmpty() == False): currentState, actions, cost = fringe.pop() if (problem.isGoalState(currentState)): return actions elif ((currentState in visitedNodes) == False): visitedNodes.append(currentState) currentNodeSuccessors = problem.getSuccessors(currentState) for node in currentNodeSuccessors: state, action, cost = node if ((state in visitedNodes) == False): newNode = (state, actions + [action], cost) fringe.push(newNode) util.raiseNotDefined()
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 ***" from util import Stack stack = util.Stack() visited = [] start_node = (problem.getStartState(), []) if problem.isGoalState(start_node): return [] stack.push(start_node) while not stack.isEmpty(): top = stack.pop() location = top[0] path = top[1] if location not in visited: visited.append(location) if problem.isGoalState(location): return path successors = problem.getSuccessors(location) if successors: for element in successors: if element[0] not in visited: new_path = path + [element[1]] stack.push((element[0], new_path)) return []
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()) """ frontier = util.Stack() visited = {} frontier.push(BSTNode((problem.getStartState(), 'Start', 0), None, [])) while not frontier.isEmpty(): current = frontier.pop() if problem.isGoalState(current.node[0]): directions = [] while current.node[1] != 'Start': directions.append(current.node[1]) current = current.parent directions = directions[::-1] return directions if not current.node[0] in visited: visited[current.node[0]] = current for successor in problem.getSuccessors(current.node[0]): successor = BSTNode(successor, current, []) if not successor.node[0] in visited: frontier.push(successor) current.children.append(successor)
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 ***" visit = [] actions = [] stack = util.Stack() begin_state = problem.getStartState() stack.push((begin_state, actions)) while not stack.isEmpty(): current_state, current_action = stack.pop() # Break if hit the goal state if problem.isGoalState(current_state): res = current_action break # Find all adjacents and push them into stack if current_state not in visit: visit.append(current_state) successors = problem.getSuccessors(current_state) for successor in successors: adjacent, action, _ = successor path = current_action + [action] stack.push((adjacent, path)) return res # print(res) util.raiseNotDefined()
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 ***" closedSet = set() dataStructure = util.Stack() path = [] pathTuple = () if "startState" in dir(problem): nodeCoordStartState = problem.startState pathTuple = ((nodeCoordStartState, "", 0), ) elif "getStartState" in dir(problem): nodeCoordStartState = problem.getStartState() pathTuple = ((nodeCoordStartState, "", 0), ) else: raise Exception("No recognizable function for getting the Start State") dataStructure.push(pathTuple) result = findSolution(problem, pathTuple, dataStructure, closedSet) if result is None: raise Exception("No solution exists!") path = getListOfActions(result) #print "[Final Path] [%s] with length %d" % (str(result), len(result)) #print "Path: %s with length %d" % (str(path), len(path)) return path
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()) print "Start:", problem.getStartState() print "Is the start a goal?", problem.isGoalState(problem.getStartState()) childs = problem.getSuccessors(problem.getStartState()) print "Start's successors:", childs firstChild = childs[0] print "second successors:", problem.getSuccessors(firstChild[0]) """ "*** YOUR CODE HERE ***" "Initiate primary variables" stack = util.Stack() current_position = problem.getStartState() visited = [] route = [] stack.push((current_position, route)) while not stack.isEmpty() and not problem.isGoalState(current_position): state, actions = stack.pop() visited.append(state) children = problem.getSuccessors(state) for child in children: coordinates = child[0] if not coordinates in visited: current_position = coordinates direction = child[1] stack.push((coordinates, actions + [direction])) return actions + [direction] util.raiseNotDefined()
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 ***" start = problem.getStartState() # print start; stack = util.Stack() visited = [] stack.push((start, [])) # print "Added to stack: ", start; while not stack.isEmpty(): currentNode, path = stack.pop() # print "Removed from stack ",currentNode; # print "path followng: ", path; #print currentNode,path #print currentNode,path,cost; if (problem.isGoalState(currentNode)): return path if (currentNode not in visited): visited.append(currentNode) # print "visited ",visited; for nextNode, nextPath, cost in problem.getSuccessors(currentNode): #cost not needed for dfs...ignore for now # print "nextNode", nextNode; if (nextNode not in visited): #print "path, nextpath",path,nextPath; stack.push((nextNode, path + [nextPath])) # print "Added to Stack: ",nextNode; util.raiseNotDefined()
def breadthFirstSearch(problem): """Search the shallowest nodes in the search tree first.""" isGoal = 0 #boolean-like item specifically for breaking the while loop once the goal is found p = [] #Holder for the final start = problem.getStartState() #obtaining the start current = util.Queue() current.push((start, [])) #A variable for the current state ar = [start ] #Set of all values checked specifically in the coordinates form c = util.Stack() #Holder for the order of directions layer = 0 #While loop to loop through the ways to go until we have the end while isGoal == 0: eck = set( ar ) #Putting the already chose values in a set so I can do "if _ in ar" without a loop reg = current.pop() wq = problem.isGoalState(reg[0]) if wq == 1: #Checks if we are in the goal state isGoal = 1 #sets so we can break the loop p = reg[1] #If it is not the goal node else: succ = problem.getSuccessors( reg[0]) #Get the successors from the current node #For loop to go through the successors and add them to the queue for i in range(0, len(succ)): ree = reg[1] #Holder for the current list of nodes visited if succ[i][ 0] in eck: #Checks if we have already been through this node layer = layer #Placeholder line so it will not do the stuff to get added else: #If not already checked w = succ[i][0] #Puts a variable w to be the coordinate current.push((w, ree + [succ[i][1]])) ar.append( succ[i][0] ) #Adds the coordinates to the checked coordinates list return p #Returns the list of directions
def graph_search_astar(problem, fringe): """Search through the successors of a problem to find a goal. The argument fringe should be an empty queue. If two paths reach a state, only use the best one. [Fig. 3.18]""" closed = {} path = [] parentMap = {} flipper = util.Stack() startofpac = problem.getStartState() for element in problem.getSuccessors(problem.getStartState()): fringe.push(element, 1) state, direction, cost = element parentMap[element] = problem.getStartState() while fringe: parent = fringe.pop() parent_state, direction, cost = parent print "parent:", parent if problem.isGoalState(parent_state): curr = parent previous = None while (curr in parentMap.keys()): flipper.push(curr) curr = parentMap[curr] previous = curr while not flipper.isEmpty(): state, direction, cost = flipper.pop() path.append(direction) return path if parent not in closed: closed[parent] = True children = problem.getSuccessors(parent_state) for child in children: fringe.push(child, util.manhattanDistance(child[0], (1, 1)) + util.manhattanDistance(parent[0], startofpac) ) #903-->big..304->med..345-->open..15->tiny if child not in parentMap: parentMap[child] = parent print child return None
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 ***" #util.raiseNotDefined() ## print "Start:", problem.getStartState() ## print "Is the start a goal?", problem.isGoalState(problem.getStartState()) ## print "Start's successors:", problem.getSuccessors(problem.getStartState()) explored = [] frontier = util.Stack() frontier.push((problem.getStartState(), [])) if problem.isGoalState(problem.getStartState()): return ['Stop'] while not frontier.isEmpty(): state = frontier.pop() if state[0] not in explored: explored.append(state[0]) if problem.isGoalState(state[0]): return state[1] for child in problem.getSuccessors(state[0]): if child[0] not in explored: frontier.push((child[0], state[1] + [child[1]])) return False
def depthFirstSearch(problem): """ Search the deepest nodes in the search tree first [p 85]. Your search algorithm needs to return a list of actions that reaches the goal. Make sure to implement a graph search algorithm [Fig. 3.7]. 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 ***" # Initialization search_stack = util.Stack() traversed = [] initial_state = problem.getStartState() # Push the starting state in the stack. search_stack.push((initial_state, [])) # While search_stack in the fringe of the present state is not empty, go on searching the goal. while search_stack: (state, move_dir) = search_stack.pop() if not state in traversed: # Avoid revisiting the same state. traversed.append(state) if problem.isGoalState(state): return move_dir # Return move_dir if goal is searched. children = problem.getSuccessors(state) # Get all child nodes of this state. for child in children: # child[0]: state of child, child[1]: action to get to the child. search_stack.push((child[0], move_dir + [child[1]])) return [] # Goal does not exist in the search_stack.
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()) util.raiseNotDefined() """ "*** YOUR CODE HERE ***" openList = util.Stack() closed = [] tracker = {} metadata = ((None, None, None), problem.getStartState()) currentstate = (problem.getStartState(), metadata) while not problem.isGoalState(currentstate[0]): parentstate = currentstate[0] if parentstate not in closed: closed.append(parentstate) tracker[parentstate] = (currentstate[1][1], currentstate[1][0][1]) for successors in problem.getSuccessors(parentstate): if successors not in closed: metadata = (successors, parentstate) openList.push((successors[0], metadata)) currentstate = openList.pop() tracker[currentstate[0]] = (currentstate[1][1], currentstate[1][0][1]) returnPath = [] state = currentstate[0] while state != problem.getStartState(): movement = tracker[state][1] returnPath.append(movement) state = tracker[state][0] returnPath.reverse() return returnPath
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()) """ initialPath = [] initialState = problem.getStartState() initialCost = 0 myNode = Node(initialPath, initialState, initialCost) if problem.isGoalState(myNode.getState()): return myNode.getPath() frontier = util.Stack() frontier.push(myNode) exploredSet = set([]) while 1: if frontier.isEmpty(): return [] node = frontier.pop() if problem.isGoalState(node.getState()): return node.getPath() exploredSet.add(node.getState()) for triple in problem.getSuccessors(node.getState()): action = triple[1] state = triple[0] cost = triple[2] path = (list)(node.getPath()) path.append(action) child = Node(path, state, cost) if child.getState() not in exploredSet: frontier.push(child) util.raiseNotDefined()
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 ***" import game succes = [] sucstack = util.Stack() hf = problem.getStartState() succ = (hf, 'Stop', 0) while (True): if (succ == 'return'): succes.pop() else: succes.append(succ) if (problem.isGoalState(succ[0])): break sucstack.push('return') for ss in problem.getSuccessors(succ[0]): flag = True for i in range(len(succes), 0, -1): if (ss[0] == succes[i - 1][0]): flag = False break if (flag): sucstack.push(ss) if (sucstack.isEmpty()): break succ = sucstack.pop() actions = [] for s in succes: actions.append(s[1]) return actions[1:]
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 ***" front = util.Stack() visited = list() pred = dict() # {successor: (predecessor, action)} goal = None front.push(problem.getStartState()) while not front.isEmpty(): node = front.pop() if problem.isGoalState(node): goal = node break visited.append(node) for succ in problem.getSuccessors(node): # successor is a tuple (nextState, action, cost) if succ[0] not in visited: front.push(succ[0]) pred[succ[0]] = (node, succ[1]) # backtrack to get the actions actions = [] if goal != None: node = goal while node != problem.getStartState(): actions.insert(0, pred[node][1]) node = pred[node][0] return actions
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: """ nodeInit = Node(problem=problem, stateCurrent=problem.getStartState()) if problem.isGoalState(nodeInit.nodeGetCurrentState()): return Solution(nodeInit) frontier = util.Stack() frontier.push(nodeInit) explored = set() while frontier.isEmpty() != True: currentNode = frontier.pop() if problem.isGoalState(currentNode.nodeGetCurrentState()): return Solution(currentNode) if currentNode.nodeGetCurrentState() not in explored: explored.add(currentNode.nodeGetCurrentState()) for successor in problem.getSuccessors( currentNode.nodeGetCurrentState()): childNode = Node(problem=problem, stateCurrent=successor[0], nodePrev=currentNode, action=successor[1]) if childNode.nodeGetCurrentState() not in explored: frontier.push(childNode) return None
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()) """ # We use Position Search problem instance. It's getSuccessors method returns state, action and cost. # Stack has LIFO. list.pop() pops the last element inserted into it. fringe = util.Stack() # A set to keep track of nodes visited. # Set() avoids duplicates thus abiding to principle of not visiting a node more than once in Graph search. nodes_expanded = set() # For DFS cost does not matter so we pass it as 1. # We initially push start state co-ordinates and empty list of directions onto stack. fringe.push((problem.getStartState(), [], 0)) # The loop executes until all the nodes are popped off the fringe. while not fringe.isEmpty(): state, actions, cost = fringe.pop() # We check if the dequeued(popped) node's state is equal to goal state.(Goal test). # If True we return the list of actions for the pacman to reach its goal state. if problem.isGoalState(state): return actions # If the node is already visited we do not push its successors onto fringe thus we avoid cycles in graph search. if state in nodes_expanded: continue # If the node is not visited we mark it as visited and we push its successors onto the fringe. nodes_expanded.add(state) for successor_state, successor_action, step_cost in problem.getSuccessors( state): fringe.push( (successor_state, actions + [successor_action], step_cost)) # Added as defensive mechanism. return []
def breadthFirstSearch(problem): """Search the shallowest nodes in the search tree first.""" "*** YOUR CODE HERE ***" # initialization state = problem.getStartState() visit = [] visit.append(state) road = [] unvisit = util.Queue() ans=util.Stack() end=[] # until meet goal while problem.isGoalState(state) != True: action = problem.getSuccessors(state) # memory unvisit points if len(action) > 0: for k in range(0, len(action)): unvisit.push([action[k][0], action[k][1], state]) #[now,path,parent] temp = unvisit.pop() # avoid walking backward while temp[0] in visit and problem.isGoalState(state) != True: temp = unvisit.pop() state=temp[0] road.append([temp[0],temp[1],temp[2]]) visit.append(state) # get one road k=road.pop() ans.push(k[1]) for n in range(len(road)): p=road.pop() if k[2]==p[0]: ans.push(p[1]) k=p while ans.isEmpty()!=True: end.append(ans.pop()) return end
def depthFirstSearch(problem): stack = util.Stack() stack.push([(problem.getStartState(), "Stop", 0)]) visited_nodes = [] while not stack.isEmpty(): path = stack.pop() current_state = path[-1][0] if problem.isGoalState(current_state): return [x[1] for x in path][1:] if current_state not in visited_nodes: visited_nodes.append(current_state) for next_node in problem.getSuccessors(current_state): next_node_path = path[:] next_node_path.append(next_node) stack.push(next_node_path) return False
def dfsMap(self, gameState, startState): searchProblem = PositionSearchProblem(gameState=gameState, startState=startState) startState = searchProblem.getStartState() stack = util.Stack() stack.push((startState, [])) closed = set() while not stack.isEmpty(): state, path = stack.pop() if state not in closed: closed.add(state) successors = searchProblem.getSuccessors(state) self.mapBySuccessor(gameState, state, successors) for s, a, c in successors: p = list(path) p.append(state) if s in closed and state != startState: if p[-2] != s: self.mapByVisited(s, p) else: stack.push((s, p))
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 ***" fringe = util.Stack() def addFringe(fringe, state, cost): fringe.push(state) return genericSearch(problem, fringe, addFringe)
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 ***" frontier = util.Stack() # Initialize the stack. 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 stack. return execute_common_search_logic(frontier, closed, problem)
def generalSearch(problem, fn): dataStructure = {'bfs': util.Queue(), 'dfs': util.Stack()} root = problem.getStartState() try: visited = set() fringe = dataStructure[fn] fringe.push((root, [], 0)) while not fringe.isEmpty(): location, path, cost = fringe.pop() if problem.isGoalState(location): # print path return path if location not in visited: visited.add(location) for x, y, z in problem.getSuccessors(location): if x not in visited: fringe.push((x, path + [y], z)) return [] except Exception as e: print e return []
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()) """ path ,exploredState,exploredPath =[],[],util.Stack() exploredState.append(problem.getStartState()) exploredPath,isGoal = dfsExplore(problem.getStartState(),exploredState,exploredPath,problem) while not exploredPath.isEmpty(): candidateAction = exploredPath.pop() if candidateAction: path.insert(0, candidateAction) return path
def depth_first_search(game, variable_selection, heuristic): """ Search the shallowest nodes in the search tree first. """ explored = set() stack = util.Stack() stack.push(game.get_initial_board()) while not stack.isEmpty(): current_board = stack.pop() yield current_board if game.is_goal_state(): yield current_board successor = get_successors(current_board) for next_board, next_path in successor: if next_board not in explored: stack.push(next_board) explored.add(current_board)
def depthFirstSearch(problem): """ Search the deepest nodes in the search tree first [2nd Edition: p 75, 3rd Edition: p 87] Your search algorithm needs to return a list of actions that reaches the goal. Make sure to implement a graph search algorithm [2nd Edition: Fig. 3.18, 3rd Edition: Fig 3.7]. 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 ***" #print "Start:", problem.getStartState() #print "Is the start a goal?", problem.isGoalState(problem.getStartState()) #print "Start's successors:", problem.getSuccessors(problem.getStartState()) return graph_search(problem, util.Stack(), add_to_fringe_fn)
def depthFirstSearch(problem): start = problem.getStartState() c = problem.getStartState() exploredState = [] exploredState.append(start) states = util.Stack() stateTuple = (start, []) states.push(stateTuple) while not states.isEmpty() and not problem.isGoalState(c): state, actions = states.pop() exploredState.append(state) successor = problem.getSuccessors(state) for i in successor: coordinates = i[0] if not coordinates in exploredState: c = i[0] direction = i[1] states.push((coordinates, actions + [direction])) return actions + [direction] util.raiseNotDefined()
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 ***" # initialize the fringe and expanded list fringe = util.Stack() return searchHelper(problem, fringe) "util.raiseNotDefined()"
def DFSLimited(problem, limit=70): nodo = problem.getStartState() frontera = util.Stack() frontera.push((nodo, [], 0)) cerrados = [] while (not frontera.isEmpty()): nodo, list_position, coste = frontera.pop() if (problem.isGoalState(nodo)): print(len(list_position)) return list_position if (nodo not in cerrados and coste < 75): cerrados.append(nodo) for success in problem.getSuccessors(nodo): if (success[0] not in cerrados): frontera.push((success[0], list_position + [success[1]], coste + success[2]))
def depthFirstSearch(problem): """Search the deepest nodes in the search tree first.""" #init closed = set() open = util.Stack() open.push((problem.getStartState(), [])) while not open.isEmpty(): state, actions = open.pop() if state in closed: continue if problem.isGoalState(state): print(actions) return actions closed.add(state) for successor, action, g in problem.getSuccessors(state): if successor not in closed: open.push((successor, actions + [action]))