A General Backtracking Algorithm
Sanity check function for the n-queens problem:
fQueens :: Int -> [Int] -> Bool
fQueens row plan = isOK plan 1
where isOK []
dist = True
isOK (p:ps) dist =
if elem p [row, row-dist, row+dist] then False
else isOK ps (dist + 1)
February 18, 2016
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
1
A General Backtracking Algorithm
We can write our general backtracking function:
backtrack :: (a->[a]->Bool) -> [[a]] -> [a]
backtrack fCheck levels = bt [] levels
where bt plan []
= plan
bt plan ([]:_)
= []
bt plan ((b:bs):ls) = if not (fCheck b plan) || null result
then bt plan (bs:ls)
else result
where result = bt (b:plan) ls
Use it to solve n-queens problem:
nQueens n = backtrack fQueens $ take n (repeat [1..n])
February 18, 2016
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
2
A General Backtracking Algorithm
Here is some code to print nQueens solution boards (rotated by
90 to simplify things):
showQueens :: Int -> [Int] -> String
showQueens size []
= ""
showQueens size (q:qs) = (concat $ replicate (q-1) ". ") ++ "Q " ++
(concat $ replicate (size-q) ". ") ++ "\n" ++
showQueens size qs
nQueensBoard :: Int -> String
nQueensBoard n = showQueens n $ nQueens n
The Haskell Platform allows you to even solve the 22-queens
problem within about 15 seconds:
main = putStrLn $ nQueensBoard 22
February 18, 2016
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
3
Our 22-Queens Solution
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
February 18, 2016
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
.
.
.
.
.
.
Q
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
.
.
.
.
.
.
Q
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
.
.
.
.
.
.
Q
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Q
.
.
.
.
.
.
.
.
.
.
.
4
A General Graph-Searching Algorithm
We just saw how backtracking can lead to very efficient search
when we continuously check whether we are stuck in a dead
end.
We would not be able to solve the 22-queens problem with
brute force, i.e., breadth-first search. That would create a tree
with at least 1 + 22 + 222 + … + 2221 + 1 = (2222 -1)/21 + 1 
1.61028 nodes before we could possibly find a solution.
Even if we could create a billion nodes per second and store
them somehow, it would still take us over 500 billion years to
build the complete tree.
February 18, 2016
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
5
A General Graph-Searching Algorithm
In some cases, we may even have an idea which decisions
during search are most likely to get us to the goal quickly.
Then we should take advantage of this information.
Unfortunately, neither depth-first nor breadth-first search are
flexible enough to allow this.
Instead, we need a general graph-searching algorithm. It can
be tuned towards depth-first or breadth-first search but also
allows intermediate variants that can be guided by taskspecific search heuristics.
Let’s see how this magic works…
February 18, 2016
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
6
A General Graph-Searching Algorithm
1. Create search tree Tr consisting only of the start node
(root) n0. Put n0 on an ordered list called OPEN.
2. Create empty list called CLOSED.
3. If OPEN is empty, exit with failure.
4. Move the first node on OPEN, called n, to CLOSED.
5. If n is a goal node, exit with success; the solution is the
path from n to n0 along the edges in Tr.
6. Expand node n by generating a set M of successors and
connect them to n. Also put the members of M on OPEN.
7. Reorder the list OPEN according to a specific rule.
8. Go to step 3.
February 18, 2016
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
7
Rules for the Graph-Searching Algorithm
What happens if we simply append new nodes to the
end of OPEN?
• The algorithm turns into breadth-first search.
What happens if we add new nodes at the beginning
of OPEN?
• The algorithm turns into depth-first search.
What happens if we sort the nodes according to a
heuristic evaluation function f’ ?
• The algorithm turns into best-first search.
February 18, 2016
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
8
Best-First (Heuristic) Search
• We can often improve search efficiency by
implementing a heuristic evaluation function f’
that estimates which node is the best one to
expand in a given situation.
• Small values of f’ indicate the best nodes.
• In the general graph-searching algorithm, sort the
nodes on the OPEN list in ascending order with
regard to their f’-values.
• This way, the supposedly “best” nodes are
expanded first.
February 18, 2016
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
9
Best-First (Heuristic) Search
Example: The Eight-puzzle
The task is to transform the initial puzzle
2 8 3
1 6 4
7
5
into the goal state
1 2 3
8
4
7 6 5
by shifting numbers up, down, left or right.
February 18, 2016
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
10
Best-First (Heuristic) Search
How can we find an appropriate evaluation function?
• Heuristic evaluation functions have to be “custommade” for individual problems.
• Often, it is easy to see what a reasonable (but
usually not optimal) function could look like.
• For the Eight-puzzle, it seems like a good idea to
expand those nodes first that lead to configurations
similar to the goal state.
• In our first attempt, we will simply define f’ as the
number of digits in the puzzle that are not in the
correct (goal) position yet.
February 18, 2016
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
11
Best-First (Heuristic) Search
4
5
3
3
3
1
6
4
7
8
3
2
1
6
4
1
7
5
8
3
2
1
4
1
6
5
7
7
3
3
8
3
2
8
3
2
1
4
7
1
4
7
6
5
6
5
8
8
2
2
3
2
4
7
5
8
3
2
8
3
4
1
6
4
7
5
3
2
8
8
4
1
4
6
5
7
6
6
5
5
4
3
5
to the goal
3
2
1
4
7
6
5
to further unnecessary expansions
February 18, 2016
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
12
Best-First (Heuristic) Search
• You see that with this simple function f’ the
algorithm is still likely to perform unnecessarily
many steps.
• We should increase the “cost” of searches in
greater depth to make the algorithm avoid them.
• To achieve this, we simply add the current depth of
a node to its f’-value.
• Now f’(n) = depth of n in the tree + number of digits
in the puzzle in incorrect position.
• Let us try again!
February 18, 2016
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
13
Best-First (Heuristic) Search
0+4
1+5
3+3
8
3
1
6
4
7
2
8
3
2
1
6
4
1
7
5
8
3
2
1
4
1
6
5
7
2
2+3
2
7
1+3
2+3
8
3
2
8
3
2
1
4
7
1
4
7
6
5
6
5
2
3
3+4
goal !
5+0
February 18, 2016
1
8
7
3+2
3
2
8
3
4
1
6
4
7
5
3
2
8
8
4
1
4
6
5
7
6
2
3
2
3
1
8
4
1
8
4
7
6
5
7
6
5
1
2
3
1
2
3
8
4
7
8
4
6
5
6
5
7
4
6
5
4+1
5
7
8
6
1+5
5
2+4
3+4
5+2
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
3
5
14
Best-First (Heuristic) Search
• Using the improved function f’, the best-first
algorithm discovers the solution much more
efficiently than it did before.
• To formalize things, we now have a function
f’(n) = g’(n) + h’(n), where
g’(n) is a estimate of the depth (or cost) of n, and
h’(n) is an estimate of the minimal distance (or cost)
from n to a goal node.
• While f’(n), g’(n), and h’(n) are estimates,
f(n) = g(n) + h(n) is the actual minimal cost of any
path going from n0 through n to a goal node.
February 18, 2016
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
15
Best-First (Heuristic) Search
Question:
What happens if for our heuristic estimation function
f’(n) = g’(n) + h’(n) we simply set h’(n) = 0?
Answer:
• Only the distance of a node from n0 determines the
cost of expanding a node.
• Nodes closer to n0 will be expanded first.
• The algorithm turns into breadth-first search.
February 18, 2016
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
16
Best-First (Heuristic) Search
And what happens if the state-space graph for our
problem is not a tree?
For example, is the Eight-puzzle state-space graph a
tree?
No. In this puzzle, actions are reversible. Any
successor of a node n has n as a successor.
In order to overcome this problem, we have to
modify Step 6 in our general graph-searching
algorithm.
February 18, 2016
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
17
Improved Graph-Searching Algorithm
1. Create search tree Tr consisting only of the start node
(root) n0. Put n0 on an ordered list called OPEN.
2. Create empty list called CLOSED.
3. If OPEN is empty, exit with failure.
4. Move the first node on OPEN, called n, to CLOSED.
5. If n is a goal node, exit with success; the solution is the
path from n to n0 along the edges in Tr.
6. Expand node n by generating a set M of successors that
and
are
not already
in Tr. Connect
each
node
connect
them to ancestors
n. Also put of
thenmembers
of M on
OPEN.
in M to node n. Also put the members of M on OPEN.
7. Reorder the list OPEN according to a specific rule.
8. Go to step 3.
February 18, 2016
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
18
Algorithm A*
The algorithm shown on the previous slide, using a
heuristic estimation function f’(n) = g’(n) + h’(n), is
also called Algorithm A*.
Under the following conditions, A* is guaranteed to
find the minimal cost path:
• Each node in the graph has a finite number of
successors (or no successors).
• All edges in the graph have costs greater than
some positive amount .
• For all nodes n in the search graph, h’(n)  h(n),
that is, h’(n) never overestimates the actual value
h(n) – an optimistic estimator.
February 18, 2016
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
19
Algorithm A*
Question:
What happens if we use a “stupid” estimation function
such as h’(n) = 0 ?
Answer:
A* is still guaranteed to find a minimal cost path.
However, the more closely our function h’(n) is to the
actual function h(n), the better will be the efficiency of
A* in finding such a path.
The effort of finding a good estimator pays off in the
efficiency of the algorithm.
February 18, 2016
Introduction to Artificial Intelligence
Lecture 8: Search in State Spaces III
20