# CS 416 Artificial Intelligence Lecture 3 Uninformed Searches (mostly copied from Berkeley) Lecture 3 Uninformed Searches (mostly copied from Berkeley)

## Presentation on theme: "CS 416 Artificial Intelligence Lecture 3 Uninformed Searches (mostly copied from Berkeley) Lecture 3 Uninformed Searches (mostly copied from Berkeley)"— Presentation transcript:

CS 416 Artificial Intelligence Lecture 3 Uninformed Searches (mostly copied from Berkeley) Lecture 3 Uninformed Searches (mostly copied from Berkeley)

Outline Problem Solving Agents Restricted form of general agentRestricted form of general agent Problem Types Fully vs. partially observable, deterministic vs. stochasticFully vs. partially observable, deterministic vs. stochastic Problem Formulation State space, initial state, successor function, goal test, path costState space, initial state, successor function, goal test, path cost Example Problems Basic Search Algorithms Problem Solving Agents Restricted form of general agentRestricted form of general agent Problem Types Fully vs. partially observable, deterministic vs. stochasticFully vs. partially observable, deterministic vs. stochastic Problem Formulation State space, initial state, successor function, goal test, path costState space, initial state, successor function, goal test, path cost Example Problems Basic Search Algorithms

Problem Solving Agents Restricted form of general agent: function SIMPLE-PROBLEM-SOLVING-AGENT(percept) returns an action static: seq, an action sequence, initially empty static: seq, an action sequence, initially empty state, some description of the current world state state, some description of the current world state goal, a goal, initially null goal, a goal, initially null problem, a problem definition problem, a problem definition state <- UPDATE-STATE(state, percept) state <- UPDATE-STATE(state, percept) if seq is empty then if seq is empty then goal <- FORMULATE-GOAL(state) goal <- FORMULATE-GOAL(state) problem <- FORMULATE-PROBLEM(state, goal) problem <- FORMULATE-PROBLEM(state, goal) seq <- SEARCH(problem) seq <- SEARCH(problem) action <- RECOMMENDATION(seq, state) action <- RECOMMENDATION(seq, state) seq <- REMAINDER(seq, state) seq <- REMAINDER(seq, state) return action return action Note: This is offline problem solving; solution with “eyes closed.” Online problem solving involves acting without complete knowledge Restricted form of general agent: function SIMPLE-PROBLEM-SOLVING-AGENT(percept) returns an action static: seq, an action sequence, initially empty static: seq, an action sequence, initially empty state, some description of the current world state state, some description of the current world state goal, a goal, initially null goal, a goal, initially null problem, a problem definition problem, a problem definition state <- UPDATE-STATE(state, percept) state <- UPDATE-STATE(state, percept) if seq is empty then if seq is empty then goal <- FORMULATE-GOAL(state) goal <- FORMULATE-GOAL(state) problem <- FORMULATE-PROBLEM(state, goal) problem <- FORMULATE-PROBLEM(state, goal) seq <- SEARCH(problem) seq <- SEARCH(problem) action <- RECOMMENDATION(seq, state) action <- RECOMMENDATION(seq, state) seq <- REMAINDER(seq, state) seq <- REMAINDER(seq, state) return action return action Note: This is offline problem solving; solution with “eyes closed.” Online problem solving involves acting without complete knowledge

Example: Romania On holiday in Romania; currently in Arad. Flight leaves tomorrow from Bucharest. Formulate Goal: be in Bucharestbe in Bucharest Formulate Problem: states: various citiesstates: various cities actions: drive between cititesactions: drive between citites Find Solution: Sequence of cities, e.g., Arad, Sibiu, Fagaras, BucharestSequence of cities, e.g., Arad, Sibiu, Fagaras, Bucharest On holiday in Romania; currently in Arad. Flight leaves tomorrow from Bucharest. Formulate Goal: be in Bucharestbe in Bucharest Formulate Problem: states: various citiesstates: various cities actions: drive between cititesactions: drive between citites Find Solution: Sequence of cities, e.g., Arad, Sibiu, Fagaras, BucharestSequence of cities, e.g., Arad, Sibiu, Fagaras, Bucharest

Example: Romania

Problem Types Deterministic, fully observable  single-state problem Agent knows exactly what state it will be in; solution is a sequenceAgent knows exactly what state it will be in; solution is a sequence Non-observable  conformant problem Agent may have no idea where it is; solution (if any) is a sequenceAgent may have no idea where it is; solution (if any) is a sequence Non-deterministic and/or partially observable Percepts provide new information about current statePercepts provide new information about current state Solution is a tree or policySolution is a tree or policy Often interleave search, executionOften interleave search, execution Unknown state space  exploration problem (“online”) Deterministic, fully observable  single-state problem Agent knows exactly what state it will be in; solution is a sequenceAgent knows exactly what state it will be in; solution is a sequence Non-observable  conformant problem Agent may have no idea where it is; solution (if any) is a sequenceAgent may have no idea where it is; solution (if any) is a sequence Non-deterministic and/or partially observable Percepts provide new information about current statePercepts provide new information about current state Solution is a tree or policySolution is a tree or policy Often interleave search, executionOften interleave search, execution Unknown state space  exploration problem (“online”)

Example: Vacuum World Single-state, start in #5. Solution??Solution?? Single-state, start in #5. Solution??Solution??

Example: Vacuum World Single-state, start in #5. Solution: [Right, Suck]Solution: [Right, Suck] Conformant, start in {1,2,3,4,5,6,7,8} E.g., right goes to {2,4,6,8}E.g., right goes to {2,4,6,8} Solution??Solution?? Single-state, start in #5. Solution: [Right, Suck]Solution: [Right, Suck] Conformant, start in {1,2,3,4,5,6,7,8} E.g., right goes to {2,4,6,8}E.g., right goes to {2,4,6,8} Solution??Solution??

Example: Vacuum World Single-state, start in #5. Solution: [Right, Suck]Solution: [Right, Suck] Conformant, start in {1,2,3,4,5,6,7,8} E.g., right goes to {2,4,6,8}E.g., right goes to {2,4,6,8} Solution: [Right, Suck, Left, Suck]Solution: [Right, Suck, Left, Suck] Contingency, start in #5 Murphy’s Law: Suck can dirty a clean carpetMurphy’s Law: Suck can dirty a clean carpet Local sensing: dirt, location onlyLocal sensing: dirt, location only Solution??Solution?? Single-state, start in #5. Solution: [Right, Suck]Solution: [Right, Suck] Conformant, start in {1,2,3,4,5,6,7,8} E.g., right goes to {2,4,6,8}E.g., right goes to {2,4,6,8} Solution: [Right, Suck, Left, Suck]Solution: [Right, Suck, Left, Suck] Contingency, start in #5 Murphy’s Law: Suck can dirty a clean carpetMurphy’s Law: Suck can dirty a clean carpet Local sensing: dirt, location onlyLocal sensing: dirt, location only Solution??Solution??

Example: Vacuum World Single-state, start in #5. Solution: [Right, Suck]Solution: [Right, Suck] Conformant, start in {1,2,3,4,5,6,7,8} E.g., right goes to {2,4,6,8}E.g., right goes to {2,4,6,8} Solution: [Right, Suck, Left, Suck]Solution: [Right, Suck, Left, Suck] Contingency, start in #5 Murphy’s Law: Suck can dirty a clean carpetMurphy’s Law: Suck can dirty a clean carpet Local sensing: dirt, location onlyLocal sensing: dirt, location only Solution: [Right, if dirt then Suck]Solution: [Right, if dirt then Suck] Single-state, start in #5. Solution: [Right, Suck]Solution: [Right, Suck] Conformant, start in {1,2,3,4,5,6,7,8} E.g., right goes to {2,4,6,8}E.g., right goes to {2,4,6,8} Solution: [Right, Suck, Left, Suck]Solution: [Right, Suck, Left, Suck] Contingency, start in #5 Murphy’s Law: Suck can dirty a clean carpetMurphy’s Law: Suck can dirty a clean carpet Local sensing: dirt, location onlyLocal sensing: dirt, location only Solution: [Right, if dirt then Suck]Solution: [Right, if dirt then Suck]

State Space Real world is absurdly complex  state space must be abstracted for problem solving (Abstract) state = set of real states(Abstract) state = set of real states (Abstract) action = complex combination of real actions, e.g., “Arad  Zerind” represents a complex set of possible routes, detours, rest stops, etc.(Abstract) action = complex combination of real actions, e.g., “Arad  Zerind” represents a complex set of possible routes, detours, rest stops, etc. (Abstract) solution = set of real paths that are solutions in the real world(Abstract) solution = set of real paths that are solutions in the real world Each abstract action should be “easier” than the original problem! Real world is absurdly complex  state space must be abstracted for problem solving (Abstract) state = set of real states(Abstract) state = set of real states (Abstract) action = complex combination of real actions, e.g., “Arad  Zerind” represents a complex set of possible routes, detours, rest stops, etc.(Abstract) action = complex combination of real actions, e.g., “Arad  Zerind” represents a complex set of possible routes, detours, rest stops, etc. (Abstract) solution = set of real paths that are solutions in the real world(Abstract) solution = set of real paths that are solutions in the real world Each abstract action should be “easier” than the original problem!

Example: Vacuum World state space graph States? Actions? Goal test? Path cost?

Example: Vacuum World state space graph States: Integer dirt and robot locations (ignore dirt amounts)Integer dirt and robot locations (ignore dirt amounts)Actions: Left, Right, Suck, NoOpLeft, Right, Suck, NoOp Goal test: No dirtNo dirt Path cost: 1 per action (0 for NoOp)1 per action (0 for NoOp)States: Integer dirt and robot locations (ignore dirt amounts)Integer dirt and robot locations (ignore dirt amounts)Actions: Left, Right, Suck, NoOpLeft, Right, Suck, NoOp Goal test: No dirtNo dirt Path cost: 1 per action (0 for NoOp)1 per action (0 for NoOp)

Other Examples Eight puzzle Robotic Assembly States? Actions? Goal test? Path cost? Eight puzzle Robotic Assembly States? Actions? Goal test? Path cost?

Tree Search Algorithms Basic idea: Offline, simulated exploration of state space by generating successors of already explored states (AKA expanding states)Offline, simulated exploration of state space by generating successors of already explored states (AKA expanding states) function TREE-SEARCH(problem, strategy) returns a solution, or failure initialize the search tree using the initial state of problem initialize the search tree using the initial state of problem loop do loop do if there are no more candidates for expansion then return failure if there are no more candidates for expansion then return failure choose a leaf node for expansion according to strategy choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree else expand the node and add the resulting nodes to the search tree end end Basic idea: Offline, simulated exploration of state space by generating successors of already explored states (AKA expanding states)Offline, simulated exploration of state space by generating successors of already explored states (AKA expanding states) function TREE-SEARCH(problem, strategy) returns a solution, or failure initialize the search tree using the initial state of problem initialize the search tree using the initial state of problem loop do loop do if there are no more candidates for expansion then return failure if there are no more candidates for expansion then return failure choose a leaf node for expansion according to strategy choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree else expand the node and add the resulting nodes to the search tree end end

Implementation: states vs. nodes State (Representation of) a physical configureation(Representation of) a physical configureationNode Data structure constituting part of a search treeData structure constituting part of a search tree –Includes parent, children, depth, path cost g(x) States do not have parents, children, depth, or path cost! State (Representation of) a physical configureation(Representation of) a physical configureationNode Data structure constituting part of a search treeData structure constituting part of a search tree –Includes parent, children, depth, path cost g(x) States do not have parents, children, depth, or path cost!

Implementation: general tree search function TREE-SEARCH (problem, fringe) returns a solution, or failure fringe  INSERT(MAKE-NODE(INITIAL-STATE[problem]), fringe) fringe  INSERT(MAKE-NODE(INITIAL-STATE[problem]), fringe) loop do loop do if fringe is empty then return false if fringe is empty then return false node  REMOVE-FRONT(fringe) node  REMOVE-FRONT(fringe) if GOAL-TEST[problem] applied to STATE(node) succeeds return node if GOAL-TEST[problem] applied to STATE(node) succeeds return node fringe  INSERTALL(EXPAND(node, problem), fringe) fringe  INSERTALL(EXPAND(node, problem), fringe) function EXPAND (node, problem) returns a set of states successors  the empty set successors  the empty set for each action, result in SUCCESSOR-FN[problem](STATE[node]) do for each action, result in SUCCESSOR-FN[problem](STATE[node]) do s  a new NODE s  a new NODE PARENT-NODE[s]  node; ACTION[s]  action; STATE(s)  result PARENT-NODE[s]  node; ACTION[s]  action; STATE(s)  result PATH-COST[s]  PATH-COST[node] + STEP-COST(node, action, s) PATH-COST[s]  PATH-COST[node] + STEP-COST(node, action, s) DEPTH[s]  DEPTH[node] + 1 DEPTH[s]  DEPTH[node] + 1 add s to successors add s to successors return successors Find the error on this page! function TREE-SEARCH (problem, fringe) returns a solution, or failure fringe  INSERT(MAKE-NODE(INITIAL-STATE[problem]), fringe) fringe  INSERT(MAKE-NODE(INITIAL-STATE[problem]), fringe) loop do loop do if fringe is empty then return false if fringe is empty then return false node  REMOVE-FRONT(fringe) node  REMOVE-FRONT(fringe) if GOAL-TEST[problem] applied to STATE(node) succeeds return node if GOAL-TEST[problem] applied to STATE(node) succeeds return node fringe  INSERTALL(EXPAND(node, problem), fringe) fringe  INSERTALL(EXPAND(node, problem), fringe) function EXPAND (node, problem) returns a set of states successors  the empty set successors  the empty set for each action, result in SUCCESSOR-FN[problem](STATE[node]) do for each action, result in SUCCESSOR-FN[problem](STATE[node]) do s  a new NODE s  a new NODE PARENT-NODE[s]  node; ACTION[s]  action; STATE(s)  result PARENT-NODE[s]  node; ACTION[s]  action; STATE(s)  result PATH-COST[s]  PATH-COST[node] + STEP-COST(node, action, s) PATH-COST[s]  PATH-COST[node] + STEP-COST(node, action, s) DEPTH[s]  DEPTH[node] + 1 DEPTH[s]  DEPTH[node] + 1 add s to successors add s to successors return successors Find the error on this page!

Search strategies A strategy is defined by picking the order of node expansion Strategies are evaluated along the following dimensions: Completeness – does it always find a solution if one exists?Completeness – does it always find a solution if one exists? Time complexity – number of nodes generated/expandedTime complexity – number of nodes generated/expanded Space complexity – maximum nodes in memorySpace complexity – maximum nodes in memory Optimality – does it always find a least cost solution?Optimality – does it always find a least cost solution? Time and space complexity are measured in terms of: b – maximum branching factor of the search treeb – maximum branching factor of the search tree d – depth of the least-cost solutiond – depth of the least-cost solution m – maximum depth of the state space (may be infinite)m – maximum depth of the state space (may be infinite) A strategy is defined by picking the order of node expansion Strategies are evaluated along the following dimensions: Completeness – does it always find a solution if one exists?Completeness – does it always find a solution if one exists? Time complexity – number of nodes generated/expandedTime complexity – number of nodes generated/expanded Space complexity – maximum nodes in memorySpace complexity – maximum nodes in memory Optimality – does it always find a least cost solution?Optimality – does it always find a least cost solution? Time and space complexity are measured in terms of: b – maximum branching factor of the search treeb – maximum branching factor of the search tree d – depth of the least-cost solutiond – depth of the least-cost solution m – maximum depth of the state space (may be infinite)m – maximum depth of the state space (may be infinite)

Uninformed Search Strategies Uninformed strategies use only the information available in the problem definition Breadth-first searchBreadth-first search Uniform-cost searchUniform-cost search Depth-first searchDepth-first search Depth-limited searchDepth-limited search Iterative deepening searchIterative deepening search Uninformed strategies use only the information available in the problem definition Breadth-first searchBreadth-first search Uniform-cost searchUniform-cost search Depth-first searchDepth-first search Depth-limited searchDepth-limited search Iterative deepening searchIterative deepening search

Breadth-first search Expand shallowest unexpanded node Implementation: Fringe is a FIFO queue, i.e., new successors go at endFringe is a FIFO queue, i.e., new successors go at end Execute first few expansions of Arad to Bucharest using Breadth-first searchExecute first few expansions of Arad to Bucharest using Breadth-first search Expand shallowest unexpanded node Implementation: Fringe is a FIFO queue, i.e., new successors go at endFringe is a FIFO queue, i.e., new successors go at end Execute first few expansions of Arad to Bucharest using Breadth-first searchExecute first few expansions of Arad to Bucharest using Breadth-first search

Properties of breadth-first search Complete?? Yes (if b is finite) Time?? 1 + b + b 2 + … + b d + b(b d -1) = O(b d+1 ), i.e., exp in d Space?? O(b d+1 ) (keeps every node in memory) Optimal?? If cost = 1 per step, not optimal in general Space is the big problem; can easily generate nodes at 10 MB/s, so 24hrs = 860GB! Complete?? Yes (if b is finite) Time?? 1 + b + b 2 + … + b d + b(b d -1) = O(b d+1 ), i.e., exp in d Space?? O(b d+1 ) (keeps every node in memory) Optimal?? If cost = 1 per step, not optimal in general Space is the big problem; can easily generate nodes at 10 MB/s, so 24hrs = 860GB!

Uniform-cost search Expand least-cost unexpanded node Implementation: Fringe = queue ordered by path costFringe = queue ordered by path cost Equivalent to breadth-first if… Complete?? If step cost ≥ ε Time?? # of nodes with g ≤ cost of optimal solution, O(b C/ ε ), where C is the cost of the optimal solution Space?? # of nodes with g ≤ cost of optimal solution, O(b C/ ε ) Optimal?? Yes–nodes expanded in increasing order of g(n) Execute first few expansions of Arad to Bucharest using Uniform-first search Expand least-cost unexpanded node Implementation: Fringe = queue ordered by path costFringe = queue ordered by path cost Equivalent to breadth-first if… Complete?? If step cost ≥ ε Time?? # of nodes with g ≤ cost of optimal solution, O(b C/ ε ), where C is the cost of the optimal solution Space?? # of nodes with g ≤ cost of optimal solution, O(b C/ ε ) Optimal?? Yes–nodes expanded in increasing order of g(n) Execute first few expansions of Arad to Bucharest using Uniform-first search

Depth-first search Expand deepest unexpanded node Implementation: Fringe = LIFO queue, i.e., a stackFringe = LIFO queue, i.e., a stack Execute first few expansions of Arad to Bucharest using Depth-first searchExecute first few expansions of Arad to Bucharest using Depth-first search Expand deepest unexpanded node Implementation: Fringe = LIFO queue, i.e., a stackFringe = LIFO queue, i.e., a stack Execute first few expansions of Arad to Bucharest using Depth-first searchExecute first few expansions of Arad to Bucharest using Depth-first search

Depth-first search Complete??Time??Space??Optimal??Complete??Time??Space??Optimal??

Complete?? No: fails in infinite-depth spaces, spaces with loops.No: fails in infinite-depth spaces, spaces with loops. Can be modified to avoid repeated states along path  complete in finite spacesCan be modified to avoid repeated states along path  complete in finite spacesTime?? O(b m ) : terrible if m is much larger than d, but if solutions are dense, may be much faster than breadth-firstO(b m ) : terrible if m is much larger than d, but if solutions are dense, may be much faster than breadth-firstSpace?? O(bm), i.e., linear space!O(bm), i.e., linear space!Optimal?? NoNoComplete?? No: fails in infinite-depth spaces, spaces with loops.No: fails in infinite-depth spaces, spaces with loops. Can be modified to avoid repeated states along path  complete in finite spacesCan be modified to avoid repeated states along path  complete in finite spacesTime?? O(b m ) : terrible if m is much larger than d, but if solutions are dense, may be much faster than breadth-firstO(b m ) : terrible if m is much larger than d, but if solutions are dense, may be much faster than breadth-firstSpace?? O(bm), i.e., linear space!O(bm), i.e., linear space!Optimal?? NoNo

Depth-limited search Depth-first search with depth limit l i.e., nodes at depth l have no successorsi.e., nodes at depth l have no successors function DEPTH-LIMITED-SEARCH (problem, limit) returns soln/fail/cutoff RECURSIVE-DLS(MAKE-NODE(INITIAL-STATE[problem], problem, limit) RECURSIVE-DLS(MAKE-NODE(INITIAL-STATE[problem], problem, limit) function RECURSIVE-DLS (node, problem, limit) returns soln/fail/cutoff cutoff-occurred?  false cutoff-occurred?  false if GOAL-TEST[problem](STATE[node]) then return node if GOAL-TEST[problem](STATE[node]) then return node else if DEPTH[node] = limit then return cutoff else if DEPTH[node] = limit then return cutoff else for each successor in EXPAND(node, problem) do else for each successor in EXPAND(node, problem) do result  RECURSIVE-DLS(successor, problem, limit) result  RECURSIVE-DLS(successor, problem, limit) if result = cutoff then cutoff-occurred?  true if result = cutoff then cutoff-occurred?  true else if result ≠ failure then return result else if result ≠ failure then return result if cutoff-occurred? then return cutoff else return failure if cutoff-occurred? then return cutoff else return failure Depth-first search with depth limit l i.e., nodes at depth l have no successorsi.e., nodes at depth l have no successors function DEPTH-LIMITED-SEARCH (problem, limit) returns soln/fail/cutoff RECURSIVE-DLS(MAKE-NODE(INITIAL-STATE[problem], problem, limit) RECURSIVE-DLS(MAKE-NODE(INITIAL-STATE[problem], problem, limit) function RECURSIVE-DLS (node, problem, limit) returns soln/fail/cutoff cutoff-occurred?  false cutoff-occurred?  false if GOAL-TEST[problem](STATE[node]) then return node if GOAL-TEST[problem](STATE[node]) then return node else if DEPTH[node] = limit then return cutoff else if DEPTH[node] = limit then return cutoff else for each successor in EXPAND(node, problem) do else for each successor in EXPAND(node, problem) do result  RECURSIVE-DLS(successor, problem, limit) result  RECURSIVE-DLS(successor, problem, limit) if result = cutoff then cutoff-occurred?  true if result = cutoff then cutoff-occurred?  true else if result ≠ failure then return result else if result ≠ failure then return result if cutoff-occurred? then return cutoff else return failure if cutoff-occurred? then return cutoff else return failure

Depth-limited search Complete??Time??Space??Optimal??Complete??Time??Space??Optimal??

Iterative deepening search function ITERATIVE-DEEPENING-SEARCH(problem) returns a solution inputs: problem, a problem inputs: problem, a problem for depth  0 to ∞ do for depth  0 to ∞ do result  DEPTH-LIMITED-SEARCH(problem, depth) result  DEPTH-LIMITED-SEARCH(problem, depth) if result ≠ cutoff then return result if result ≠ cutoff then return result end end function ITERATIVE-DEEPENING-SEARCH(problem) returns a solution inputs: problem, a problem inputs: problem, a problem for depth  0 to ∞ do for depth  0 to ∞ do result  DEPTH-LIMITED-SEARCH(problem, depth) result  DEPTH-LIMITED-SEARCH(problem, depth) if result ≠ cutoff then return result if result ≠ cutoff then return result end end

Properties of iterative deepening Complete??Time??Space??Optimal??Complete??Time??Space??Optimal??

Complete?? YesYesTime?? (d+1)b 0 + db 1 + (d-1)b 2 + … b d = O(b d )(d+1)b 0 + db 1 + (d-1)b 2 + … b d = O(b d )Space?? O(bd)O(bd)Optimal?? If step cost = 1If step cost = 1 Can be modified to explore uniform-cost treeCan be modified to explore uniform-cost treeComplete?? YesYesTime?? (d+1)b 0 + db 1 + (d-1)b 2 + … b d = O(b d )(d+1)b 0 + db 1 + (d-1)b 2 + … b d = O(b d )Space?? O(bd)O(bd)Optimal?? If step cost = 1If step cost = 1 Can be modified to explore uniform-cost treeCan be modified to explore uniform-cost tree

Summary All tree searching techniques are more alike than different Breadth-first has space issues, and possibly optimality issues Uniform-cost has space issues Depth-first has time and optimality issues, and possibly completeness issues Depth-limited search has optimality and completeness issues Iterative deepening is the best uninformed search we have explored Next class we study informed searches All tree searching techniques are more alike than different Breadth-first has space issues, and possibly optimality issues Uniform-cost has space issues Depth-first has time and optimality issues, and possibly completeness issues Depth-limited search has optimality and completeness issues Iterative deepening is the best uninformed search we have explored Next class we study informed searches

Download ppt "CS 416 Artificial Intelligence Lecture 3 Uninformed Searches (mostly copied from Berkeley) Lecture 3 Uninformed Searches (mostly copied from Berkeley)"

Similar presentations