1. Graph Algorithms GAM 376 Robin Burke Winter 2006

2. Outline Graphs Theory Data structures Graph search Algorithms DFS BFS Project #1 Soccer Break Lab

3. Admin Homework #3 due Monday not today Careers in Technology Tomorrow 5 – 7 pm Midway Games will be there

4. Admin Late policy not spelled out in syllabus 10% per day for three days Meaning tomorrow is the last day to turn in Homework #2 30% off though

5. Grading Yes, I am way behind in grading

6. Admin Final project first build Same as the exercise from Lab #1 but you have to decide what map you're going to use what NPC you're going to create Deliverable compiled map

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

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

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

10. An Example Graph v1 v2 v3 v4 v5 v6v7 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.

11. Definitions A “path” is a sequence of vertices w 1, w 2, w 3, …, w n such that (w i, w i+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.

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

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

14. A Modified Graph v1 v2 v3 v4 v5 v6v7 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.

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

16. Graph Representation v1 v2 v3 v4 v5 v6v7 v1 v2 v3 v4 v5 v6 v7 v1 v2 v3 v4 v5 v6 v7 0 1 1 1 0 0 0 0 0 0 1 1 0 0 We can use an “adjacency matrix” representation. For each edge (u,v) we set A[u][v] to true; else it is false. If there are weights associated with the edges, insert those instead.

17. Representation The adjacency matrix representation requires O(V 2 ) 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.

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

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

20. 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 from m add (i, j) to the frontier if j not previously visited

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

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

23. DFS v1 v2 v3 v4 v5 v6v7 start target

24. 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 Complexity Time: O(E) Space: O(1)

25. Optimal DFS Really expensive Start with bestPath = { } bestCost =  "frontier" = { } Repeat until frontier is empty remove a pair 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 from n add to the frontier if m not previously visited or if previous path to m was longer

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

27. Buckland's implementation

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

29. BFS v1 v2 v3 v4 v5 v6v7 start target

30. 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 Complexity Time: O(E) Space: O(E)

31. Buckland implementation

32. 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 We will cover this next week

33. Next week More graph fun Dijkstra's algorithm A* Scripting / Lua

34. Simple Soccer Implementation of a 5-player soccer team Two state machines "Team state" "Player state"

35. Team state kickoff everybody go to default position offense look for opportunities to get a pass upfield from the player with the ball defense go to defensive position transition offense / defense based on possession of ball

36. Player state defense chase ball if you're the closest offense move toward goal with ball pass if possible without ball, move to support spot ask for pass

37. Steering behaviors chasing the ball steering to support position goalie has special behavior to get in blocking position

38. Demo

39. SteeringSoccerLab Not the same as Buckland's Allows multiple team implementations Records the CPU time used by each AI implementation Don't use Buckland's code

40. How to allow different opponents? Need students to make their own soccer teams need to run tournament in which teams compete don't want to recompile when adding a team How to make extensible code that doesn't need recompilation? In particular how can I create an instance if I don't know the name of the class

41. AbstractFactory

42. Registration How to know which factory object to use? Static instance that registers a name on instantiation Table associating factories with names Result dynamic object creation A bit easier in Java using reflection

43. Tournament rules Round-robin 3 game matches 5 minutes / match Scoring Lower scoring team get a bonus if they used less CPU time 20% less CPU = 1 point Ties go to the most efficient team Degenerate strategies disqualified

44. Teams Team 1 Choryan Gilliam Wiemeyer Team 2 Abero Gantchev McNulty Team 3 Flaks Hall Team 4 Chrostowski Hogan Kenley

45. Break