Graph Algorithms

1. Graph Algorithms GAM 376 Robin Burke Winter 200

2. Homework #2 • No 10s • Most common mistake • not handling the possibilities associated with damage • Big no-no • States with no exit conditions • Handling explosion without state blip

3. 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%

4. from any state except E from any state KO return to previous P A Aout and ~Dead (S or F) and D50 F and Hs H F and Hw CN CHS V and D50 Hs CHW V and D50 Hw V and DMed V and D10 Aout and Dead DMed V and DMed D50 D10 D50 E CC CC2 D10 DMed Aout V and D10 CDH V and (DMed or D50) D Hs orHw V and D10 CD from any state Dmg D10 CDC DMed

5. Homework #3 • Buckland’s API • yes, it isn’t very well documented • very, very typical of production game code • Cannot wait for the world to become better documented • investigate the code and its usage • find clues • apply logic

6. 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 itself inline 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; }

7. Clues • Calling convention • first the data being converted • then information about the vehicle • local space • Return value • converted point • Vehicle API • includes heading, side (?) and position

8. Outline • Graphs • Theory • Data structures • Graph search • Algorithms • DFS • BFS

9. 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?

10. Graph Algorithms in Games • Many problems reduce to graphs • path finding • tech trees in strategy games • state space search • problem solving • "game trees"

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

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

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

14. An Example Graph v2 v1 v5 v4 v3 v6 v7 The sequence v1, v2, v5, v4, v3, v6 is a path. The length is 5. It is a simple path.

15. 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!).

16. A Modified Graph v2 v1 v5 v4 v3 v6 v7 The sequence v1, v2, v5, v4, v3, v1 is a cycle. We had to make one change to this graph to achieve this cycle. So, this graph is not acyclic.

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

18. Graph Representation v2 We can use an “adjacency matrix” representation. v1 v5 v4 v3 v1 v2 v3 v4 v5 v6 v7 0 1 1 1 0 0 0 v6 v7 v1 0 0 0 1 1 0 0 v2 v3 For each edge (u,v) we set A[u][v] to true; else it is false. v4 v5 v6 v7

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

20. Adjacency List v2 We can use an “adjacency list” representation. v1 v5 v4 v3 v1  v2  v4  v3 v6 v7 v2  v4  v5 v3  v6 v4  v6  v7  v3 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. v5  v4  v7 v6 v7  v6

21. Graph search • Problem • is there a path from v to w? • what is the shortest / best path? • optimality • what is a plausible path that I can compute quickly? • bounded rationality

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

23. Note • We don't say how to pick a node to "expand" • We don't find the best path, some path

24. Depth First Search • Last-in first-out • We continue expanding the most recent edge until we run out of edges • no edges out or • all edges point to visited nodes • Then we "backtrack" to the next edge and keep going

25. DFS v2 v1 start v5 v4 v3 v6 v7 target

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

27. Optimality • DFS does not find the shortest path • returns the first path it encounters • If we want the shortest path • we have to keep going • until we have expanded everything

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

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

30. Buckland's implementation

31. Breadth-first search • First-in first-out • Expand nodes in the order in which they are added • don't expand "two steps" away • until you've expanded all of the "one step" nodes

32. BFS v2 v1 start v5 v4 v3 v6 v7 target

33. Characteristics • Will find shortest path • Won't get lost in deep trees • Can be memory-intensive • frontier can become very large • especially if branching factor is high • Typical Complexity • Time: O(p*b) • Space: O(E)

34. Buckland implementation

35. 1 2 3 4 5 6 Exercise • Path from node1 to node6 • depth-first • breadth-first • iterative deepening dfs

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

37. Weighted graph 1 v2 v1 1 1 5 3 1 v5 v4 v3 3 3 v1 v2 v3 v4 v5 v6 v7 2 2 1 0 1 1 5 0 0 0 v1 0 0 0 3 1 0 0 v6 v7 v2 2 0 0 0 0 0 1 0 v3 0 0 1 0 0 3 2 v4 v5 v6 v7

38. Uniformed algorithms • Can use DFS and BFS but • how to know when the shortest path found? • Problem condition • long paths of cheap links • must examine whole network

39. Midterm review • Midterm topics • Finite state machines • Steering behaviors • Graph search

40. Tuesday • Soccer Lab