PROBLEM

Write an algorithm that calculates the most efficient route

between two points as quickly as possible.

INTRODUCTION TO ALGORITHMS

SEARCHING & FINDING

Improving search techniques

Simon Ellis

24th March, 2014

Search techniques

Breadth-first search (BFS)

Depth-first search (DFS)

Tree spanning

Greedy best-first search

Dijkstra’s algorithm

Improving search performance

Guided search Uses an heuristic to improve performance

Guaranteed to find a path if one exists Like other searches … but will always return the optimum path with

admissible heuristic

Heuristics

An heuristic is an experience-based technique used for problem-solving, learning and discovery

Solution is not guaranteed to be optimal

Speeds up process of finding a satisfactory solution using shortcuts

Could be called ‘computational best-guesswork’

Heuristics

Strategies using readily accessible, if not always strictly applicable, information to control and influence problem solving

Heuristics

Common heuristics in humans include Trial and error Drawing a picture Writing out an algorithm Assuming you have a solution and attempting to

derive from that (‘working backwards’) Talking to someone about a problem Obtaining a concrete example of an abstract problem Trying for a general solution before the specific one

(‘inventor’s paradox’) Putting a problem aside and coming back to it later Getting someone else to do it for you

Admissibility

An heuristic is admissible if and only if it is optimistic

An ‘optimistic’ heuristic will never over-estimate the remaining cost to the goal from any given node n

Assume n is a node h is an heuristic h(n) is the heuristic cost C(n) is the actual cost

Admissibility

An admissible heuristic can be derived from Induction and inductive learning Information from databases with solutions to

subproblems Relaxed versions of the problem

A* basics

Best-first search

Finds a least-cost path from initial node to goal node

Uses a knowledge-plus-heuristic cost to determine search order

Complete and admissible Will always find a solution if it exists Guaranteed to find the shortest path between nodes

A* basics

Maintains 2 pieces of information Open list

Contains candidate nodes which may lie along the path

Closed list Contains nodes which have the lowest path score so far

Nodes move between lists based on current information

A* basics

Uses a knowledge-plus-heuristic cost

Knowledge Movement cost to reach node nk from initial node n0 G

Heuristic cost to reach target node nt from node nk H

Lowest total path cost to node nk is given by F = G

+ H

Best path is given by sequence of nodes with lowest F

A* algorithm 1

1. Add initial node n0 to open list

2. Do

1. Find the node with the lowest F cost on the open list, nc

2. Remove nc from the open list and add it to the closed list

3. For all nodes nk connected to nc

1. If node is on the closed list or not traversable (e.g. a wall): ignore it

2. If node is not on the open list: add it, record costs, make nc its parent

3. If node is already on the open list: check to see if this path to nc is

better (i.e. a lower G score); if so, change parent of nc to nk and

recalculate its G and F scores (may require resorting of open list)

4. Until

1. If nt is added to the closed list, path has been found

2. If open list is empty, there is no path

A* algorithm 2

3. Derive path if one exists

1. Begin at target node nt

2. Follow chain of parent nodes back to node n0

3. Reverse order of nodes to derive path

A* heuristics

There are some ‘standard heuristics’ G

For square grids, often the ‘Manhattan distance’• Orthogonal movement costs 10 or 1

• Diagonal movement costs 14 or 1.4

For other graphs, the edge cost is generally used

H Straight-line distance often used

Numerous other heuristics are possible (Manhattan, cross-product…)

A* heuristics

Scales must be the same for both heuristics!

What happens if scales are not the same? Firstly, heuristic is probably inadmissible

(overestimates cost) Won’t find the best path Might take longer to run

In short, will not find the best path in the best time

Example

Example

Example

Example

Example

Example

A* performance

Speed: O(bd)

Memory requirement: O(bd)

… why? Same as Dijkstra’s algorithm

Dijkstra’s algorithm is effectively A* with H = 0 for all nodes

ANY QUESTIONS?

References

Useful A* resourceshttp://www.policyalmanac.org/games/aStarTutorial.htm

http://theory.stanford.edu/~amitp/GameProgramming/AStarComparison.html

http://heyes-jones.com/astar.php

Imagesfrom http://www.policyalmanac.org/games/aStarTutorial.htm