From f7fb1976bc4d6222111bd61db51977145d02438f Mon Sep 17 00:00:00 2001 From: Eugene Wang Date: Mon, 22 Jan 2024 20:40:25 -0800 Subject: [PATCH 1/5] message --- search.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/search.py b/search.py index cd330bf..623a907 100644 --- a/search.py +++ b/search.py @@ -86,8 +86,13 @@ def depthFirstSearch(problem): print("Is the start a goal?", problem.isGoalState(problem.getStartState())) print("Start's successors:", problem.getSuccessors(problem.getStartState())) """ - "*** YOUR CODE HERE ***" - util.raiseNotDefined() + + #fringe = util.Stack() # stack that store all nodes that is waiting to be visited + #current = (problem.getStartState(), [], []) + #while not fringe.isEmpty(): + + + def breadthFirstSearch(problem): """Search the shallowest nodes in the search tree first.""" From eeb2eaf981e04f5307d1d8581926900a55b5f264 Mon Sep 17 00:00:00 2001 From: Eugene Wang Date: Wed, 24 Jan 2024 09:09:29 -0800 Subject: [PATCH 2/5] message --- search.py | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/search.py b/search.py index 623a907..ba8e40b 100644 --- a/search.py +++ b/search.py @@ -86,13 +86,24 @@ def depthFirstSearch(problem): print("Is the start a goal?", problem.isGoalState(problem.getStartState())) print("Start's successors:", problem.getSuccessors(problem.getStartState())) """ - - #fringe = util.Stack() # stack that store all nodes that is waiting to be visited - #current = (problem.getStartState(), [], []) - #while not fringe.isEmpty(): - + frontier = Stack() + visited = set() + + frontier.push((problem.getStartState(), [])) + while not frontier.isEmpty(): + node, path = frontier.pop() + if problem.isGoalState(node): + return path + if node not in visited: + visited.add(node) + for successor in problem.getSuccessors(node): + frontier.push((successor[0], path + [successor[1]])) + + return [] + + def breadthFirstSearch(problem): """Search the shallowest nodes in the search tree first.""" From 7a38d37590c36702c0cd4498dead4019a5ce07ef Mon Sep 17 00:00:00 2001 From: Eugene Wang Date: Wed, 24 Jan 2024 09:23:10 -0800 Subject: [PATCH 3/5] message --- search.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/search.py b/search.py index ba8e40b..4d41f4a 100644 --- a/search.py +++ b/search.py @@ -18,7 +18,7 @@ """ import util - +from util import Stack class SearchProblem: """ This class outlines the structure of a search problem, but doesn't implement @@ -100,8 +100,6 @@ def depthFirstSearch(problem): visited.add(node) for successor in problem.getSuccessors(node): frontier.push((successor[0], path + [successor[1]])) - - return [] From 725e2aff9d271fcf7de9eeab0fd2b4f7b530d452 Mon Sep 17 00:00:00 2001 From: Eugene Wang Date: Wed, 24 Jan 2024 09:29:30 -0800 Subject: [PATCH 4/5] latest update --- search.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/search.py b/search.py index 4d41f4a..54a0f3f 100644 --- a/search.py +++ b/search.py @@ -86,20 +86,20 @@ def depthFirstSearch(problem): print("Is the start a goal?", problem.isGoalState(problem.getStartState())) print("Start's successors:", problem.getSuccessors(problem.getStartState())) """ - frontier = Stack() + fringe = Stack() visited = set() - frontier.push((problem.getStartState(), [])) + fringe.push((problem.getStartState(), [])) - while not frontier.isEmpty(): - node, path = frontier.pop() + while not fringe.isEmpty(): + node, path = fringe.pop() if problem.isGoalState(node): return path if node not in visited: visited.add(node) for successor in problem.getSuccessors(node): - frontier.push((successor[0], path + [successor[1]])) + fringe.push((successor[0], path + [successor[1]])) From 141add4205a6cfcaeb7feb5cec0af7284be3accd Mon Sep 17 00:00:00 2001 From: Eugene Wang Date: Sun, 28 Jan 2024 14:52:59 -0800 Subject: [PATCH 5/5] updated --- search.py | 148 +++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 147 insertions(+), 1 deletion(-) diff --git a/search.py b/search.py index 54a0f3f..e2ce3f5 100644 --- a/search.py +++ b/search.py @@ -19,6 +19,7 @@ import util from util import Stack +from util import Queue class SearchProblem: """ This class outlines the structure of a search problem, but doesn't implement @@ -103,10 +104,155 @@ def depthFirstSearch(problem): + +# search.py +# --------- +# Licensing Information: You are free to use or extend these projects for +# educational purposes provided that (1) you do not distribute or publish +# solutions, (2) you retain this notice, and (3) you provide clear +# attribution to UC Berkeley, including a link to http://ai.berkeley.edu. +# +# Attribution Information: The Pacman AI projects were developed at UC Berkeley. +# The core projects and autograders were primarily created by John DeNero +# (denero@cs.berkeley.edu) and Dan Klein (klein@cs.berkeley.edu). +# Student side autograding was added by Brad Miller, Nick Hay, and +# Pieter Abbeel (pabbeel@cs.berkeley.edu). + + +""" +In search.py, you will implement generic search algorithms which are called by +Pacman agents (in searchAgents.py). + +# Abbreviations +bfs = breadthFirstSearch +dfs = depthFirstSearch +astar = aStarSearch +ucs = uniformCostSearch +""" + +import util + + +class SearchProblem: + """ + This class outlines the structure of a search problem, but doesn't implement + any of the methods (in object-oriented terminology: an abstract class). + + You do not need to change anything in this class, ever. + """ + + def getStartState(self): + """ + Returns the start state for the search problem. + """ + util.raiseNotDefined() + + def isGoalState(self, state): + """ + state: Search state + + Returns True if and only if the state is a valid goal state. + """ + util.raiseNotDefined() + + def getSuccessors(self, state): + """ + state: Search state + + For a given state, this should return a list of triples, (successor, + action, stepCost), where 'successor' is a successor to the current + state, 'action' is the action required to get there, and 'stepCost' is + the incremental cost of expanding to that successor. + """ + util.raiseNotDefined() + + def getCostOfActions(self, actions): + """ + actions: A list of actions to take + + This method returns the total cost of a particular sequence of actions. + The sequence must be composed of legal moves. + """ + util.raiseNotDefined() + + +def tinyMazeSearch(problem): + """ + Returns a sequence of moves that solves tinyMaze. For any other maze, the + sequence of moves will be incorrect, so only use this for tinyMaze. + """ + from game import Directions + s = Directions.SOUTH + w = Directions.WEST + return [s, s, w, s, w, w, s, w] + + +def depthFirstSearch(problem: SearchProblem): + """ + 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 = Stack() + visited = set() + + fringe.push((problem.getStartState(), [])) + + while not fringe.isEmpty(): + node, path = fringe.pop() + if problem.isGoalState(node): + return path + + if node not in visited: + visited.add(node) + for successor in problem.getSuccessors(node): + fringe.push((successor[0], path + [successor[1]])) + + + def breadthFirstSearch(problem): """Search the shallowest nodes in the search tree first.""" "*** YOUR CODE HERE ***" - util.raiseNotDefined() + from game import Directions, Actions + + queue = util.Queue() + visited = set() + actions = [] + # print(queue.isEmpty()) + print("Start:", problem.getStartState()) + print("Is the start a goal?", problem.isGoalState(problem.getStartState())) + print("Start's successors:", problem.getSuccessors(problem.getStartState())) + + # push root (starting position) + root = problem.getStartState() + queue.push(root) + + visited.add(root) + while not queue.isEmpty(): + current_node = queue.pop() + print("Visiting:", current_node) + + if (problem.isGoalState(current_node)): + print("Reached the goal") + break + + for paths in problem.getSuccessors(current_node): + path = paths[0] + if path not in visited: + visited.add(path) + queue.push(path) + print(actions) + return path + def uniformCostSearch(problem): """Search the node of least total cost first."""