def uniformCostSearch(problem): "Search the node of least total cost first. " fringe = util.PriorityQueue() paths = util.PriorityQueue() costs = util.PriorityQueue() discovered = [] fringe.push(problem.getStartState(), 0) paths.push([], 0) costs.push(0, 0) while not fringe.isEmpty(): current_state = fringe.pop() current_path = paths.pop() cost = costs.pop() discovered.append(current_state) if problem.isGoalState(current_state)==True: return current_path children = problem.getSuccessors(current_state) for successor in children: if successor[0] not in discovered: copy = current_path[:] copy.append(successor[1]) costs.push(successor[2] + cost, successor[2] + cost) paths.push(copy, successor[2] + cost) fringe.push(successor[0], successor[2] + cost) return None
def depthFirstSearch(problem): """ Search the nodes in the search tree with a depth-first search algorithm and returns the first accepted path to the goal. This is implemented with a graph search algorithm. Author - Shandheap Shanmuganathan """ # Uses two stacks to store the path to the state # as well as the state that should be discovered fringe = util.Stack() paths = util.Stack() discovered = [] fringe.push(problem.getStartState()) paths.push([]) # While there are states still to be explored while not fringe.isEmpty(): current_state = fringe.pop() current_path = paths.pop() discovered.append(current_state) # If the algorithm finds a goal, then it immediately # returns it if problem.isGoalState(current_state): return current_path children = problem.getSuccessors(current_state) for successor in children: if successor[0] not in discovered: copy = current_path[:] copy.append(successor[1]) paths.push(copy) fringe.push(successor[0]) return None
def breadthFirstSearch(problem): """ Search the shallowest nodes in the search tree first. """ fringe = util.Queue() paths = util.Queue() discovered = [] fringe.push(problem.getStartState()) paths.push([]) while not fringe.isEmpty(): current_state = fringe.pop() current_path = paths.pop() discovered.append(deepcopy(current_state)) if problem.isGoalState(current_state)==True: return current_path children = problem.getSuccessors(current_state) for successor in children: if successor[0] not in discovered: if type(successor[0][0]) == tuple and successor[0][0] in problem.corners: if problem.corners[problem.current_corner] == successor[0][0]: if problem.goal[problem.current_corner] == False: problem.goal[problem.current_corner] = True fringe = util.Queue() paths = util.Queue() problem.current_corner += 1 discovered.append(deepcopy(successor[0])) copy = current_path[:] copy.append(successor[1]) paths.push(copy) fringe.push(successor[0]) return None
def uniformCostSearch(problem): ''' Search the node of least total cost first and returns the shortest possible accepted path. This is implemented with a graph search algorithm. Author - Shandheap Shanmuganathan ''' fringe = util.PriorityQueue() paths = util.PriorityQueue() costs = util.PriorityQueue() discovered = [] fringe.push(problem.getStartState(), 0) paths.push([], 0) costs.push(0, 0) while not fringe.isEmpty(): current_state = fringe.pop() current_path = paths.pop() cost = costs.pop() discovered.append(current_state) if problem.isGoalState(current_state): return current_path children = problem.getSuccessors(current_state) for successor in children: if successor[0] not in discovered: copy = current_path[:] copy.append(successor[1]) costs.push(successor[2] + cost, successor[2] + cost) paths.push(copy, successor[2] + cost) fringe.push(successor[0], successor[2] + cost) return None
def copy_of(board): """ Returns a copy of a board """ copy = [] for row_num in range(10): row = [] for col_num in range(10): row.append(board[row_num][col_num]) copy.append(row) return copy
def aStarSearch(problem, heuristic = nullHeuristic): ''' Search the node that has the lowest combined cost and heuristic first. Implemented with a graph search algorithm. Uses nullHeuristic by default if no other heuristic is specified. Author - Shandheap Shanmuganathan ''' fringe = util.PriorityQueue() paths = util.PriorityQueue() aStarCosts = util.PriorityQueue() discovered = [] heuristicCost = heuristic(problem.getStartState(), problem) fringe.push(problem.getStartState(), heuristicCost) paths.push([], heuristicCost) aStarCosts.push(heuristicCost, heuristicCost) while not fringe.isEmpty(): current_state = fringe.pop() current_path = paths.pop() cost = aStarCosts.pop() while current_state in discovered: current_state = fringe.pop() current_path = paths.pop() cost = aStarCosts.pop() # Makes a deep copy so that the entry in list discovered # is not altered by changes to current_state discovered.append(deepcopy(current_state)) if problem.isGoalState(current_state): return current_path children = problem.getSuccessors(current_state) for successor in children: if successor[0] not in discovered: if type(successor[0][0]) == tuple and successor[0][0] in problem.corners: if problem.corners[problem.current_corner] == successor[0][0]: if problem.goal[problem.current_corner] == successor[0][0]: problem.goal[problem.current_corner] = True fringe = util.PriorityQueue() paths = util.PriorityQueue() aStarCosts = util.PriorityQueue() problem.current_corner += 1 copy = current_path[:] copy.append(successor[1]) heuristicCost = heuristic(successor[0], problem) aStarCosts.push(successor[2] + cost, successor[2] + cost + heuristicCost) paths.push(copy, successor[2] + cost + heuristicCost) fringe.push(successor[0], successor[2] + cost + heuristicCost) 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()) """ fringe = util.Stack() paths = util.Stack() discovered = [] fringe.push(problem.getStartState()) paths.push([]) while not fringe.isEmpty(): current_state = fringe.pop() current_path = paths.pop() discovered.append(current_state) if problem.isGoalState(current_state)==True: return current_path children = problem.getSuccessors(current_state) for successor in children: if successor[0] not in discovered: copy = current_path[:] copy.append(successor[1]) paths.push(copy) fringe.push(successor[0]) return None
def aStarSearch(problem, heuristic = nullHeuristic): "Search the node that has the lowest combined cost and heuristic first." fringe = util.PriorityQueue() paths = util.PriorityQueue() aStarCosts = util.PriorityQueue() discovered = [] heuristicCost = heuristic(problem.getStartState(), problem) fringe.push(problem.getStartState(), heuristicCost) paths.push([], heuristicCost) aStarCosts.push(heuristicCost, heuristicCost) while not fringe.isEmpty(): current_state = fringe.pop() current_path = paths.pop() cost = aStarCosts.pop() while current_state in discovered: current_state = fringe.pop() current_path = paths.pop() cost = aStarCosts.pop() discovered.append(deepcopy(current_state)) if problem.isGoalState(current_state)==True: return current_path children = problem.getSuccessors(current_state) for successor in children: if successor[0] not in discovered: if type(successor[0][0]) == tuple and successor[0][0] in problem.corners: if problem.corners[problem.current_corner] == successor[0][0]: if problem.goal[problem.current_corner] == successor[0][0]: problem.goal[problem.current_corner] = True fringe = util.PriorityQueue() paths = util.PriorityQueue() aStarCosts = util.PriorityQueue() problem.current_corner += 1 copy = current_path[:] copy.append(successor[1]) heuristicCost = heuristic(successor[0], problem) aStarCosts.push(successor[2] + cost, successor[2] + cost + heuristicCost) paths.push(copy, successor[2] + cost + heuristicCost) fringe.push(successor[0], successor[2] + cost + heuristicCost) return None
def breadthFirstSearch(problem): """ Search the shallowest nodes in the search tree first and returns the shortest possible accepted path. This is implemented with a graph search algorithm. Author - Shandheap Shanmuganathan """ fringe = util.Queue() paths = util.Queue() discovered = [] fringe.push(problem.getStartState()) paths.push([]) while not fringe.isEmpty(): current_state = fringe.pop() current_path = paths.pop() # Makes a deep copy so that the entry in list discovered # is not altered by changes to current_state discovered.append(deepcopy(current_state)) if problem.isGoalState(current_state): return current_path children = problem.getSuccessors(current_state) for successor in children: if successor[0] not in discovered: if type(successor[0][0]) == tuple and successor[0][0] in problem.corners: if problem.corners[problem.current_corner] == successor[0][0]: if problem.goal[problem.current_corner] == False: problem.goal[problem.current_corner] = True fringe = util.Queue() paths = util.Queue() problem.current_corner += 1 discovered.append(deepcopy(successor[0])) copy = current_path[:] copy.append(successor[1]) paths.push(copy) fringe.push(successor[0]) return None