Informed

Search
Chapter 4 (a)
Some material adopted from notes
by Charles R. Dyer, University of
Wisconsin-Madison
 Todays class
Heuristic search
Best-first search
Greedy search
Beam search
A, A*
Examples
Memory-conserving variations
of A*
Heuristic functions
 Big idea: heuristic
Merriam-Webster's Online Dictionary
Heuristic (pron. \hyu-ris-tik\): adj. [from Greek heuriskein to
discover.] involving or serving as an aid to learning, discovery, or
problem-solving by experimental and especially trial-and-error
methods
The Free On-line Dictionary of Computing (15Feb98)
heuristic 1. <programming> A rule of thumb, simplification or
educated guess that reduces or limits the search for solutions in
domains that are difficult and poorly understood. Unlike algorithms,
heuristics do not guarantee feasible solutions and are often used
with no theoretical guarantee. 2. <algorithm> approximation
algorithm.
From WordNet (r) 1.6
heuristic adj 1: (computer science) relating to or using a heuristic
rule 2: of or relating to a general formulation that serves to guide
investigation [ant: algorithmic] n : a commonsense rule (or set of
rules) intended to increase the probability of solving some problem
[syn: heuristic rule, heuristic program]
Informed methods add
domain-specific
information
Add domain-specific information to select the
best path along which to continue searching
Define a heuristic function, h(n), that
estimates the goodness of a node n.
Specifically, h(n) = estimated cost (or
distance) of minimal cost path from n to a
goal state.
The heuristic function is an estimate, based
on domain-specific information that is
computable from the current state
description, of how close we are to a goal
 Heuristics
All domain knowledge used in the search is
encoded in the heuristic function, h().
Heuristic search is an example of a weak method
because of the limited way that domain-specific
information is used to solve the problem.
Examples:
Missionaries and Cannibals: number of people on starting
river bank
8-puzzle: number of tiles out of place
8-puzzle: sum of distances each tile is from its goal position
In general:
h(n) >= 0 for all nodes n
h(n) = 0 implies that n is a goal node
h(n) = implies that n is a dead-end that can never lead
to a goal
 Weak vs. strong

methods
We use the term weak methods to refer to methods that
are extremely general and not tailored to a specific
situation.
Examples of weak methods include
Means-ends analysis is a strategy in which we try to represent
the current situation and where we want to end up and then look
for ways to shrink the differences between the two.
Space splitting is a strategy in which we try to list the possible
solutions to a problem and then try to rule out classes of these
possibilities.
Subgoaling means to split a large problem into several smaller
ones that can be solved one at a time.
Called weak methods because they do not take
advantage of more powerful domain-specific heuristics
 Heuristics for 8-puzzle
1 2 3
Current
State 4 5 6
7 8 11 22 33
The number of
misplaced tiles 44 55 66
1 2 3 77 8
(not including Goal 8
the blank) State 4 5 6
7 8
N N N
In this case, only 8 is misplaced, so the heuristic
function evaluates to 1. N N N
N Y
In other words, the heuristic is telling us, that it thinks a
solution might be available in just 1 more move.
 Heuristics for 8-puzzle
Manhattan 3 2 8 3 3
Current
Distance (not State 4 5 6 2 spaces
including the 7 1
blank)
8
1 2 3
Goal 3 spaces
State 4 5 6
8
7 8
1
In this case, only the 3, 8 and 1 tiles are
misplaced, by 2, 3, and 3 squares respectively, so 3 spaces
the heuristic function evaluates to 8. 1
In other words, the heuristic is telling us, that it
thinks a solution is available in just 8 more moves.
The misplaced heuristics value is 3. Total 8
 1 2 3 h(n)
4 8 5
7 6 5

We can use 1 2 1 2 3

heuristics to guide 4 8 3 6 4 8 5 4
7 6 5 7 6
search.
1 2 3
4 8 5 3
In this hill climbing 7 6

example, the 1 2 3 1 2 3
Manhattan Distance 4 8 5 4 4 5 2
7 6 7 8 6
heuristic helps us
quickly find a 1 2 3 1 2 3 1 3
4 5 1 4 5 3 4 2 5 3
solution to the 8- 7 8 6 7 8 6 7 8 6

puzzle.
1 2 3 1 2
goal 4 5 6 0 4 5 3 2
7 8 7 8 6
 1 2 3 h(n)
In this example, 4 5 8 6
hill climbing does 6 7
not work!

All the nodes on

1 2 3 1 2 3
the fringe are
taking a step 4 5 8 7 4 5 5
backwards 6 7 6 7 8
(local minima)

Note that this

1 2 3 1 2
puzzle is solvable
in just 12 more 4 5 6 4 5 3 6
steps. 6 7 8 6 7 8
 Best-first search
A search algorithm which optimizes
depth-first search by expanding the
most promising node chosen according
to some rule.
Order nodes on the nodes list by
increasing value of an evaluation
function, f(n), that incorporates
domain-specific information in some
way.
This is a generic way of referring to the
class of informed methods.
 Greedy best first

search search
Use as an evaluation function f(n)
= h(n), sorting nodes by increasing
values of f. a
Selects node to expand believed to
be closest (hence greedy) to a h=2 b h h=4
goal node (i.e., select node with
smallest f value) h=1 c i h=1
Not complete
Not admissible, as in the example h=1 d h=0
Assuming all arc costs are one, then g2
greedy search will find goal g, which has h=1 e
a solution cost of five
However, the optimal solution is the
h=0 g
path to goal with cost three.
 Beam search
Use an evaluation function f(n), but the maximum
size of the nodes list is k, a fixed constant
Only keeps k best nodes as candidates for
expansion, and throws the rest away
k is the beam width
More space efficient than greedy search, but may
throw away a node that is on a solution path
As k increases, beam search approaches best first
search
Not complete
Not admissible (optimal)
 Algorithm A
Use as an evaluation function
f(n) = g(n) + h(n) 8
S
g(n) = minimal-cost path from the
start state to state n
1 5 8
g(n) term adds a breadth-first 1 8
component to the evaluation A 5 B C
function 9
Ranks nodes on search frontier by 7 3 5
estimated cost of solution from start 1
4 D
node through the given node to goal E
G
Not complete if h(n) can equal
infinity 9
Not admissible (optimal)
g(d)=4 C is chosen
next to expand
h(d)=9
 Algorithm A
1 Put the start node S on the nodes list, called OPEN
2 If OPEN is empty, exit with failure
3 Select node in OPEN with minimal f(n) and place on
CLOSED
4 If n is a goal node, collect path back to start and stop
5 Expand n, generating all its successors and attach to
them pointers back to n. For each successor n' of n
1 If n' is not already on OPEN or CLOSED
put n ' on OPEN
compute h(n'), g(n')=g(n)+ c(n,n'), f(n')=g(n')+h(n')
2 If n' is already on OPEN or CLOSED and if g(n') is lower
for the new version of n', then:
Redirect pointers backward from n' along path yielding lower g(n').
Put n' on OPEN.
 Algorithm A*
A star
Described by Hart and Nilsson in 1968
Algorithm A with constraint that h(n) <= h*(n)
h*(n) = true cost of the minimal cost path from n
to a goal
h is admissible when h(n) <= h*(n) holds
Using an admissible heuristic guarantees that the
first solution found will be an optimal one
A* is complete whenever the branching factor is
finite, and every operator has a fixed positive cost
A* is admissible

Hart, P. E.; Nilsson, N. J.; Raphael, B. (1968). "A Formal Basis for the Heuristic Determination of
Minimum Cost Paths". IEEE Transactions on Systems Science and Cybernetics SSC4 4 (2): 100107.
 Some observations on
A
Perfect heuristic: If h(n) = h*(n) for all n, then
only the nodes on the optimal solution path will be
expanded. So, no extra work will be performed
Null heuristic: If h(n) = 0 for all n, then this is an
admissible heuristic and A* acts like uniform-cost
search
Better heuristic: If h1(n) < h2(n) <= h*(n) for all
non-goal nodes, then h2 is a better heuristic than h1
If A1* uses h1, and A2* uses h2, then every node
expanded by A2* is also expanded by A1*
i.e., A1 expands at least as many nodes as A2*
We say that A2* is better informed than A1*
The closer h is to h*, the fewer extra nodes that will
be expanded
 Example search space
start state
parent pointer
0 S 8 arc cost
1 5 8

1 A 8 5 B 4 8 C 3
3 9 h value
7 4 5 g value
4 D 8 E 9 G 0

goal state
 Example
n g(n) h(n) f(n) h*(n)
S 0 8 8 9
A 1 8 9 9
B 5 4 9 4
C 8 3 11 5
D 4 inf inf inf
E 8 inf inf inf
G 9 0 9 0
h*(n) is the (hypothetical) perfect heuristic
(an oracle)
Since h(n) <= h*(n) for all n, h is admissible
(optimal)
Optimal path = S B G with cost 9
 Greedy search
f(n) = h(n)
nodeexpandednodeslist
{S(8)}
S{C(3)B(4)A(8)}
C{G(0)B(4)A(8)}
G{B(4)A(8)}

Solution path found is S C G, 3 nodes expanded.

See how fast the search is!! But it is NOT
optimal.
 A* search
f(n) = g(n) + h(n)

nodeexp.nodeslist
{S(8)}
S{A(9)B(9)C(11)}
A{B(9)G(10)C(11)D(inf)E(inf)}
B{G(9)G(10)C(11)D(inf)E(inf)}
G{C(11)D(inf)E(inf)}

Solution path found is S B G, 4 nodes expanded..

Still pretty fast. And optimal, too.
 Proof of the optimality
of
Assume that A* has A* G2, a goal state
selected
with a suboptimal solution, i.e., g(G2) > f*
We show that this is impossible
Choose a node n on the optimal path to G
Because h(n) is admissible, f* >= f(n)
If we choose G2 instead of n for expansion, then
f(n) >= f(G2).
This implies f* >= f(G2).
G2 is a goal state: h(G2) = 0, f(G2) = g(G2).
Therefore f* >= g(G2)
Contradiction
 Dealing with hard
problems
For large problems, A* may require too much
space
Two variations conserve memory: IDA* and SMA*
IDA* -- iterative deepening A* -- uses successive
iteration with growing limits on f, e.g.
A* but dont consider any node n where f(n) >10
A* but dont consider any node n where f(n) >20
A* but dont consider any node n where f(n) >30, ...
SMA* -- Simplified Memory-Bounded A*
uses a queue of restricted size to limit memory
use
On finding a a good
heuristic
If h1(n) < h2(n) <= h*(n) for all n, h2 is better than
(dominates) h1
Relaxing the problem: remove constraints to create a
(much) easier problem; use the solution cost for this
problem as the heuristic function
Combining heuristics: take the max of several
admissible heuristics: still have an admissible
heuristic, and its better!
Use statistical estimates to compute g; may lose
admissibility
Identify good features, then use a learning algorithm
to find a heuristic function; also may lose
admissibility
 Summary: Informed
search
Best-first search is general search where the
minimum-cost nodes (w.r.t. some measure) are
expanded first
Greedy search uses minimal estimated cost h(n)
to the goal state as measure; reduces search time,
but is neither complete nor optimal
A* search combines uniform-cost search and
greedy search: f(n) = g(n) + h(n). A* handles state
repetitions and h(n) never overestimates
A* is complete and optimal, but space complexity is high.
The time complexity depends on the quality of the heuristic
function.
IDA* and SMA* reduce the memory requirements of A*.