Pathfinding

Prof. Dr. Taoufik NouriNouri@Nouri.ch

06-11-2014

Pathfinding

• Depth First Search

• Breadth First Search

• Dijkstra

• A*

Pathfinding

• Pathfinding

AI-Game Engine

• Navigation 1:Soccer

Navigation 2: Raven

Pathfinding 1

• Pathfinding is the path between two nodes of a graph.

• A graph is a set of points called nodes connected to each other through connections.

• There is an infinite number of paths from one node to another.

• Usually pathfinding is the shortest way between two nodes

Pathfinding 2

• Graphs can have a cost associated to the connections like distances etc.

• This kind of graphs is called weighted graph.• There is also, directional graphs: paths between

nodes is considered one way.• Graphs can be more complicated: Weighted

directional graphs, you can not go back.• A graph can be of any dimensions and any

shapes

Pathfinding

Very important for real world problems:1. The airport system is a graph. What is the best flight

from one city to another?

2. Traffic flow can be modeled with a graph. What are the shortest routes?

3. Traveling Salesman Problem: What is the best order to visit a list of cities in a graph?

Graph Representation

v1 v2

v3 v4 v5

v6 v7 v1v2v3

v4v5v6v7

v1 v2 v3 v4 v5 v6 v7

0 1 1 1 0 0 00 0 0 1 1 0 0

We can use an “adjacencymatrix” representation.

For each edge (u,v) we set A[u][v] to true;else it is false. If there are weights associatedwith the edges, insert those instead.

v1 v2

v3 v4 v5

v6 v7 v1 v2 v4 v3v2 v4 v5v3 v6

v4 v6 v7 v3v5 v4 v7v6v7 v6

We can use an “adjacencylist” representation.

For each vertex we keep a list of adjacent vertices.If there are weights associated with the edges, that information must be stored as well.

Adjacency List

Graph

GraphNodes are indexed nodes see class GraphNode GraphNodeTypes.h

class GraphEdge{protected: //An edge connects two nodes. Valid node indices are always positive. int m_iFrom; int m_iTo; //the cost of traversing the edge double m_dCost;public: //ctors GraphEdge(int from, int to, double cost):m_dCost(cost), m_iFrom(from), m_iTo(to)…}

see GraphEdgeTypes.h

The graph can be a matrix or a lists

Pathfinding 3

• This is a weighted graph

• Cities are nodes connected through roads-distances-Relief-Terrain

kante(saintgall, zurich, 80, Terrain etc).kante(zurich, basel, 85).kante(basel, bern, 100).kante(lausanne,fribourg,31).kante(lausanne , geneve, 100).kante(zurich , bern, 120).kante(bern, fribourg, 30).kante(bern , neuchatel, 48).kante(neuchatel , lausanne, 78).kante(zurich , solothurn, 99).kante(solothurn , biel, 27).kante(biel , neuchatel, 29).

Pathfinding 4

• Usually, we define a graph as regularly spaced grid where we can travel to: N, NW, NE, S, SW, SE etc.

• Green is start position, Red is Target

• Note: There is no obstacle in our grid

Pathfinding 5• Here is a graph with obstacle

Graph is a powerfull representation tool. But this power can be realized when they are operated upon by algorithms designed to explore them, either to find a specific node or to find a path berween nodes. this is what we will do next

General search algorithm

• Start with – "frontier" = { (v,v) }

• Until frontier is empty– remove an edge (n,m) from the frontier set– mark n as parent of m– mark m as visited– if m = w,

• return

– otherwise• for each edge <i,j> from m

– add (i, j) to the frontier» if j not previously visited

Questions

Answer the following questions:

• What is pathfinding?

• Why is pathfinding useful or necessary

• what is a graph

• What is a weighted graph

• What are the traditional types of pathfinding methods

Pathfinding

• Depth First Search

• Breadth First Search

• Dijkstra

• A*

Depth First Search DFSStack Parent

5-5 1->?2->?3->?4->?5->?6->?

Firt In Last Out

DFS

Stack Parent

5-25-45-6

1->?2->?3->?4->?5->56->?

The edges leading from node 5 are placed on the Stack

Node 5 is marked Visited

DFS

Stack Parent

2-15-45-6

1->?2->53->?4->?5->56->?

Node 2 is pushed on the Stack, Node 5 is parent of 2

Node 2 is marked Visited

DFS

Stack Parent

1-35-45-6

1->22->53->?4->?5->56->?

Node 1 is pushed on the stack, 2 is parent of 1

Node 1 is marked Visited

DFS

Stack Parent

5-45-6

1->22->53->14->?5->56->?

Node 1 is parent of 3, Edge 1-3 is poped from the stack

Node 3 is marked Visited, OHH Node 3 is the Target, the algorithm exit

•The path from S to T is stored in a vector m-Route in the table parent.•A method getPathtoTarget will extract this information and return a vector 5-2-1-3. •What about the path 5-4-3

DFS

• Depth limitation is the major problem of DFS

• The path is not allways the shortest

• It is easy to implement using recursion

• Some situation DFS will make spagethi if not restricted in depth

• see GraphAlgorithms.h implementation

DFS in Action

Breadth First Search BFSThe BFS fans out from the source node and examines each of the nodes ist edges lead to before fanning out from those nodes and examining all the edges they connect to and so on. look at that!!!

BFSQueue Parent

5-5

1->?2->?3->?4->?5->?6->?

First In First Out

BFS

Queue Parent

5-25-45-6

1->?2->?3->?4->?5->56->?

The edges faning from node 5 are placed on the Queue

Node 6, 4 and 2 are marked Visited

BFS

Queue Parent

4-35-2

5-6

1->?2->?3->?4->55->56->5

Node 6 pointed to node 4(visited), Node 6 is not placed on the Queue

Node 6 is marked Visited

BFS

Queue Parent

2-14-3

5-2

1->?2->53->?4->55->56->5

The edges leading from node 4 to 3 are placed on the Queue

Node 4 is marked Visited

BFS

Queue Parent

2-1

4-3

1->?2->53->44->55->56->5

Edge 4-3 is next. Node 4 is noted to be node 3's parent.Node 3 is Target. BFS exits. m_Routes Vector work back through the parents from T to S and we get 3-4-5.

Node 3 is marked Visited

BFS in Action

•BFS returns allways the shortest path if exist.•Simple to implement

•Very Slow on large graphe.•Doesn't consider path cost!

•see GraphAlgorithms.h implementation

DFS-BFS Summary

Depth first search begins by diving down as quickly as possible to the leaf nodes of the tree (or graph). Traversal can be done by: visiting the node first, then its children (pre-order traversal): a b d h e i j c f k g visiting the children first, then the node (post-order traversal): h d i j e b k f g c a visiting some of the children, then the node, then the other children ( in-order traversal) h d b i e j a f k c g

Breadth-first search traverses the tree or graph level-by-level, visiting the nodes of the tree above in the order a b c d e f g h i j k.

Exercices

• How are the traditional types of pathfinding methods implemented

• Implement in a pseudo-code the following pathfinding techniques:BFS, DFS

Shortest Path Trees SPTDijkstra's Algorithm

This is a weighted graph.Weight is distance, cost etc.

How to find the shortest pathfrom a source node to a Targetnode?

Dijkstra's Algorithm

SPT

Starting from node 5, source.

S

TT

5

Dijkstra's Algorithm

SPT

The algorithm take edge 2 and 6.Added the shortest 2 (1.9) to the SPT

S

TT

5

2

Dijkstra's Algorithm

SPT

The algorithm examines edge 2-3, the cost to node 3 is 5(1.9+3.1).The cost to from node 5 to 6 is 3.0. Node 6 is added to SPT

S

TT

5

26

Dijkstra's Algorithm

SPT

The process is repeated once more.Cost to node 4 is less(3.0+1.1 contra 1.9+3.1 to node 3.Node 4 is added to SPT

S

TT

5

26

Dijkstra's Algorithm

SPT

The process is repeated once more.Cost to node 3 is more(3.0+1.1+3.7 contra 1.9+3.1 to node 3.Node 3 is added to SPT through 5-2-3

S

TT

5

26

43

The shortest path is:5-2-3 with the cost 5.0

Djikstra's Algorithm• Use a priority queue

– a data structure in which the item with the smallest "value" is always first

– items can be added in any order• Use the "value" of an edge as the total cost of the path through

that edge– always expand the node with the least cost so far

• If an edge leads to a previously expanded node– compare costs

• if greater, ignore edge• if lesser, replace path and estimate at node with new value

• "Greedy" algorithm

Dijskra's Algoritm in Action

In this case the cost is the distance, from source to target

see GraphAlgorithms.h implementation

Best First Search A*

• Dijkstra's algorithm searches by minimizing the cost of the path in a directed weighet graph.

• In some situations, we have partial knowledge of the structure of the search space that can be applied to guide search.

• It can be improved by estimating the cost to the target. This estimate is usually referred to as a heuristic and the algorithm is called Best-first search (A*).

• We can inspect all the currently-available transitions, and rank them on the basis of our partial knowledge. Here high rank means that the transition looks promising in relation to the goal.

Best First Search A*

• If good Heuristics are used,A* is guaranteed to give the optimal paths.

• Heuristics: any cost estimate to the goal, ex. Euclidean distance, Block distance, it can be coupled with penalties or bonuses for traveling on a specific type of terrain(jungle, desert, forest,plain…).

• Performance of A* is based on the value of Heuristics

• Poor heuristics provides bad performance with A*

Best First Search A*

Heuristic estimates

• Max(dx, dy)

• Manhatten or Blocks (dx+dy)

• Euclidean sqrt(dx*dx + dy*dy)

Best First Search A*

• You are at A going to Target T.• f(T) = g(A) + h(A).• f(T) total cost, g(A) cost until A, h(A) estimate cost from A to T.• We continue our search with the lowest f(T).

A* in Action

•see GraphAlgorithms.h implementation

Comparison No walls

Comparison with walls

Questions about A*

• What is A*?

• What are the advantages of A*?

• What are the disadvantages of A*?

• How can heuristics be used to help A*?

Exercices

• Implement in a pseudo-code the following pathfinding techniques: DJ,A*

Summary

• We introduced the concepts of : node, edge and graph.

• Pathfinding: BFS, BFS, DJ and best-first search A*

• Their Advantages/Desadvantages

• Demo and comparison

• For source code/exe files s. [1]

Exercices

1. Solve with hand some path finder using these four algorithms.

2. Implement the DFS Method3. Implement the A* search Method4. Create a weighted Graph and walk

through it step by step with Dijkstra's5. Try Dijkstra's on graph with negative

weights6. Experiment with pathfinder chapt. 5 [1]

Exercices

7. Implement or read the implementations of

DFS, BFS, Dijkstra and A*

8. Read the solution of exercice 7 in chap. 5 [1]

Other Implementations

In the next slide, you have the best search first using prolog.It is compact and efficient.

Demo--Vortrag

/* to use this programme, write:go(saintgall,geneve,Route).

The answer look like this: Route = [saintgall,zurich,bern,fribourg,lausanne,geneve]

*/

kante(saintgall, zurich, 80).kante(zurich, basel, 85).kante(basel, bern, 100).kante(lausanne,fribourg,31).kante(lausanne , geneve, 100).kante(zurich , bern, 120).kante(bern, fribourg, 30).kante(bern , neuchatel, 48).kante(neuchatel , lausanne, 178).kante(zurich , solothurn, 99).kante(solothurn , biel, 27).kante(biel , neuchatel, 29).

pfad(X, X).pfad(AnfP, EndP):- (kante(AnfP, ZP,Dist); kante(ZP, AnfP,Dist) ),

pfad(ZP, EndP).

pfad_ohne_zyklus(AnfP, EndP):- weg(AnfP, EndP, [AnfP]).

weg(X, X, Kantenzug) .weg(AnfP, EndP, Kantenzug):- (kante(AnfP, ZP, Dist);

kante(ZP, AnfP, Dist)),not(element(ZP, Kantenzug)),weg(ZP, EndP, [ZP |

Kantenzug]).element(E, [E | Rest]).element(E, [Kopf | Rest]):- element(E, Rest).

pfad_mit_knotenliste(AnfP, EndP, Pfad):- weg(AnfP, EndP, [], P), reverse(P, Pfad).

weg(X, X, Kantenzug, [X|Kantenzug]).weg(AnfP, EndP, T, Kantenzug) :- moeglicher_Knoten(AnfP, T,

ZP),weg(ZP, EndP, [AnfP|T],

Kantenzug).

moeglicher_Knoten(AnfP, Kantenzug, ZP) :- (kante(AnfP, ZP,Dist);kante(ZP, AnfP,Dist)),not(element(ZP, Kantenzug)) .

reverse([], []).reverse([K|Rest], Neueliste):-reverse( Rest, TL),append(TL , [K], Neueliste).

append([], Liste , Liste).append([Kopf|Rest], Liste, [Kopf|Ergebnis]) :-append( Rest, Liste, Ergebnis).

pfad_mit_breitensuche(AnfP, EndP, Route) :- weg([[AnfP]], EndP, R), reverse(R, Route ).

moeglicher_Knoten( AnfP, Kantenzug, ZP) :- (kante(AnfP, ZP,Dist);kante(ZP, AnfP,Dist)),not(element(ZP, Kantenzug)).

collect_found(S, L) :-getnext(X), !,collect_found([X | S], L).collect_found(L, L).getnext(X) :- retract(found(X)), !, X \== mark.

append([], Liste, Liste).append([Kopf|Rest], Liste, [Kopf|Ergebnis]):- append( Rest, Liste, Ergebnis).

% Best first searchkurz_pfad(Routes, Dest, Route) :- shortest(Routes, Shortest, RestRoutes),

proceed(Shortest, Dest, RestRoutes, Route).% proceed finds all the legal extensions to the path and adds them to the list

proceed(r(Dist, Route), Dest,_, Route):- Route =[Dest|_].% r(M, P) M is the total length of the path and P is the list of places visitedproceed(r(Dist, [Last|Trail]), Dest, Routes, Route):-

findall(r(D1, [Z, Last|Trail]),legalnode(Last, Trail, Z, Dist, D1), List),

% write(Route),write(Dist),nl,% write(Routes),nl,% write([List]),nl,% write([D1,Z,Dist,D1,Last,Trail]),nl,

append(List, Routes, NewRoutes),kurz_pfad(NewRoutes, Dest, Route).

% shortest returns the shortest path on the listshortest([Route|Routes], Shortest, [Route|Rest]):-

shortest(Routes, Shortest, Rest),shorter(Shortest, Route),!.

shortest([Route|Rest], Route, Rest).shorter(r(M1,_), r(M2,_)):- M1 < M2.

% legal node adds the distance to the next town

legalnode(X, Trail, Y, Dist, NewDist) :- (kante(X, Y, Z); kante(Y, X, Z)),legal(Y, Trail), NewDist is Dist + Z.

legal(X, []). % legal ist gleich not member or not elementlegal(X, [H|T]) :- X \== H, legal(X, T).

% To start write: go(zurich,geneve,J).go(Start, Dest, Route) :- kurz_pfad([r(0, [Start])], Dest, R), reverse(R, Route),!.

Exercice: Best search using prolog

Pseudo-code of DFS

Pseudo-code of BFS

Pseudo-code of DJ

Pseudo-code of A*

Pseudo-code of Trace