Graph Traversals. Ric Glassey

Transcription

1 Graph Traversals Ric Glassey

2 Overview Graph Traversals Aim: Develop alternative strategies to moving through a graph by visiting vertices and travelling along edges Maze example Depth-first search Breadth-First search

3 Maze Example

4 Passage Intersection You find yourself in a maze

5 Map the maze using a graph

6 Remove redundant information

7 Traversals Explore the graph by: Start at a source vertex Perform visit action on vertex Mark as vertex visited Select an edge and travel to adjacent vertex Repeat for all vertices in graph*

8 S? Exit!

9 S? 0 2 HELP!!! Exit! How can we fix this?

10 Useful Traversal Knowledge During traversal, memory can be used for: Which vertices have been visited already Maintain a list data structure Which vertices should be revisited Maintain a stack data structure Which adjacent vertices should be visited next Maintain a queue data structure

11 Depth-first Search

12 DFS Traversal Take unmarked passage Mark intersection when visited Retrace steps when approaching marked intersection Retrace steps when no options remain

13 DFS Algorithm depth first search (source vertex) Start at source vertex Mark as visited Perform visit action For all unvisited vertices adjacent to source Call depth first search (with adjacent vertex)*

14 public class DepthFirstSearch { private boolean[] marked; private int count; public DepthFirstSearch(Graph G, int s) { marked = new boolean[g.v()]; dfs(g, s); private void dfs(graph G, int v) { marked[v] = true; count++; // visit action for each V // all adjacent vertices for (int w : G.adj(v)) { if (!marked[w]) { dfs(g, w); // recursive dfs call public boolean marked(int w) { return marked[w]; public int count() { return count;

15 public class DepthFirstSearch { private boolean[] marked; private int count; public DepthFirstSearch(Graph G, int s) { marked = new boolean[g.v()]; dfs(g, s); private void dfs(graph G, int v) { marked[v] = true; count++; // visit action for each V for (int w : G.adj(v)) { if (!marked[w]) { dfs(g, w); // recursive dfs call public boolean marked(int w) { return marked[w]; public int count() { return count;

16 Breadth-first Search

17 BFS Traversal DFS will explore paths, but is not concerned with finding the shortest path (common problem) BFS explores paths, but only after selecting all of the shortest options from the source vertex

18 BFS Algorithm breadth first search (source vertex) Create a queue to store which vertex to visit next Add source to queue* For all vertices in queue: Dequeue next vertex Mark as visited Perform visit action Enqueue all unmarked adjacent vertices

19 public class BreadthFirstPaths { // Is a shortest path to this vertex known? private boolean[] marked; // last vertex on known path to this vertex private int[] edgeto; // source vertex private final int s; public BreadthFirstPaths(Graph G, int s) { marked = new boolean[g.v()]; edgeto = new int[g.v()]; this.s = s; bfs(g, s);

20 private void bfs(graph G, int s) { Queue<Integer> queue = new Queue<Integer>(); marked[s] = true; // Mark the source queue.enqueue(s); // and put it on the queue. while (!q.isempty()) { // Remove next vertex from the queue. int v = queue.dequeue(); for (int w : G.adjacent(v)) if (!marked[w]) { // For every unmarked adjacent vertex, // save last edge on a shortest path, edgeto[w] = v; // mark it because path is known, marked[w] = true; // and add it to the queue. queue.enqueue(w);

21 private void bfs(graph G, int s) { Queue<Integer> queue = new Queue<Integer>(); marked[s] = true; // Mark the source queue.enqueue(s); // and put it on the queue. while (!q.isempty()) { // Remove next vertex from the queue. int v = queue.dequeue(); for (int w : G.adjacent(v)) if (!marked[w]) { // For every unmarked adjacent vertex, // save last edge on a shortest path, edgeto[w] = v; // mark it because path is known, marked[w] = true; // and add it to the queue. queue.enqueue(w);

22 DFS & BFS Comparison

23 DFS BFS

24 DFS BFS

25 DFS BFS

26 DFS BFS

27 DFS BFS

28 DFS/BFS Observations DFS dives into the graph exploring the further reaches faster Long and winding paths BFS is more comprehensive in local exploration before moving forwards (frontline) Short and direct paths Your application may benefit from these characteristics

29 Readings Algorithms and Data Structures *required reading* Nilsson Graphs Introduction to Algorithms, 3rd Edition Corman et al Chapter 22, Elementary Graph Algorithms Algorithms 4th Edition Sedgwick & Wayne Chapter 4, Graphs

30 Survey What have been the issues with the homework: Quality of reading material Clarity of tasks Level of feedback