Basic Graph Algorithms CS 583 Analysis of Algorithms
Basic Graph Algorithms CS 583 Analysis of Algorithms 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 1
Outline • Graphs – Definitions – Representation • Breadth-First Search – Algorithm – Shortest paths – Correctness • Self-Test – 22. 1 -2, 22. 2 -1, 22. 2 -2 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 2
Graphs • Graphs are a popular data structure in computer science. – Algorithms for working with them are fundamental in the field. – There are multiple computational problems (applications) defined in terms of graphs. • A graph G=(V, E) is defined as a set of vertices (V) and edges (E). – Each edge connects two vertices. – The running time of graph algorithms is defined on the number of vertices |V| and the number of edges |E| of the graph. 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 3
Adjacency-List Representation • The adjacency-list representation: – Preferred as a compact way to represent sparse graphs. • |E| << |V|2 – Uses array Adj of size |V|. – For each u V, the adjacency list Adj[u] contains all vertices v such that there is an edge (u, v) E. – The vertices in each adjacency list are sorted in an arbitrary order. – In a directed graph the sum of the lengths of all adjacency lists is |E|. • Each edge is represented by a single element in a list. – In an undirected graph the sum is 2 |E|. • Each edge (u, v) is represented by 2 elements, <u, v> and <v, u>. 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 4
Adjacency-Matrix Representation • The adjacency-matrix representation: – May be preferred for dense graphs. • |E| is close to |V|2 – Assume all vertices are numbered 1, 2, . . . , |V| – The adjacency |V| matrix A = (aij) such that • aij = 1 if (i, j) E, 0 otherwise – The adjacency matrix requires (V 2) memory independent of the number of edges. – Define the transpose of a matrix A to be AT = (aij. T), where aij. T = aji. • In an undirected graph A = AT since both (u, v) and (v, u) represent the same edge. 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 5
Breadth-First Search • Given a graph G=(V, E) and a source vertex s, the algorithm: – Explores all edges of G to “discover” every vertex that is reachable from s. – Computes the distance (smallest number of edges) from s to each reachable vertex. – Produces a “breadth-first tree” with root s that contains all reachable vertices. • For any vertex v reachable from s the path in the tree corresponds to a “shortest path” from s to v in G. • The shortest path is a path containing the smallest number of edges. – The algorithm works on both directed and undirected graphs. 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 6
Breadth-First Search: Algorithm • Features: – Discovers all vertices at distance k before discovering any vertices at distance (k+1), -- “breadth-first”. – In the process it colors each vertex white, gray, or black: • All vertices start white. • The vertex is black if all its adjacent vertices are discovered. • The vertex is gray if it has any white adjacent vertices – It constructs a breadth-first tree starting with s as a root. • When a white vertex v is discovered when scanning an adjacency list of a discovered vertex u, the edge (u, v) is added to the tree. • Vertex u is a predecessor, or parent of the vertex v. • Ancestors and descendants are defined relative to root: – If u lies on a path from s to v, then u is an ancestor of v, and v is a descendant of u. 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 7
Breadth-First Search: Pseudocode The procedure below assumes that the graph is represented using adjacency lists. It maintains additional fields for each node: color[], predecessor [], and distance d[]. BFS(G, s) // Set up the structure for all vertices <> s 1 for each vertex u V[G] – {s} 2 color[u] = WHITE 3 d[u] = 4 [u] = NIL // Set up the structure for vertex s 5 color[s] = GRAY 6 d[s] = 0 7 [s] = NIL 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 8
Breadth-First Search: Pseudocode (cont. ) 8 9 10 11 12 13 14 15 16 17 18 // Use a queue to manage gray vertices Q = ENQUEUE(Q, s) while Q u = DEQUEUE(Q) for each v Adj[u] if color[v] = WHITE color[v] = GRAY d[v] = d[u] + 1 [v] = u ENQUEUE(Q, v) color[u] = BLACK 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 9
BFS: Invariant • The while loop 10 -18 iterates as long as there are gray vertices. – These are discovered vertices that have not yet had their adjacency lists fully explored. • The loop maintains the invariant: – At the test in line 10, the queue Q consists of the set of gray vertices. – This invariant is not used to prove correctness, but it’s easy to see that it holds. • The breadth-first tree may vary depending on the order the vertices are visited. – The distances d[] computed by the algorithm will not vary. 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 10
BFS: Performance • Running time on an input graph G=(V, E): – The test on line 13 ensures that each vertex is enqueued and dequeued at most once in (1) time. • The total time spent on all vertices is O(V). – Each adjacency list is scanned at most once. • Operation on each vertex takes (1). • The total sum of the lengths of all adjacency lists is (E). • The total time spent scanning all adjacency lists is O(E). – The initialization at lines 1 -8 is O(V). – The total running time is: • O(V) + O(E) = O(V+E) 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 11
Shorted Paths • Define the shortest-path distance (s, v) from s to v as the minimum number of edges in any path from vertex s to vertex v. – If there’s no path from s to v, then (s, v) = • A path of length (s, v) from s to v is called a shortest path from s to v. • We will show that BFS computes shortest path distances. 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 12
Shortest-Path Distance Property Lemma 22. 1 Let G=(V, E) be a directed or undirected graph, and let s V be an arbitrary vertex. Then, for any edge (u, v) E, (s, v) (s, u) + 1 Proof. If u is reachable from s, then so is v. The shortest path to v cannot be longer then the shortest path to u followed by the edge (u, v), that is inequality holds. If u is not reachable from s, then (s, u)= , and the inequality holds. 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 13
BFS Distance Computing Lemma 22. 2 Let G=(V, E) be a directed or undirected graph, and BFS runs from a vertex s. Then upon termination: d[v] (s, v)for each v V Proof. We use induction on the number (n) of ENQUEUE operations. For the basis of the induction (n=1), note that after s in enqueued in line 9, the hypothesis holds as d[s, s] = 0 = (s, s) d[v] = (s, v) for all v V-{s} 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 14
BFS Distance Computing (cont. ) For the inductive step, consider a white vertex v that is about to be enqueued in step 17 after being discovered in a search from the vertex u. d[u] (s, u) (induction assumption) d[v] = d[u] + 1 (s, u) + 1 (s, v) (from Lemma 22. 1) Vertex v is then enqueued and is never enqueued again, hence its distance never changes. Thus the inductive hypothesis is maintained. 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 15
BFS Queue Maintenance Lemma 22. 3 Suppose that during the execution of BFS the queue Q contains the vertices (v 1, v 2, . . . , vr) in that order. Then, d[vr] d[v 1] + 1 d[vi] d[vi+1], i=1, 2, . . . , r-1 Proof. We use induction on the number (n) of queue operations. When n=1 and the queue contains only s, the induction hypothesis is trivial and holds. 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 16
BFS Queue Maintenance (cont. ) For the inductive step we must prove that the lemma holds after both dequeuing and enqueuing a vertex. When a vertex is dequeued, the list becomes (v 2, . . . , vr): d[vi] d[vi+1], i=2, . . . , r-1 (induction assumption) d[vr] d[v 1] + 1 d[v 2] + 1 (as d[v 1] d[v 2] by assumption) 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 17
BFS Queue Maintenance (cont. ) When a vertex vr+1 is enqueued in line 17, the list becomes (v 1, . . . , vr+1). Note that, by that time the vertex u whose adjacency list is being scanned is removed from the queue. Hence, d[vr+1] = d[u] + 1 d[v 1] + 1 (as d[u] d[v 1] by assumption) d[vr] d[u] + 1 (by inductive assumption) = d[vr+1] The rest of inequalities are unaffected and thus the Lemma follows. 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 18
BFS Correctness Corollary 22. 4 Suppose that vertices vi and vj are enqueued during the execution of BFS and that vi is enqueued before vj. Then at the time vj is enqueued: d[vi] d[vj] Proof. Immediately follows from Lemma 22. 3 and the flow of the algorithm’s execution. (The vertex receives a value d at most once. ) 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 19
BFS Correctness (cont. ) Theorem 22. 5 During the execution of BFS for each discovered vertex v, d[v] = (s, v). Moreover, for any v s that is reachable from s, one of the shortest paths from s to v is a shortest path from s to (v), followed by the edge ( (v), v). Proof. By contradiction assume d[v] (s, v) for some v. By Lemma 22. 2 d[v] (s, v) => d[v] > (s, v) Note that v is reachable from s. (Otherwise, (s, v) = and the above inequality is not correct. ). 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 20
BFS Correctness (cont. ) Let u be a vertex immediately preceding v on a shortest path from s to v. (s, v) = (s, u) + 1 => d[v] > (s, v) = (s, u) + 1 = d[u] + 1 (d[u] = (s, u) by the way u and v are chosen) When u is dequeued in line 11, vertex v can be white, gray, or black. When v is white, d[v] = d[u] + 1 in line 15 => contradiction. When v is black, it’s already removed from the queue. By Corollary 22. 4: d[v] <= d[u] => contradiction. 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 21
BFS Correctness (cont. ) When v is gray, it was painted gray as it was discovered from an adjacency list of some vertex w that was removed from a queue earlier than u. d[v] = d[w] + 1 d[u] + 1 (d[w] <= d[u] by Corollary 22. 4) => contradiction. Hence d[v] = (s, v) for all v. To conclude the proof, note that if (v) = u, then d[v] = d[u] + 1. Thus, we can obtain a shortest path from s to v by taking a shortest path from s to (v), and then from (v) to v. 12/31/2021 CS 583 Fall'06: Basic Graph Algorithms 22
- Slides: 22