Graph Algorithms GAM 376 Robin Burke Winter 200. Homework #2 No 10s Most common mistake not handling...

Graph Algorithms

GAM 376

Robin Burke

Winter 200

Homework #2

No 10s Most common mistake

not handling the possibilities associated with damage

Big no-noStates with no exit conditionsHandling explosion without state blip

My solution

States Patrol Combat-Normal Combat-HideSolid Combat-HideWeak Combat-Close Combat-Closer Combat-Damaged Combat-DamagedHide Combat-

DamagedCloser Hit Explode Dead

Conditions Player enters tank's field of view Player fires Player hides behind a non-destructible

object Player hides behind a dest. object Player is not hidden Tank / player distance > 50 meters Tank / player distance < 50 meters and >

10 Tank / player distance < 10 meters Player hits with grenade or RPG Player health < 0 Animation complete Tank health < 0 Tank health < 25%

P

CN CHS

CHW

CC CC2

H

E

(S or F) and D50 F and HsF and Hw

D50 DMed D50D10

D10

DMed

V and D50 V and

D50

Hs

Hw

from any state

A

Aout and Dead

D

Aout

Aout and ~Dead

return toprevious

from any state except EKO

CDfrom any state

Dmg

CDH

CDC

D10

DMed

Hs orHw

V and (DMed or D50)

V and DMed

V and D10

V and D10

V and D10V and DMed

Homework #3

Buckland’s APIyes, it isn’t very well documentedvery, very typical of production game

code Cannot wait for the world to become

better documented investigate the code and its usage find cluesapply logic

Example PointToLocalSpace

look at a function call (Obstacle avoidance) //calculate this obstacle's position in local space Vector2D LocalPos = PointToLocalSpace((*curOb)->Pos(), m_pVehicle->Heading(), m_pVehicle->Side(), m_pVehicle->Pos());

look at the function itselfinline Vector2D PointToLocalSpace(const Vector2D &point, Vector2D &AgentHeading, Vector2D &AgentSide, Vector2D &AgentPosition){ //make a copy of the point Vector2D TransPoint = point; //create a transformation matrix C2DMatrix matTransform; double Tx = -AgentPosition.Dot(AgentHeading); double Ty = -AgentPosition.Dot(AgentSide); //create the transformation matrix matTransform._11(AgentHeading.x); matTransform._12(AgentSide.x); matTransform._21(AgentHeading.y); matTransform._22(AgentSide.y); matTransform._31(Tx); matTransform._32(Ty); //now transform the vertices matTransform.TransformVector2Ds(TransPoint); return TransPoint;}

Clues

Calling conventionfirst the data being convertedthen information about the vehicle

• local space

Return valueconverted point

Vehicle APIincludes heading, side (?) and position

Outline

Graphs Theory Data structures Graph search

Algorithms DFS BFS

Graph Algorithms

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

best flight from one city to another? Class prerequisites can be represented as a

graph. What is a valid course order? Traffic flow can be modeled with a graph.

What are the shortest routes? Traveling Salesman Problem: What is the

best order to visit a list of cities in a graph?

Graph Algorithms in Games

Many problems reduce to graphspath findingtech trees in strategy gamesstate space search

• problem solving• "game trees"

What is a Graph? A graph G = (V,E) consists of a set of vertices V

and a set of edges E. Each edge is a pair (v,w) where v and w are vertices.

If the edges are ordered (indicated with arrows in a picture of a graph), the graph is “directed” and (v,w) != (w,v).

Edges can also have weights associated with them.

Vertex w is “adjacent” to v if and only if (v,w) is an edge in E.

An Example Graph

v1 v2

v3 v4 v5

v6 v7

v1, v2, v3, v4, v5, v6, and v7 are vertices. (v1,v2) is an edge in thegraph and thus v2 is adjacent to v1. The graph is directed.

Definitions

A “path” is a sequence of vertices w1, w2, w3, …, wn such that (wi, wi+1) are edges in the graph.

The “length” of the path is the number of edges (n-1).

A “simple” path is one where all vertices are distinct, except perhaps the first and last.

An Example Graph

v1 v2

v3 v4 v5

v6 v7

The sequence v1, v2, v5, v4, v3, v6 is a path. The length is 5.It is a simple path.

More Definitions

A “cycle” in a directed graph is a path such that the first and last vertices are the same.

A directed graph is “acyclic” if it has no cycles. This is sometimes referred to as a DAG (directed acyclic graph).

The previous graph is a DAG (convince yourself of this!).

A Modified Graph

v1 v2

v3 v4 v5

v6 v7

The sequence v1, v2, v5, v4, v3, v1 is a cycle. We had tomake one change to this graph to achieve this cycle. So, thisgraph is not acyclic.

More Definitions…

An undirected graph is “connected” if there is a path from every vertex to every other vertex. A directed graph with this property is called

“strongly connected”. If the directed graph is not strongly connected, but the underlying undirected graph is connected, then the graph is “weakly connected”.

A “complete” graph is a graph in which there is an edge between every pair of vertices.

The prior graphs have been weakly connected and have not been complete.

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.

Representation

The adjacency matrix representation requires O(V2) space. This is fine if the graph is complete, or nearly complete.

But what if it is sparse (has few edges)?

Then we can use an “adjacency list” representation instead. This will require O(V+E) space.

Adjacency List

v1 v2

v3 v4 v5

v6 v7 v1 v2 v4 v3v2 v4 v5v3 v6

v4 v6 v7 v3v5 v4 v7

v6v7 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.

Graph search

Problemis there a path from v to w?what is the shortest / best path?

• optimalitywhat is a plausible path that I can

compute quickly?• bounded rationality

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

Note

We don't say how to pick a node to "expand"

We don't find the best path, some path

Depth First Search

Last-in first-out We continue expanding the most

recent edge until we run out of edgesno edges out orall edges point to visited nodes

Then we "backtrack" to the next edge and keep going

DFS

v1 v2

v3 v4 v5

v6 v7

start

target

Characteristics

Can easily get side-tracked into non-optimal paths

Very sensitive to the order in which edges are added

Guaranteed to find a path if one exists Low memory costs

only have to keep track of current path nodes fully explored can be discarded

Typical Complexity Time: O(E/2) Space: O(1)

• assuming paths are short relative to the size of the graph

Optimality

DFS does not find the shortest pathreturns the first path it encounters

If we want the shortest pathwe have to keep goinguntil we have expanded everything

Optimal DFS

Really expensive Start with

bestPath = { } bestCost = "frontier" = { <{ }, (v,v)>}

Repeat until frontier is empty remove a pair <P, > from the frontier set if n = w Add w to P If cost of P is less than bestCost

• bestPath = P record n as "visited" add n to the path P for each edge <n,m> from n

• add <P, m> to the frontier• if m not previously visited• or if previous path to m was longer

Iterative Deepening DFS

Add a parameter k Only search for path of lengths <= k Start with k = 1

while solution not found• do DFS to depth k

Sounds wasteful searches repeated over and over but actually not too bad

• more nodes on the frontier finds optimal path less memory than BFS

Buckland's implementation

Breadth-first search

First-in first-out Expand nodes in the order in which

they are addeddon't expand "two steps" awayuntil you've expanded all of the "one

step" nodes

BFS

v1 v2

v3 v4 v5

v6 v7

start

target

Characteristics

Will find shortest path Won't get lost in deep trees Can be memory-intensive

frontier can become very largeespecially if branching factor is high

Typical ComplexityTime: O(p*b)Space: O(E)

Buckland implementation

ExerciseNodes Edges1 1-4, 1-3, 1-223 3-4, 3-54 4-65 5-2, 5-66 6-3

1

65

432

Path from node1 to node6 depth-first breadth-first iterative deepening dfs

What if edges have weight?

If edges have weight then we might want the lowest weight path a path with more nodes might have lower

weight Example

a path around the lava pit has more steps but you have more health at the end compared to the path that goes through the

lava pit

Weighted graph

v1 v2

v3 v4 v5

v6 v7

1

1

1

2

21

5 3

3

23

1

v1v2v3

v4v5v6v7

v1 v2 v3 v4 v5 v6 v7

0 1 1 5 0 0 00 0 0 3 1 0 00 0 0 0 0 1 0

0 0 1 0 0 3 2

Uniformed algorithms

Can use DFS and BFS buthow to know when the shortest path

found? Problem condition

long paths of cheap linksmust examine whole network

Midterm review

Midterm topicsFinite state machinesSteering behaviorsGraph search

Tuesday

Soccer Lab