def find_immediate_common_ancestor_2(root, value1, value2): """find_immediate_common_ancestor_2 algorithm: in post-order, the stack holds all the parent node when find the first value, the parent list only shrink on the road to find the 2nd value. """ p, last_visited, immediate_ancestor = root, None, None #stack = Stack([], debug=True) stack = Stack([]) while p or stack: while p: stack.append(p) p = p.left p = stack[-1] if not p.right or p.right == last_visited: stack.pop() #^# if p.value in (value1, value2): if not immediate_ancestor: immediate_ancestor = stack[-1] else: return immediate_ancestor.value if p == immediate_ancestor: if stack: immediate_ancestor = stack[-1] #$# last_visited = p p = None else: p = p.right
def postorder_traverse_3(root): """postorder_traverse_3 algorithm: push/pop node to stack according to current node's state """ ns = [root, VISIT_LEFT] #(node, state) stack = Stack([], debug=True) while ns or stack: while ns: stack.append(ns) node, state = ns #ns[1] == VISIT_LEFT ns[1] = VISIT_RIGHT if node.left: ns = [node.left, VISIT_LEFT] else: ns = None ns = stack[-1] if ns[1] == VISIT_RIGHT: ns[1] = VISIT_SELF if ns[0].right: ns = [ns[0].right, VISIT_LEFT] else: ns = None elif ns[1] == VISIT_SELF: yield ns[0] stack.pop() ns = None
def postorder_traverse_4(root): """postorder_traverse_4 algorithm: improve postorder_traverse_3 based on the fact that if last visited node is current node's right child, then current node should be popped up """ stack = Stack([], debug=True) node = root last_visited = None while True: # push while node: stack.append(node) node = node.left if not stack: break # top/pop node = stack[-1] if not node.right or node.right == last_visited: node = stack.pop() yield node last_visited = node # prepare next node = None else: # prepare next node = node.right
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 ***" path = Stack() explored = [] def depthSearch(state): explored.append(state)#record that this node is explored if problem.isGoalState(state): #check if goal return True #return to the higher level of the "depthSearch" suc = problem.getSuccessors(state) #get a list of triples(successor, action, stepCost) #the successor is the next state #e.g. [((5, 4), 'South', 1), ((4, 5), 'West', 1)] # suc = [triple for triple in suc if not triple[0] in explored] # for triple in suc: # explored.append(triple[0]) for triple in suc: # for every triple(successor, action, stepCost) if explored.__contains__(triple[0]):#check if the state is searched continue if depthSearch(triple[0]): #the recursive path.push(triple[1]) # if the lower level return true, record the action return True # which means this level also has found goal state return False depthSearch(problem.getStartState()) #The first call route = [] while (not path.isEmpty()): action = path.pop() #print action route.append(action) #return a list of action return route
def depthFirstSearch(problem): successor_idx = {'dir': 1, 'state': 0, 'cost': -1} MAX_ITER = int(20000) stateStack = Stack() visitedSet = set() actionList = [] # add actions to get to the state, use pop to remove last one successorDict = {} curState = problem.getStartState() stateStack.push(curState) for it in range(MAX_ITER): if problem.isGoalState(curState): return actionList if curState not in visitedSet: successors = problem.getSuccessors(curState) successorDict[curState] = successors visitedSet.add(curState) nStateTuple = filter(lambda x: x[0] not in visitedSet, successorDict[curState]) # get next state if len(nStateTuple) == 0: stateStack.pop() actionList.pop() curState = stateStack.list[-1] else: curState = nStateTuple[0][successor_idx['state']] stateStack.push(curState) actionList.append(nStateTuple[0][successor_idx['dir']]) return []
def depthFirstSearch(problem): from collections import defaultdict from util import Stack initial_node=problem.getStartState() current_node=defaultdict(list) current_node[initial_node].append("No parent") current_node[initial_node].append("No direction") stack=Stack() stack.push(current_node) current_node=stack.pop() direction_list={} Child=current_node.keys() Parent=current_node.values()[0] visited_list={} while (problem.isGoalState(Child[0]) is not True): if(Child[0] in visited_list.keys()): current_node=stack.pop() Child=current_node.keys() Parent=current_node.values()[0] else: visited_list[Child[0]]=Parent[0] direction_list[Child[0]]=Parent[1] Successor_node=problem.getSuccessors(Child[0]) for index in range(len(Successor_node)): temp_dict=defaultdict(list) temp_dict[Successor_node[index][0]].append(Child[0]) temp_dict[Successor_node[index][0]].append(Successor_node[index][1]) #print"The temp dict values are",temp_dict stack.push(temp_dict) #print " The heap of queue is",priority_queue.heap current_node=stack.pop() #print "The current node is",current_node Child=current_node.keys() Parent=current_node.values()[0] visited_list[Child[0]]= Parent[0] direction_list[Child[0]]=Parent[1] backtracking =[] path = Child[0] backtracking.append(direction_list[path]) path = visited_list[path] print "The path is",path while (path!= problem.getStartState()): backtracking.append(direction_list[path]) path = visited_list[path] backtracking.reverse() return backtracking 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()) """ from util import Stack start = problem.getStartState() checkStack = Stack() checkStack.push((start,[])) visitedStates = [] while not checkStack.isEmpty(): popState, popDirection = checkStack.pop() for successors in problem.getSuccessors(popState): state, direction, cost = successors if not state in visitedStates: if problem.isGoalState(state): print state return popDirection + [direction] checkStack.push((state,popDirection+[direction])) visitedStates = visitedStates+[popState]
def depthFirstSearch(problem): stack = Stack(); parentNode = []; successors = []; visitedNodes = [] parentChildMapList = {} stack.push(problem.getStartState()) currentState = problem.getStartState() #need to remove while problem.isGoalState(currentState) is False and problem.isGoalState(currentState[0]) is False: if(currentState == problem.getStartState()): successors = problem.getSuccessors(currentState) visitedNodes.append(currentState) else: successors = problem.getSuccessors(currentState[0]) visitedNodes.append(currentState[0]) if successors != None and len(successors) > 0 : parentNode.append(currentState) for node in successors: if(visitedNodes.__contains__(node) == False and visitedNodes.__contains__(node[0]) == False): stack.push(node) parentChildMapList[node] = currentState tempCurrentNode = stack.pop() if(visitedNodes.__contains__(tempCurrentNode) == False and visitedNodes.__contains__(tempCurrentNode[0]) == False): currentState = tempCurrentNode else: currentState = stack.pop() validDirections = [] firstState = currentState while firstState != problem.getStartState(): validDirections.append(firstState[1]) firstState = parentChildMapList[firstState] validDirections.reverse() return validDirections util.raiseNotDefined()
def depthFirstSearch(problem): "Search the shallowest nodes in the search tree first. [p 81]" from util import Stack BFS1 = Stack() Moves = [] Visited = [] Final = [] NewState = (0, (problem.getStartState(), 'Start', 0)) #print CurrentState BFS1.push([NewState]) while not BFS1.isEmpty(): NewState = BFS1.pop() if problem.isGoalState(NewState[0][1][0]): Final = NewState break if Visited.count(NewState[0][1][0]) == 0: #print NewState for item in enumerate(problem.getSuccessors(NewState[0][1][0])): #print item BFS1.push([item] + NewState) Visited.append(NewState[0][1][0]) for nodes in Final: Moves.append(nodes[1][1]) Moves.reverse() Moves.remove('Start') #print Moves return Moves
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 frontier=Stack() start_node = Node(problem.getStartState(), step_cost=0) explored = [] frontier.push(start_node) while not frontier.isEmpty(): node = frontier.pop() explored.append(node.state) if problem.isGoalState(node.state): return node.getPath() for child in node.getChildren(problem): if not child.state in explored: frontier.push(child)
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()''' from util import Stack path=[] closedList=[] cost=0 fringe = Stack() node=[path, cost ,problem.getStartState()] fringe.push(node) while (1): if fringe.isEmpty(): raise Exception, 'no solutiion' newState=fringe.pop() if problem.isGoalState(newState[2]): return newState[0] if newState[2] not in closedList: closedList.append(newState[2]) for x in problem.getSuccessors(newState[2]): fringe.push([newState[0]+[str(x[1])],newState[1]+x[2],x[0]])
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()) """ frontier = Stack() # A helper stack of (state,route_to_state) explored_set = set() # A set of state recording the explored nodes start = problem.getStartState() frontier.push((start,list())) while not frontier.isEmpty(): current_node = frontier.pop() if problem.isGoalState(current_node[0]): return current_node[1] successors = problem.getSuccessors(current_node[0]) explored_set.add(current_node[0]) for s in successors: if s[0] not in explored_set: current_route = list(current_node[1]) current_route.append(s[1]) frontier.push((s[0],current_route)) print "No route found!" return list()
def getNodes(dsType, problem): if dsType == DataStructureType.STACK: from util import Stack nodes = Stack() nodes.push(Node([problem.getStartState()], [], 0, 0)) return nodes elif dsType == DataStructureType.QUEUE: from util import Queue nodes = Queue() nodes.push(Node([problem.getStartState()], [], 0, 0)) return nodes elif dsType == DataStructureType.PRIORITY_QUEUE: from util import PriorityQueue nodes = PriorityQueue() nodes.push(Node([problem.getStartState()], [], 0,0),0) return nodes
def find_immediate_common_ancestor(root, value1, value2): """find_immediate_common_ancestor algorithm: in post-order, the stack holds all the ancestor node. record the 2 ancestor lists and compare them. """ p = root #stack = Stack([], debug=True) stack = Stack([]) last_visited = None count_found = 0 while p or stack: while p: stack.append(p) p = p.left p = stack[-1] if not p.right or p.right == last_visited: stack.pop() #^# if p.value in (value1, value2): count_found += 1 if count_found == 1: parent_stack1 = stack[:] elif count_found == 2: common_idx = -1 min_len = len(stack) < len(parent_stack1) and len(stack) or len(parent_stack1) idx = 0 while idx < min_len: if stack[idx] == parent_stack1[idx]: common_idx = idx idx += 1 else: break return stack[common_idx].value #$# last_visited = p p = None else: p = p.right
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 #: lista de nodos visitados closed = [] #: pila que hace la funcion de frontera frontier = Stack() # Recogemos el primer estado, creamos un nodo y lo # insertamos en la pila frontier.push(Node(problem.getStartState())) # iteramos hasta que no hayan nodos en la pila # o hayamos encontrado el objetivo while not frontier.isEmpty(): #: siguiente nodo a expandir node = frontier.pop() # comprobamos si el estado actual nos cumple el objetivo if problem.isGoalState(node.state): # si lo cumple, salimos del bucle break if node.state not in closed: # insertamos el estado en la lista de visitados closed.append(node.state) # recuperamos los estados sucesores for successor in problem.getSuccessors(node.state): frontier.push(Node( successor[0], node, successor[1], successor[2])) #: acciones para llegar al objetivo actions = [] # recorremos mientras haya un action en el nodo previo while node.action: actions.append(node.action) node = node.previous #mostramos el resultado antes de devolverlo #print actions[::-1] return actions[::-1]
def inorder_traverse(root): """inorder traversal """ stack = Stack([], debug=True) node = root while True: # push while node: stack.append(node) node = node.left if len(stack) == 0: break # pop node = stack.pop() yield node # next node = node.right
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 ***" stateStack = Stack() state = problem.getStartState() state = [(state, "Stop", 0)] stateStack.push(state) while not problem.isGoalState(state[len(state) - 1][0]): state = stateStack.pop() successors = problem.getSuccessors(state[len(state) - 1][0]) for successor in successors: if successor[0] not in [position[0] for position in state]: stateStack.push(state + [successor]) return [direction[1] for direction in state]
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 ***" from util import Stack fringe = Stack() visited = set() path = Stack() start = problem.getStartState() visited.add(start) path.push(start) children = problem.getSuccessors(start) for child in children: fringe.push(child) ds = DFSRec(problem,fringe,visited,path) if ds != None: break pathToGoal = directions(ds) return pathToGoal
def find_immediate_common_ancestor_5(root, value1, value2): """find_immediate_common_ancestor_5 algorithm: pre-order traversal with value for each level """ if not root: return ancestor, immediate_ancestor_level = {}, -1 stack = Stack([(root, 0)]) while stack: p, level = stack.pop() #^# ancestor[level] = p if p.value in (value1, value2): if immediate_ancestor_level == -1: immediate_ancestor_level = level - 1 else: return ancestor[immediate_ancestor_level].value if immediate_ancestor_level > level - 1: immediate_ancestor_level = level - 1 #$# if p.right: stack.append((p.right, level+1)) if p.left: stack.append((p.left, level+1))
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 "the problem is ", problem from game import Directions s = Directions.SOUTH w = Directions.WEST n = Directions.NORTH e = Directions.EAST start = problem.getStartState() if problem.isGoalState(start): return [] from util import Stack statesStack = Stack() exploredSet = set([start]) tup = (start,[]) statesStack.push(tup) while not statesStack.isEmpty(): tup1 = statesStack.pop() state = tup1[0] path = tup1[1] if problem.isGoalState(state): return path successors = problem.getSuccessors(state) for succ in successors: coor = succ[0] move = succ[1] #cost = succ[2] tempPath = list(path) if not coor in exploredSet: exploredSet.add(coor) if move == 'North': tempPath.append(n) elif move == 'East': tempPath.append(e) elif move == 'South': tempPath.append(s) elif move == 'West': tempPath.append(w) statesStack.push((coor,tempPath)) return []
def depthFirstSearch(problem): """ Search the deepest nodes in the search tree first [p 74]. Your search algorithm needs to return a list of actions that reaches the goal. Make sure to implement a graph search algorithm [Fig. 3.18]. 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 currentState = problem.getStartState() setOfExploredNodes = set([currentState]) listofMoves = [] successorStack = Stack() while not isGoalState.problem(currentState): for successor in problem.getSuccessors(currentState): if successor[0] not in setOfExploredNodes: if problem.isGoalState(successor[0]): return listofMoves + [successor[1]] setOfExploredNodes.add(successor[0]) successorStack.push((successor[0], listofMoves + [successor[1]])) currentState = successorStack.pop() listofMoves = currentState[1] currentState = currentState[0] 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:""" loc_stack = Stack() visited_node = {} parent_child_map = {} direction_list = [] start_node = problem.getStartState() parent_child_map[start_node] = [] loc_stack.push(start_node) def traverse_path(parent_node): while True: map_row = parent_child_map[parent_node] if (len(map_row) == 2): parent_node = map_row[0] direction = map_row[1] direction_list.append(direction) else: break return direction_list while (loc_stack.isEmpty() == False): parent_node = loc_stack.pop() if (problem.isGoalState(parent_node)): pathlist = traverse_path(parent_node) pathlist.reverse() return pathlist elif (visited_node.has_key(parent_node) == False): visited_node[parent_node] = [] sucessor_list = problem.getSuccessors(parent_node) no_of_child = len(sucessor_list) if (no_of_child > 0): temp = 0 while (temp < no_of_child): child_nodes = sucessor_list[temp] child_state = child_nodes[0]; child_action = child_nodes[1]; if (visited_node.has_key(child_state) == False): loc_stack.push(child_state) parent_child_map[child_state] = [parent_node,child_action] temp = temp + 1
def __init__(self, game_state, n, blocks=None, position=None): self.ds = Stack() self.game_state = game_state self.position = position if position else self.game_state.getPacmanPosition() self.n = n ghosts = [search(GhostMovesProblem(round_tuple(ghost.getPosition()),ghost.scaredTimer, game_state, n)) for ghost in self.game_state.getGhostStates()] if blocks: self.blocks = blocks else: self.blocks = {} for i in range(n): self.blocks[i] = [] for gn in ghosts: self.blocks[i].extend([round_tuple(t) for t in gn[i]])
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 if problem.isGoalState(problem.getStartState()): return list() ##initialize the list of actions to return, frontier and explored set frontier = Stack() listOfActions = list() ##frontier includes the state and the list of actions to get to that state to construct the node frontier.push( [problem.getStartState(),listOfActions] ) explored = set() ##looping while the frontier is not empty while not(frontier.isEmpty()): ##pop one node off the frontier, check if it is the goal state node = frontier.pop() if problem.isGoalState(node[0]): return node[1] ##add the state to the explored set if it is not the goal state explored.add(node[0]) ##looping through current state's successor states for state,action,stepCost in problem.getSuccessors(node[0]): ##add the action needed from current state to next state onto the action list oldActions = list(node[1]) oldActions.append(action) nextNode = [state, oldActions] ##push the node onto the frontier if it is unexplored if(state not in explored): frontier.push(nextNode) return None
def depthFirstSearch(problem): from game import Directions from util import Stack South = Directions.SOUTH West = Directions.WEST East = Directions.EAST North = Directions.NORTH stop = Directions.STOP """ 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()) """ ans = [] ParentNode = {} direction = {} stack = Stack() startNode = problem.getStartState() visitedList = [] stack.push(startNode) if problem.isGoalState(startNode): return stop while stack.isEmpty() == False: currentNode = stack.pop() visitedList.append(currentNode) if problem.isGoalState(currentNode): goalPath = currentNode while goalPath != startNode: ans.append(direction[goalPath]) goalPath = ParentNode[goalPath] return ans[::-1] allCurrentSuccessor = problem.getSuccessors(currentNode) for Node in allCurrentSuccessor: if not Node[0] in visitedList: stack.push(Node[0]) ParentNode[Node[0]] = currentNode direction[Node[0]] = Node[1] return stop 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()) """ from util import Stack from game import Directions s = Directions.SOUTH w = Directions.WEST n = Directions.NORTH e = Directions.EAST opened = Stack() #create an open stack start = problem.getStartState() closed = set([start]) #create a closed list with the root node 1st entry if problem.isGoalState(start): #failsafe in case root is goal return [] opened.push((start, [])) while not opened.isEmpty(): tup2 = opened.pop() #remove 1st item from open stack state = tup2[0] direction = tup2[1] if problem.isGoalState(state): return direction children = problem.getSuccessors(state) #generate children for child in children: #name both the coordinates and direction position = child[0] direct = child[1] list_of_paths = list(direction) if not position in closed: #add to closed list (if not already there) closed.add(position) #list_of_paths.append(direction) if direct == 'North': list_of_paths.append(n) elif direct == 'East': list_of_paths.append(e) elif direct == 'South': list_of_paths.append(s) elif direct == 'West': list_of_paths.append(w) #keeps track of all directions traveled in dfs opened.push((position,list_of_paths)) #add children to stack return []
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()) """ from game import Directions from util import Stack n=Directions.NORTH s=Directions.SOUTH e=Directions.EAST w=Directions.WEST explored=[] frontier=Stack() frontierSet=[] start_node=problem.getStartState() if problem.isGoalState(start_node)==True: return [] frontier.push((start_node,[])) while frontier.isEmpty()==False: currentNode=frontier.pop() currentState=currentNode[0] actions=currentNode[1] if(problem.isGoalState(currentState)==True): return actions explored.extend(currentState) successors=problem.getSuccessors(currentState) for successor in successors: succState=successor[0] succAction=successor[1] if succState not in explored and succState not in frontierSet: frontierSet.append(succState) tempPath=list(actions) if(succAction=='North'): tempPath.append(n) elif(succAction=='East'): tempPath.append(e) elif(succAction=='South'): tempPath.append(s) elif(succAction=='West'): tempPath.append(w) frontier.push((succState,tempPath)) return []
def postorder_traverse_2(root): """postorder_traverse_2 algorithm: improve postorder_traverse by using 2 stacks and make the output in the rite order. """ stack1, stack2 = Stack([], debug=True), Stack([]) stack1.append(root) while stack1: p = stack1.pop() stack2.append(p) if p.left: stack1.append(p.left) if p.right: stack1.append(p.right) while stack2: p = stack2.pop() yield p
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 ***" from util import Stack Explored = {} Frontier = Stack() node = 0 current = problem.getStartState() Explored[current] = 1; succ = problem.getSuccessors(current) for k in succ: #print "initial push",k Frontier.push([k]); Explored[k[0]] = 1; while not (Frontier.isEmpty()): current = Frontier.pop() node = current[-1][0] #print "curr path and node",current,node,"explored status",(node in Explored),"\n" # check if done if (problem.isGoalState(node)): break succ = problem.getSuccessors(node) for k in succ: if not (k[0] in Explored): Frontier.push(current + [k]); Explored[k[0]] = 1; sol = [] #print current for k in current: sol += [k[1]] # print sol return sol
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 nodes = Stack() closed = dict() moves = list() for var in problem.getSuccessors(problem.getStartState()): state = FringeState(var[0]) state.moves.append(Directions.convToDirection(var[1])) nodes.push(state) closed[problem.getStartState()] = True while(False == nodes.isEmpty()): current_node = nodes.pop() #print "Current node:", current_node if(closed.has_key(current_node.pos)): continue if(problem.isGoalState(current_node.pos)): print "Goal reached!" moves = current_node.moves break for var in problem.getSuccessors(current_node.pos): state = FringeState(var[0]) state.moves= copy.deepcopy(current_node.moves) state.moves.append(Directions.convToDirection(var[1])) nodes.push(state) closed[current_node.pos] = True return moves
def dfs(self, starting_vertex, destination_vertex): """ Return a list containing a path from starting_vertex to destination_vertex in depth-first order. """ s = Stack() s.push([starting_vertex]) # Create a Set to store visited vertices visited = set() # While the queue is not empty... while s.size() > 0: # Dequeue the first PATH path = s.pop() # Grab the last vertex from the PATH s = path[-1] # If that vertex has not been visited... if s not in visited: # CHECK IF IT'S THE TARGET # IF SO, RETURN PATH if s == destination_vertex: return path # Mark it as visited... visited.add(s) # Then add A PATH TO its neighbors to the back of the queue # COPY THE PATH # APPEND THE NEIGHOR TO THE BACK for next_vert in self.get_neighbors(s): new_path = list(path) # Copy the list new_path.append(next_vert) s.push(new_path) # If we got here, we didn't find it return None
def dft(self, starting_vertex): # create a stack (DFT requires a stack) s = Stack() # push the starting index s.push(starting_vertex) # create a blank set to hold the nodes that have been visited visited = set() # run a loop while the stack still has items while s.size() > 0: # pop the first item and store it in a variable v = s.pop() # check if the node has already been visited or not if v not in visited: # if not, print it and # add it to the set print(v) visited.add(v) for next_vert in self.get_neighbors(v): # push new vertices for all the neighbors s.push(next_vert)
def dft(self, starting_vertex): """ Print each vertex in depth-first order beginning from starting_vertex. """ # Create empty set vertices = set() # Create empty Stack stack = Stack() stack.push(starting_vertex) # Iterate all the levels and identify the vertices while stack.size() > 0: vertex = stack.pop() # Check if node visited if vertex not in vertices: print(vertex) vertices.add(vertex) for next_vertex in self.vertices[vertex]: if next_vertex not in vertices: stack.push(next_vertex)
def dfs(self, starting_vertex, destination_vertex): """ Return a list containing a path from starting_vertex to destination_vertex in depth-first order. """ stack = Stack() visited = set() # while the queue is not empty stack.push([starting_vertex]) #create a set to store the visited vertices while stack.size() > 0: # dequeue the first path path = stack.pop() # grab the last index from the PATH vertex = path[-1] # check if the vertex has not been visited if vertex not in visited: # is this vertex the target? if vertex == destination_vertex: # return path return path # mark it as visited visited.add(vertex) # then add a path to its neighbors to the back of the queue for nextVertex in self.get_neighbors(vertex): # make a copy of the path pathCopy = list(path) # append a neighbor to the back of the path pathCopy.append(nextVertex) # enqueue out new path stack.push(pathCopy) # return none return None
def dft(self, starting_vertex): """ Print each vertex in depth-first order beginning from starting_vertex. """ # Create a queue/stack as appropriate stack = Stack() # Put the starting point in that stack.push(starting_vertex) # Make a set to keep track of where we've been visited = set() # While there is stuff in the queue/stack while stack.size() > 0: # Pop the first item vertex = stack.pop() # If not visited if vertex not in visited: # DO THE THING! print(vertex) visited.add(vertex) # For each edge in the item for next_vert in self.get_neighbors(vertex): # Add that edge to the queue/stack stack.push(next_vert)
def dfs(self, starting_vertex, destination_vertex): """ Return a list containing a path from starting_vertex to destination_vertex in depth-first order. """ # pass # TODO # create a stack s = Stack() # push a list holding the starting vertex id s.push([starting_vertex]) # created an empty visited set visited = set() # while the stack is not empty while s.size() > 0: # pop to the path vertex = s.pop() # set a vert to the last item in the path last_vertex = vertex[-1] # if vert is not in visited if last_vertex not in visited: # if vert is equal to target value if last_vertex == destination_vertex: # return path return vertex # add vert to visited set visited.add(last_vertex) # loop over next vert in vertices at the index of vert for next_vert in self.vertices[last_vertex]: # set a new path equal to a new list of the path (copy) path = list(vertex) # append next vert to new path path.append(next_vert) # push the new path s.push(path) return None
def dft(graph, starting_node): stack = Stack() stack.push((starting_node, 0)) visited = set() # could build a dictionary or set or # track two variables as we go visited_pairs = set() while stack.size() > 0: current_pair = stack.pop() visited_pairs.add(current_pair) current_node = current_pair[0] current_distance = current_pair[1] if current_node not in visited: visited.add(current_node) parents = graph.getNeighbors(current_node) for parent in parents: parent_distance = current_distance + 1 stack.push((parent, parent_distance)) longest_distance = 0 aged_one = -1 for pair in visited_pairs: node = pair[0] distance = pair[1] if distance > longest_distance: longest_distance = distance aged_one = node return aged_one
def build_traversal_path(player, room_graph): stack = Stack() stack.push((player.current_room.id, 'null')) visited = {} while stack.size() > 0: t = stack.pop() vertex = t[0] direction = t[1] if vertex not in visited: visited[vertex] = direction if direction != 'null': if player_can_move(player, direction, vertex) is not False: player.travel(direction) traversal_path.append(direction) else: path = find_path(player.current_room.id, vertex) walk_the_path(path, player) for i in room_graph[vertex][1]: stack.push((room_graph[vertex][1][i], i))
def dfs(self, starting_vertex, destination_vertex): """ Return a list containing a path from starting_vertex to destination_vertex in depth-first order. """ stack = Stack() visited = set() path = [starting_vertex] stack.push(path) while stack.size() > 0: path = stack.pop() vertex = path[-1] if vertex == destination_vertex: return path if vertex not in visited: visited.add(vertex) for neighbor in self.get_neighbors(vertex): new_path = path[:] new_path.append(neighbor) stack.push(new_path)
def dft(self, starting_vertex): """ Print each vertex in depth-first order beginning from starting_vertex. 1. create a stack and visted set 2. starting with starting node, push it 3. while there is items in stack, do the following 4. pop the first item 5. if not visited 6. list it in visted set 7. get all negiboring vertices 8. push all negiboring vertices 9. print the poped item """ s = Stack() visited = set() s.push(starting_vertex) while s.size() > 0: poped = s.pop() if poped not in visited: visited.add(poped) for each in self.get_neighbors(poped): s.push(each) print(poped)
def dft(self, starting_vertex): """ Print each vertex in depth-first order beginning from starting_vertex. Memorize: Create an empty stack and push the starting vertex ID Create an empty Set to store veisited vertices while the stack is not empty... Pop the first vertex If that vertex has not be visited... Mark it as visited Then push all of its neighbors to the top of the stack """ s = Stack() s.push(starting_vertex) visited = set() while s.size() > 0: v = s.pop() while v not in visited: print(v) visited.add(v) for next_vert in self.get_neighbors(v): s.push(next_vert)
def dft(self, starting_vertex): """ Print each vertex in depth-first order beginning from starting_vertex. """ # Create stack ss = Stack() # Add starting vertex to stack ss.push(starting_vertex) # Create empty set to hold items already visited visited = set() # While stack is not empty while ss.size() > 0: # Get next item from stack node = ss.pop() # Check if item has been visited already if node not in visited: # If not, print it print(node) # and add it to visited set visited.add(node) for next_node in self.get_neighbors(node): # Get neighbors of node and add them to the stack to iterate through next ss.push(next_node)
def earliest_ancestor(ancestors, starting_node): s = Stack() path = [[starting_node]] first = find_ancestors(starting_node, ancestors) # edge case: no ancestors if len(first) == 0: return -1 s.push(first) path.append(first) while s.size() > 0: cur = s.pop() for el in cur: nxt = find_ancestors(el, ancestors) if len(nxt) > 0: s.push(nxt) path.append(nxt) last = min(path[-1]) return last
def dfs(self, starting_vertex, destination_vertex): """ Return a list containing a path from starting_vertex to destination_vertex in depth-first order. """ # Create an empty stack and push A PATH TO the starting vertex ID s = Stack() s.push([starting_vertex]) # Create a Set to store visited vertices visited = set() # While the stack is not empty... while s.size() > 0: # Pop the first PATH path = s.pop() # Grab the last vertex from the PATH v = path[-1] # If that vertex has not been visited... if v not in visited: # Check if it's the target if v == destination_vertex: # If so, return PATH return path # Otherwise, else: # Mark it as visited visited.add(v) # Then add A PATH TO its neighbors to the top of the stack for next_vert in self.get_neighbors(v): # _COPY_ THE PATH path_copy = path.copy() # APPEND THE NEIGHOR TO THE BACK path_copy.append(next_vert) s.push(path_copy)
def dfs(self, starting_vertex, destination_vertex): """ Return a list containing a path from starting_vertex to destination_vertex in depth-first order. """ # create a stack s = Stack() # push a path to the starting vertex s.push([starting_vertex]) # create a set to store visited vertices visited = set() # while the stack is not empty while s.size() > 0: # pop off the first path path = s.pop() # grab the last vertex from the path v = path[-1] # check if it's been visited # if it hasn't been visited if v not in visited: # mark it as visited visited.add(v) # check if it's the targeted vertex if v == destination_vertex: # if it is, return the path return path # otherwise, push a path to all its neighbors # for each neighbor: for neighbor in self.get_neighbors(v): # make a copy of current path new_path = path.copy() # add neighbor to the end new_path.append(neighbor) # push the new path s.push(new_path)
def dft(self, starting_vertex): """ Print each vertex in depth-first order beginning from starting_vertex. """ # Create a stack s = Stack() # Push the starting vertex s.push(starting_vertex) # Create a set to store visited vertices visited = set() # while the stack is not empty... while s.size() > 0: # pop the first vertex v = s.pop() # Check if it's been visited # If it hasn't been visited... if v not in visited: # Mark it as visited print(v) visited.add(v) # push all it's neighbors onto the stack for neighbor in self.get_neighbors(v): s.push(neighbor)
def dfs(self, starting_vertex, destination_vertex, visited=set()): """ Return a list containing a path from starting_vertex to destination_vertex in depth-first order. """ stack = Stack() visited = set() stack.push([starting_vertex]) while stack.size() > 0: path = stack.pop() vert = path[-1] if vert not in visited: if vert == destination_vertex: return path visited.add(vert) for next_vert in self.vertices[vert]: new_path = list(path) new_path.append(next_vert) stack.push(new_path) return None
def dfs(self, starting_vertex, destination_vertex): """ Return a list containing a path from starting_vertex to destination_vertex in depth-first order. """ # refactoring bfs to use stack s = Stack() s.push([starting_vertex]) visited = set() while s.size() > 0: path = s.pop() last_vertex = path[-1] if last_vertex not in visited: if last_vertex == destination_vertex: return path visited.add(last_vertex) for n in self.get_neighbors(last_vertex): new_path = list(path) # copy the list new_path.append(n) s.push(new_path) return None
def dfs(self, starting_vertex, destination_vertex): """ Return a list containing a path from starting_vertex to destination_vertex in depth-first order. """ qq = Stack() visited = set() qq.push([starting_vertex]) while qq.size() > 0: path = qq.pop() print(f'path: {path}') vertex = path[-1] print(f'vertex: {vertex}') if vertex not in visited: if vertex == destination_vertex: return path visited.add(vertex) print(f'visited: {visited}') for next_vert in self.vertices[vertex]: new_path = list(path) #creates a deepcopy new_path.append(next_vert) qq.push(new_path)
def dfs(self, starting_vertex, destination_vertex): """ Return a list containing a path from starting_vertex to destination_vertex in depth-first order. """ stack = Stack() visited = set() stack.push([starting_vertex]) while stack.size() > 0: path = stack.pop() current_vertex = path[-1] if current_vertex == destination_vertex: return path if current_vertex not in visited: visited.add(current_vertex) neighbors = self.getNeighbors(current_vertex) for neighbor in neighbors: current_path = path[:] current_path.append(neighbor) stack.push(current_path) return []
def dft(self, starting_vertex): """ Print each vertex in depth-first order beginning from starting_vertex. """ # Create an empty stack and push the starting vertex ID stack = Stack() stack.push(starting_vertex) # Create an empty set to store visited vertices visited = set() # While the stack is not empty... while stack.size() > 0: # Pop the first vertex v = stack.pop() # If that vertex has not been visited... if v not in visited: # Mark it as visited print(v) visited.add(v) # Then add all of its neighbors to the top of the stack for neigbor in self.vertices[v]: # for neighbor in self.get_neighbors(vertex): stack.push(neigbor)
def earliest_ancestor(ancestors, starting_node): graph = Graph() for parent, child in ancestors: vertices = graph.vertices if parent not in vertices: graph.add_vertex(parent) if child not in vertices: graph.add_vertex(child) graph.add_edge(child, parent) s = Stack() s.push([starting_node]) longest = [starting_node] visited = set() oldest = -1 while s.size() > 0: path = s.pop() curr = path[-1] # breakpoint() if (len(path) > len(longest)) or (len(path) == len(longest) and curr < oldest): longest = path oldest = longest[-1] if curr not in visited: visited.add(curr) parents = graph.get_neighbors(curr) for parent in parents: new_path = path + [parent] s.push(new_path) return oldest
def dft(self, starting_vertex): """ Print each vertex in depth-first order beginning from starting_vertex. """ # create an empty stack and push the starting vertex id s = Stack() s.push(starting_vertex) # create a set to store our visited vertices visited = set() # while stack is not empty (len greater than 0) while s.size() > 0: # pop the first vertex v = s.pop() # if that vertex has not been visited if v not in visited: # mark as visited and print for debugging visited.add(v) print(v) # iterate over the child vertices of the current vertex for next_vertex in self.vertices[v]: # push the next vertex s.push(next_vertex)
def dfs(self, starting_vertex, destination_vertex): """ Return a list containing a path from starting_vertex to destination_vertex in depth-first order. """ s = Stack() visited = set() path = [starting_vertex] s.push(path) while s.size() > 0: curr_path = s.pop() curr = curr_path[-1] if curr == destination_vertex: return curr_path if curr not in visited: visited.add(curr) neighbors = self.get_neighbors(curr) for neighbor in neighbors: path_copy = curr_path[:] path_copy.append(neighbor) s.push(path_copy)
def dfs(self, starting_vertex, destination_vertex): # create a Stack (DFS requires a stack) # and push the starting vertex in a list (to keep track of the traveled path) # create a visited set to keep track of visited nodes s = Stack() s.push([starting_vertex]) visited = set() # while the stack still has items while s.size() > 0: # grab the first item in the stack path = s.pop() # and grab the vertex from the last index in the path vert = path[-1] # if the vertex hasn't been visited if vert not in visited: # if the vertex equals our destination value, # return the path, we have our answer if vert == destination_vertex: return path # else add the vertex to visited visited.add(vert) # loop through all remaining neighbors and # create a copy of the path, # append the new vertex for all neighbors to the path, # and push the new paths for next_vert in self.get_neighbors(vert): path_copy = list(path) path_copy.append(next_vert) s.push(path_copy) # if we get here, there was no path from start to destination return None
def earliest_ancestor2(ancestors, starting_node): #nodes -> people #edges -> when child has a parent #either bfs or dfs would work here graph = build_graph(ancestors) s = Stack() visited = set() s.push([starting_node]) longest_path = [starting_node] aged_one = -1 while s.size() > 0: path = s.pop() current_node = path[-1] # if path is longer, or path is equal but the id is smaller if (len(path) > len(longest_path)) or (len(path) == len(longest_path) and current_node < aged_one): longest_path = path aged_one = longest_path[-1] if current_node not in visited: visited.add(current_node) parents = graph.get_neighors(current_node) for parent in parents: new_path = path + [parent] s.push(new_path) return aged_one
def dfs(self, starting_vertex, destination_vertex): # Create an empty stack to_visit = Stack() # push A PATH TO the starting vertex ID to_visit.push([starting_vertex]) # Create a Set to store visited vertices visited = set() # While the queue is not empty... while to_visit.size() > 0: # Pop the first PATH v = to_visit.pop() # Grab the last vertex from the PATH v2 = v[-1] # If that vertex has not been visited... if v2 not in visited: # CHECK IF IT'S THE TARGET if v2 == destination_vertex: # IF SO, RETURN PATH return v # Mark it as visited... visited.add(v2) # Then add A PATH TO its neighbors to the back of the queue for neighbor in self.vertices[v2]: to_visit.push(v + [neighbor])
def dfs(self, starting_vertex, destination_vertex): """ Return a list containing a path from starting_vertex to destination_vertex in depth-first order. """ # Create a Stack ss = Stack() # Create a set of traversed/visited vertices visited = set() # Push a PATH to the starting vertex ss.push([starting_vertex]) # while the stack is not empty.. while ss.size() > 0: # Dequeue/pop the the first index/vertex path = ss.pop() # Grab the vertex from the end of the path last_vertex = path[-1] # Check if vertex (node) is visited, if not if last_vertex not in visited: # DO THE THING!! (search stop when you find something) print(last_vertex) # mark as visited visited.add(last_vertex) # enqueue/add a path to all it's neighbors if last_vertex == destination_vertex: return path for next_vert in self.get_neighbors(last_vertex): # Make a copy of the path # new_path = path.copy() new_path = list(path) # append/add all neighbors new_path.append(next_vert) # push the copy ss.push(new_path)
def dfs(starting_room, destination_room): stack = Stack() visited = set() stack.push([starting_room]) while stack.size() > 0: path = stack.pop() room = path[-1] if room not in visited: if room == destination_room: break visited.add(room) for next_room in list(traversal_graph[room].values()): if next_room != '?': n_path = list(path) n_path.append(next_room) stack.push(n_path) dirs = [] for i in range(len(path) - 1): for direction, room in traversal_graph[path[i]].items(): if room == path[i + 1]: dirs.append(direction) return dirs
def dft(self, starting_vertex): """ Print each vertex in depth-first order beginning from starting_vertex. """ # create a stack to hold the nodes to visit to_visit = Stack() # use this to hold visited nodes visited = set() # push the starting node to the stack to_visit.push(starting_vertex) # while the stack exists while to_visit.size() > 0: # pop the first value, hold it as "v" v = to_visit.pop() # if v isn't in the visited set if v not in visited: #print it print(v) # and add it to visited visited.add(v) # push all of it's neighbors for n in self.vertices[v]: to_visit.push(n)