CS 436 - Oct 18 Lecture Uninformed Search

Tree Search

• lisp code

  "Expand nodes according to the specification of PROBLEM until we find a solution or run out of nodes to expand. The QUEUING-FN decides which nodes to look at first. [p 73]" defun general-search (problem queuing-fn) (let ((nodes (make-initial-queue problem queuing-fn)) node) (loop (if (empty-queue? nodes) (RETURN nil)) (setq node (remove-front nodes)) (if (goal-test problem (node-state node)) (RETURN node)) (funcall queuing-fn nodes (expand node problem)))))

Breadth First Search

• Tree Search + FIFO (Queue)
• lisp code

  "Search the shallowest nodes in the search tree first. [p 74]" (defun breadth-first-search (problem) (general-search problem #'enqueue-at-end))

• BFS Applet
• Time Complexity
  b + b² + b³ + .. + b^d + (b^d+1-b)
• Space Complexity
  every node stays in memory - same as time complexity

Depth First Search

• Tree Search + LIFO (Stack)
• lisp code

  "Search the deepest nodes in the search tree first. [p 78]" (defun depth-first-search (problem) (general-search problem #'enqueue-at-front))

• DFS Applet
• Time Complexity
  taverse every node in tree - exponential time O(b^m)
• Space Complexity
  Modest - memory for each node in current path + each node's siblings
  O(bm)

Depth-Limited Search

• Tree Search + LIFO (Stack) + Depth Limit
• Pseudo Code

  "Search depth-first, but only up to LIMIT branches deep in the tree." Push(S, Start State) Loop If S is empty, exit with failure C <-- Pop(S) If C is a goal state, exit and return C If Depth(C) < Limit for each N <-- Expand(C) Push(S, N) Goto Loop

• Time Complexity
  taverse every node in tree to limit - exponential time O(b^limit)
• Space Complexity
  Modest - memory for each node in current path + each node's siblings to limit
  O(bl)

Iterative Deepening

• Series of Depth Limited Searches
• Pseudo Code

  "Do a series of depth-limited searches, increasing depth each time. [p 79]" for depth = (0 to infinity) do result = Depth-Limited-Search(problem, depth) If result != cuttoff then return result

• Time Complexity - based upon number of times each level of tree is generated
  (d)b + (d-1)b² + .. + (1)b^d
• Space Complexity
  Modest - memory for each node in current path + each node's siblings in each depth-run
  O(bd)