COMP 2521 Data Structures and Algorithms _ Week 07 Lab Solution Graph Search Algorithms and Maze Sol

downloaded from

Scholarfriends

https://scholarfriends.com Downloaded by: writerforacademic@gmail.com | https://scholarfriends.com/singlePaper/310529/comp-2521-data-structures-and-algorithmsweek-07-lab-solution-graph-search-algorithms-and-maze-sol Distribution of this document is illegal.

Week 07 Lab Solution Graph Search Algorithms and Maze Solvers Possible Solution solveBfs

This study source was downloaded by 100000857336479 from CourseHero.com on 04-02-2023 06:42:13 GMT -05:00

https://www.coursehero.com/file/155377365/COMP2521-22T1-Week-07-Lab-Solutionpdf/

1

#define MAX_NEIGHBOURS 4

2 3

static void fillPath(Maze m, Cell start, Cell exit, Cell **pred);

4

static bool validCell(Maze m, Cell c);

5 6 7

bool solve(Maze m) { int height = MazeHeight(m);

8

int width = MazeWidth(m);

9 10 11

bool **visited = createBoolMatrix(height, width); Cell **pred = createCellMatrix(height, width);

12 13

Queue q = QueueNew();

14 15 16

Cell start = MazeGetStart(m); QueueEnqueue(q, start);

17 18

bool found = false;

19 20

while (!found && !QueueIsEmpty(q)) { Cell v = QueueDequeue(q);

21 22

if (visited[v.row][v.col]) {

23 24

continue; }

25 26

visited[v.row][v.col] = true;

27 28

if (MazeVisit(m, v)) { fillPath(m, start, v, pred);

29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

found = true; break; } Cell adj[MAX_NEIGHBOURS] = { { .row = v.row - 1, .col = v.col }, // up { .row = v.row, .col = v.col + 1 }, // right { .row = v.row + 1, .col = v.col }, // down { .row = v.row, .col = v.col - 1 }, // left }; for (int i = 0; i < MAX_NEIGHBOURS; i++) { Cell w = adj[i]; if (validCell(m, w) && !MazeIsWall(m, w) && !visited[w.row][w.col]) { QueueEnqueue(q, w); pred[w.row][w.col] = v; } } } QueueFree(q); freeBoolMatrix(visited); freeCellMatrix(pred); return found; } static void fillPath(Maze m, Cell start, Cell exit, Cell **pred) { Cell curr = exit; while (!(curr.col == start.col && curr.row == start.row)) {

59 60 61

MazeMarkPath(m, curr); curr = pred[curr.row][curr.col]; }

62 63

MazeMarkPath(m, start); }

64 65 66

static bool validCell(Maze m, Cell c) { return (

67 c.row >= 0 && c.row < MazeHeight(m) && 68 was downloadedc.col >= 0 && from c.col < MazeWidth(m) This study source by 100000857336479 CourseHero.com on 04-02-2023 06:42:13 GMT -05:00 69

);

https://www.coursehero.com/file/155377365/COMP2521-22T1-Week-07-Lab-Solutionpdf/ 70 }

solveDfs The code is the same as for solveBfs, except with queue operations replaced by stack operations.

This study source was downloaded by 100000857336479 from CourseHero.com on 04-02-2023 06:42:13 GMT -05:00

https://www.coursehero.com/file/155377365/COMP2521-22T1-Week-07-Lab-Solutionpdf/

1 2 3

#define MAX_NEIGHBOURS 4

4 5 6

static bool validCell(Maze m, Cell c);

static void fillPath(Maze m, Cell start, Cell exit, Cell **pred);

bool solve(Maze m) {

7 8

int height = MazeHeight(m); int width = MazeWidth(m);

9 10 11

bool **visited = createBoolMatrix(height, width); Cell **pred = createCellMatrix(height, width);

12 13

Stack s = StackNew();

14 15 16

Cell start = MazeGetStart(m); StackPush(s, start);

17 18 19

bool found = false; while (!found && !StackIsEmpty(s)) {

20 21

Cell v = StackPop(s);

22 23 24

if (visited[v.row][v.col]) { continue; }

25 26

visited[v.row][v.col] = true;

27 28 29

if (MazeVisit(m, v)) { fillPath(m, start, v, pred); found = true;

30 31 32

break; }

33 34

Cell adj[MAX_NEIGHBOURS] = { { .row = v.row - 1, .col = v.col

35 36 37

{ .row = v.row, .col = v.col + 1 }, // right { .row = v.row + 1, .col = v.col }, // down { .row = v.row, .col = v.col - 1 }, // left

38 39 40

}; for (int i = 0; i < MAX_NEIGHBOURS; i++) {

41 42

Cell w = adj[i]; if (validCell(m, w) && !MazeIsWall(m, w) && !visited[w.row][w.col]) {

43 44 45 46

StackPush(s, w); pred[w.row][w.col] = v; } }

47 48 49 50 51

}

52 53 54 55 56

freeCellMatrix(pred); return found;

StackFree(s); freeBoolMatrix(visited);

} static void fillPath(Maze m, Cell start, Cell exit, Cell **pred) {

57 58 59 60 61 62 63 64 65 66 67

}, // up

Cell curr = exit; while (!(curr.col == start.col && curr.row == start.row)) { MazeMarkPath(m, curr); curr = pred[curr.row][curr.col]; } MazeMarkPath(m, start); } static bool validCell(Maze m, Cell c) { return ( c.row >= 0 && c.row < MazeHeight(m) &&

68 was downloadedc.col >= 0 && from c.col < MazeWidth(m) This study source by 100000857336479 CourseHero.com on 04-02-2023 06:42:13 GMT -05:00 69 ); https://www.coursehero.com/file/155377365/COMP2521-22T1-Week-07-Lab-Solutionpdf/ 70 }

Complexity Analysis ============ solveBfs ============ - Worst case time complexity: O(n) ============ solveDfs ============ - Worst case time complexity: O(n)

COMP2521 22T1: Data Structures and Algorithms is brought to you by the School of Computer Science and Engineering at the University of New South Wales, Sydney.

For all enquiries, please email the class account at cs2521@cse.unsw.edu.au CRICOS Provider 00098G

This study source was downloaded by 100000857336479 from CourseHero.com on 04-02-2023 06:42:13 GMT -05:00

https://www.coursehero.com/file/155377365/COMP2521-22T1-Week-07-Lab-Solutionpdf/

Powered by TCPDF (www.tcpdf.org)