Project 1: Background

1
Project 1 Background

• Informed search 8- puzzle world
• BFS, DFS and A algorithms
• Heuristics Manhattan distance , Number of
  misplaced tiles
• Lisp programming
• Defstruct, defparameter, setf, list, zerop
• mapcar, append, cond, loop..do, aref
• Funcall, return-from, format and .

2
A search

• Combines
• Uniform cost search
• g(n) Exact path cost from start state to node n
• Initial node 0, later nodes (parent g-value)1
• Greedy search
• h(n) Heuristic path cost from node n to a goal
  state
• Initial node0, later nodes Manhattan distance/
  Misplaced Number of tiles
• Heuristic function for A
• f(n) g(n) h(n)
• choose h(n) so that it never overestimates
  (admissible)
• A Next node to expand is node with lowest f(n)

3
Some lisp

• Funcall(a b c d..) calls function a with
  arguments b,c,d..
• Sort(list lt key x) sorts the list in lt
  order based on the x field of each item in list
  destructive
• Append(list1 list2), cond
• (mapcar (lambda (x) (op)) (list)) computes op
  on each item of list and returns new list
  (Children fn)
• quote (common mistake) protects from evaluation
• (Make-array (2 3) initial-element 0) 2 by 3
  array
• (Aref array x y) returns x,y the element of array
  
• Equalp (cannot be used with arrays)

4
A Search Code
A list of nodes (state, action, parent, g-val,
h-val, f-val)

• (defun A (nodes goalp children-fn fvalue-fn)
• (
• cond ((null nodes) nil)
• Return the first node if it is a goal node.
• ((funcall goalp (first nodes)) (first nodes))
• Append the children to the set of old nodes
• (t (A (sort (append (funcall children-fn (first
  nodes))
• (rest nodes)) 'lt key fvalue-fn ) goalp
  children-fn fvalue-fn))))
• (t (let ((temp (sort (append (funcall children-fn
  (first nodes)
• (rest nodes)) 'lt key fvalue-fn )))
• (A temp goalp children-fn fvalue-fn)))))

Functions goalp Compare current state
to
goal-state returns true or
nil children-fn
takes parent-node and
returns a list of children nodes
fvalue-fn takes a node
and returns
its f-value ( a one line code)
A Good place to find the maximum length of queue
5
Node structure global parameters

• Node
• State Could be just an array (33)
• Parent again a node
• Action left, right, up, down from parent
  (string)
• G-val parent g-val 1
• H-val call manhattan distance or misplaced
  tiles
• F-val G-val H-val
• Start node(start state, NIL, NIL, 0,0,0)

Global parameters (defparameter) Number of nodes
generated Number of nodes expanded Maximum size
of queue Goal state
6
goalp

• Goalp (state)
• Compare state with goal (global)
• Do NOT use equalp
• Loop for each element in state to compare with
  corresponding element in goal state
• generalize and write equal-state to compare
  any two states
• return true / NIL (return-from)

7
Children Fn puzzle children

• You have left-child, similarly right, up, down
  child
• puzzle children will call each of them on a
  given state
• (append left right down up)
• Good place to keep track of number of nodes
  generated and expanded

8
Heuristics

• Manhattan
• for each element a at (x,y) in state
• Find position (another function) of a in goal
  state Say (x1,y1)
• Find (abs(x-x1)abs(y-y1))
• Number of misplaced tiles
• modification of goalp
• whenever 2 corresponding elements are not equal
  , increment a counter initially set to 0

9
Possible Order in writing functions

• Goalp
• Right, up, down children
• Children-fn
• Heuristics
• A
• Then statistics