Game Programming and Breadth First Search - Assignment Example

A1. Breadth First Search (BFS) Traversal Algorithm: In BFS traversal, nodes on the same level are examined first. So, instead of going deep into thegraph, we examine the nodes across the breadth of the graph; before going to the next level. For BFS, we use a queue to pick a node to visit first, and place its unprocessed adjacent nodes in queue. Similarly, pick a node front of queue; if unvisited, we visit the node and again place its neighbors in the queue. Output of BFS traversal: a-----d-----c-----e-----f-----b A2. Depth First Search (DFS) Traversal: Contrary to BFS, DFS involves following the path in the graph as deep as possible. If there are no unvisited, adjacent nodes, then we backtrack to the previous level and start traversal again. Thus, the depths of the graph are first examined. For DFS, a stack can be maintained to keep a record of all the visited nodes, to ease the backtracking process. Output of DFS traversal: a-----d-----c-----f-----b-----e A3. The previous output in the form of a DFS tree: Answer 2.2 A* Algorithm A1. There in all 32 states corresponding to each vertex of every polygon, along with the start and end points of the navigation. The different paths towards the goal are, considering each start point and end point as 0 in the forward direction: Path 1: 0-4-1-6-3-2-0 (goal) Path 2: 0-4-1-6-2-0 (goal) Path 3: 0-4-1-7-6-3-2-0 (goal) Path 4: 0-4-1-7-3-2-0 (goal) Path 5: 0-4-7-6-3-2-0 (goal) Path 6: 0-4-7-6-2-0 (goal) Path 7: 0-4-7-3-2-0 (goal) Path 8: 0-4-6-3-2-0 (goal) Path 9: 0-4-6-2-0 (goal) Path 10: 0-5-1-6-3-2-0 (goal) Path 11: 0-5-1-6-2-0 (goal) Path 12: 0-5-1-7-6-3-2-0 (goal) Path 13: 0-5-1-7-6-2-0 (goal) Path 14: 0-5-1-7-3-2-0 (goal) Path 15: 0-5-7-6-3-2-0 (goal) Path 16: 0-5-7-6-2-0 (goal) Path 17: 0-5-7-3-2-0 (goal) Path 18: 0-5-3-2-0 (goal) A2: State Space Representation: A3. Working of A* algorithm Given a suitable problem, we represent the initial conditions of the problem with an appropriate initial state, and the goal conditions as the goal state. For each action that is performed, generate successor states to represent the effects of the action. If this continues, at some point one of the generated successor states is the goal state, then the path from the initial state to the goal state is the solution to the problem. What A* does is generate and process the successor states in a certain way. Whenever it is looking for the next state to process, A-star employs a heuristic function to try to pick the best state to process next. If heuristic function is good, not only will A-star find a solution quickly, but it can also find the best solution possible. Brief Description:: The A* algorithm maintains two sets or ordered lists OPEN and CLOSED. OPEN list keeps a track of those nodes that need to be examined. CLOSED list keeps track of those nodes that have already been examined. Initially, OPEN list contains just the initial node. Start with initial node and insert it in ordered list OPEN list. Create a list CLOSED. This is initially an empty list. Each node 'n' maintains the following: g(n) = the cost of getting from the natal node to 'n' h(n) = the estimate, according to the heuristic function, of the cost of getting from n to the goal node. f(n) = g(n) + h(n); intuitively, this is the estimate of the best solution that goes through n. If OPEN is empty, exit with failure in algorithm. Select first node on OPEN. Remove it from OPEN and put it on CLOSED. This is node 'n'. If 'n' is goal node, exit the program. The solution is obtained by treating a path backwards along arcs in the tree from the node to n. Expand node n. This will generate successors. Read the list OPEN according to heuristic and go back to step 4. Each node maintains a pointer to its parent node, so that later on the best solution if founded can be retrieved. If n is goal node then we are done with solution given by backtracking. For each successor node n, if it is already in CLOSED list and the copy there has an equal or lower 'f' estimate, we can safely discard the newly generated n and move on. Similarly if n is already in the OPEN list and the copy there has an equal or lower 'f' estimate, we can discard the newly generated n and move on. If no better version of n exists on either the CLOSED or OPEN lists, we remove the inferior copies from the two lists and set n as the parent of n. We also calculate the cost estimates for n as follows: Set g(n) to g(n) + cost of getting n to n. Set h(n) to heuristic estimate of getting from n to goal node. Set f(n) to g(n) + h(n). Lastly, add n to the OPEN list and return to the beginning of the main loop. The A* algorithm not only gives quick solution but also gives the best possible solution for a suitable problem; if good heuristic function is used. (1) Pseudo code: Data structures used are: Class Node is defined with a constructor Node (). Structure OPENlist is created to store all the non-examined nodes, to store fdash and name. While structure CLOSEDlist is created to store all the examined nodes to store pointer to the parent node and next node. Add_OPEN function is used to add successors which have been generated but not yet examined in OPEN. It's parameter is structure OP object. Input: successor which is to be added Output: none Function: Generate_succ (), to generate successors of BESTNODE. It has two argument, name[D] and class Node pointer *p[TOT]. Input: BESTNODE, input tree Output: none Calls: Add_OPEN(temp) Function: Add_CLOSED (), to add already examined nodes in CLOSED. It has one array argument, x[D]. Input: BESTNODE Output: none Calls: none Function: Delete_OPEN (), to delete node from OPEN. It does not have any parameter. Input: none Output: none Calls: none Function: Find_Optimal_Path (), to find optimal path from initial to goal state. It has one parameter, class Node pointer *p[TOT]. Input: input tree Output: none Calls: none #define MAX 15 #define TOT 47 class Node { char parent[D], child[D]; int ht, hdash; public: Node() //constructor { parent[0] = child[0] ='0'; ht = -1; hdash = -1; } typedef struct OPENlist { char name [D]; int fdash; }OP; typedef struct CLOSEDlist { char name [D]; struct CLOSEDlist *next; } CLOSED; CLOSED *prev,*first; Char BESTNODE[D]; Heuristic used to compute hdash value hdash number of positions that are not same in initial an goal state. for(j=0;jht + p[j]->hdash; Add_OPEN(temp); } } Void Add_CLOSED(char x[D]) { CLOSED *temp; If(first==NULL) { first =(CLOSED *)malloc(sizeof(CLOSED)); strcpy(first->name, x); first-name, x); temp- Read More