1. Graph and Representation

Size: px

Start display at page:

Download "1. Graph and Representation"

Blanche French
6 years ago
Views:

1 Chapter Graphs Tree Root Direction: parent-child relationships No cycles Graph Vertices + Edges No tree restrictions Examples World Wide Web Maps. Graph and Representation A graph G: a pair (V, E) vertices V edges E, each pair of vertices (v i, v j ) for v i, v j V.

2 Graph: definition (trivia) Are these graphs? A single vertex: v 0 Yes. V = {v 0, E = {. A single vertex with a self-loop edge: v 0 Yes. V = {v 0, E = {e 0. Graph: edge An edge e is directed if defined as an ordered pair of vertices (v i, v j ). A directed edge is denoted by an arrow v i v j. V i is called the source, and v j is called the destination of the edge. The number of incoming edges to a vertex is called the in-degree, and the number of outgoing edges is called the out-degree. An undirected edge e` between v i and v j is equivalent to two directed edges v i v j and v j v i.

3 Graph: path A path is a sequence v, v,,v N such that (v i, v i+ ) E for i=,,,n-. The length of a path: the number of edges on the path, i.e., N-. The path is a cycle if v v N. The path is simple if all v i, i=,,,n-, are distinct. (v v N is allowed.) Given a path v, v, v i-, v i, v i+,,v N, v, v, v i- are v i s predecessors v i+,,v N are v i s successors. 5 Graph types (/) A graph G is directed if each edge is directed. (a.k.a., digraph) A graph is weighted if each edge has a weight, i.e., E = { (v i, v j, w). A graph is acyclic if there is no cycle in any path. A graph is connected if there exists a path between any v i, v j V, i j. A directed graph is weakly connected if connected only if the direction of edges is ignored. A network is a connected weighted directed graph.

4 Graph types (/) Connected graph Weakly connected graph 7 Graph types (/) An undirected graph is completely connected if every pair of vertices has an edge connecting them. An undirected graph is minimally connected if each pair of vertices has only one path connecting them. This graph is also called a spanning tree. It has exactly N- edges for a graph of N vertices. 8

5 Graph: types (/) Completely connected graph E = V ( V -)/ = ( V ) Minimally connected graph (i.e., spanning tree) E = V - = ( V ) ( V : the number of vertices ) Graph representation: data structures v i, v j,, i j, are adjacent if there exists an edge (v i, v j ) between them. Adjacency matrix: a -dimensional array Adjacency list: an array of linked list. Preferred for a sparse graph. ( Sparser means fewer edges.) 0 5

6 Graph representation: adjacency list [] [] [5] [7] [] [] [] [] [0] [] [] [0] The order of nodes in the linked list does not matter. Graph representation: adjacency matrix Side note: We say a vertex is connected to itself only through an explicit self-loop edge, so assign 0 to the diagonal elements. to from 0 5 7

7 Graph representation: class exercise Represent the following undirected graph using the adjacency list and the adjacency matrix For an undirected graph, the number of nodes in the adjacency list and the number of bit s in the adjacency matrix are twice those for the directed graph. Graph representation: running time and storage space Adj. Matrix Adj. List Time: Adjacent(v i,v j ) ( ) O( V ) Process all edges ( V ) ( V + E ) Storage space: ( V ) ( V + E ) Adjacent(v i, v j ): O( V ) for the adjacency list because for accessing the i-th array element for v i and V - in the worst case to find v j. Example of the worst case is a completely connected graph. Storage space: ( V + E ) for the adjacency list, where V is the array size and E is for the total number of linked nodes. 7

8 . Graph traversal Algorithms Implementations Running time 5 Graph traversal: algorithms Breadth-first search (or traversal) Depth-first search (or traversal) (We consider connected graphs here.) 8

9 Graph traversal: side notes (/) Unlike tree traversal, there may be more than one path to reach a vertex. So, each time the next node is visited, it should be checked whether it has already been visited. 7 Graph traversal: side notes (/) In addition to breadth-first and depthfirst, there is also the priority-first search. In this search, each vertex or edge has a priority assigned, and the vertices are traversed in the order of the priority. 8

10 Breadth-first search void BFS(vertex v) { FIFO<vertex> queue; queue.put(v); while (queue is not empty) { w = queue.get(); if w has not been visited { visit w; mark w as visited; for each vertex t adjacent to w if t has not been visited queue.put(t); Depth-first search void DFS(vertex v) { LIFO<vertex> stack; stack.push(v); while (stack is not empty) { w = stack.pop(); if w has not been visited { visit w; mark w as visited; for each vertex t adjacent to w if t has not been visited stack.push(t); The DFS algorithm is the same as the BFS algorithm except that it uses a LIFO queue (stack) instead of a FIFO queue. 0 0

11 Graph traversal: recursive algorithms void DFS(vertex v) { visit v; mark v as visited; for each t adjacent to v if t has not been visited then DFS(t); Like the non-recursive counterpart, this recursive function should use a global array to keep track of the vertices visited. void BFS(vertex v) { // Well, it won t be as straightforward as DFS. // But, please try it if you will. Best-first Search: with Domain Knowledge

12 Exercise: BFS and DFS Breadth-first search and depth-first search starting with vertex : List the orders of vertices to be visited on (a). (a) (b) Graph traversal: implementation Both BFS and DFS algorithms can be implemented using either adjacency list or adjacency matrix as the data structure for graph.

13 Graph traversal implementation: example (/): BFS & DFS with Adj. list visited: for keeping track of the vertices visited 5 Graph traversal implementation: example (/) Exercise: Given the adjacency list, start from the vertex 0 and list the vertices visited during the BFS and DFS, respectively. Mark the visited array elements during the traversal. Answer: Vertices visited by BFS: 0,,,, 5,,. Vertices visited by DFS: 0,,,,,, 5.

14 Graph traversal: running time O( E + V ) for both BFS and DFS, if adjacency lists are used. Why? (See the next slides: running time observations.) Note: O( E + V ) ~= O( V ) for a dense graph Consider a completely connected graph, for which E = V ( V -)/ = Θ( V ). O( E + V ) ~= O( V ) for a sparse graph Consider a minimum spanning tree, for which E = V - = Θ( V ). 7 Graph traversal: running time observations (/) void BFS(vertex v) { // The same analysis for DFS. FIFO<vertex> queue; queue.put(v); while (queue is not empty) { w = queue.get(); if w has not been visited { visit w; mark w as visited; for each vertex t adjacent to w if t has not been visited queue.put(t); How many iterations? (See the next slide for observations.) 8

15 Graph traversal: running time observations (/) Part iterates E times. Each edge is traversed exactly once. It iterates Θ( V ) times for a dense graph and Θ( V ) times for a sparse graph as Θ( E ) = Θ( V ) for a dense graph Θ( E ) = Θ( V ) for a sparse graph. Part iterates V times as it is executed only once for each vertex. In Part, queue.put(t) iterates Θ( E ) times the total number of edges adjacent to each vertex is E for an undirected graph or E for a directed graph.. Topological sort Given a directed acyclic graph(dag) G = (V, E), a topological sort orders the vertices in a topological order so that: for any v i,v j V (i j), v j appears after v i in the ordering if there exists a path from v i to v j. 0 5

16 Topological sort: algorithm Topological_sort (graph G) { repeat { find a vertex v with no incoming edge in G; break if not found; output v as the next vertex in the sorted order; remove the vertex v and its outgoing edges from G; If G is not empty then error; Q. What does this error mean? A. There is a cycle in the graph, as every vertex in the remaining G has an incoming edge. Topological sort: example Topologically sort the vertices in the following DAG. v v v v v 5 v v 7 The resulting topological order is either <v, v, v 5, v, v, v 7, v > or <v, v, v 5, v, v 7, v, v >.

17 Topological sort: algorithm (pseudo-code) Add an in-degree field and a topological_order field in each vertex. Use a FIFO queue to keep the vertices with zero in-degree. We may use a stack (i.e., LIFO queue) instead. Topological_sort(graph G, FIFO queue) { counter = 0; for each vertex v in G if (v.indegree == 0) then queue.put(v); while queue is not empty { v = queue.get(); v.topological_order = ++ counter; for each vertex w adjacent to v { w.indegree = w.indegree ; if (w.indegree == 0) then queue.put(w); Topological sort: example G: Use an adjacency list (with in-degree and topological order stored in the array) for the graph G. v v v in- topological deg order v v v v v v v v v 5 5 v v v v 7 v v v v 7 v 5 v v 7 v Queue: v 7 v The resulting topological order is either <v, v, v 5, v, v, v 7, v > or <v, v, v 5, v, v 7, v, v >. 7

18 Topological sort: exercise Use an adjacency list to represent the graph. c f h a b d g i j e The result varies depending on the order of nodes in the adjacency list. 5 Topological sort: running time O( V + E ) Topological_sort(graph G, FIFO queue) { counter = 0; for each vertex v in G if (v.indegree == 0) then queue.put(v); while queue is not empty { v = queue.get(); v.topological_order = ++ counter; for each vertex w adjacent to v { w.indegree = w.indegree ; if (w.indegree == 0) then queue.put(w); Total O( V ) times Total V times Total E times 8

19 . Shortest path problems a.k.a. network Given a connected weighted directed graph, Single source single destination shortest path problem: Given a source vertex and a destination vertex, find a shortest path between them. Single source shortest paths problem: Given a source vertex, find a shortest path from it to each of the other vertices. (We consider this problem here.) All pairs shortest paths problem: Find a shortest path between each pair of vertices. 7 Source: Clifford Shaffer Shortest path: examples Shortest(A,E) Shortest(A,x) where x {B,C,D,E Shortest(x,y) where x, y {A,B,C,D,E and x y A 0 B 0 C 5 5 D E 8

20 Shortest path tree: definition Given a connected weighted directed graph, a shortest path tree (SPT) from a vertex s is a directed tree rooted at s each tree path from s to another vertex vis the shortest among all possible paths from s to v. Shortest path tree: example Build a shortest path tree from vertex A. A E 7 5 C D B F 0 0

21 Dijkstra s algorithm: concept Solves the single source shortest paths problem for a connected weighted directed graph with nonnegative weights. Is a greedy algorithm. Chooses the next step with the immediate biggest benefit (or, smallest cost). May end up finding only a local optimum. Dijkstra s algorithm: outline (/). Include the source in the SPT.. Build the SPT one edge at a time. Take next an edge that gives the shortest path from the source to a vertex not yet in the SPT. (I.e., add vertices to the SPT in order of their distance (through the SPT) from the start vertex.) (Source: Robert Sedgewick)

22 Dijkstra s algorithm: outline (/) A bookkeeping table for each vertex: Whether the vertex has been included in the SPT. The distance from the source to the vertex. The predecessor in the path from the source to the vertex. Two kinds of data structures for the bookkeeping table Bk. Array<VtxInfo> Bk[NUM_VERTICES]. Priority queue <VtxInfo> Bk. where VtxInfo has three fields: { Bool included; float distance; Vertex predecessor;. Dijkstra s algorithm: pseudo code void Dijkstra(Vertex s) { for each vertex t { // initialize the vertex information t.included = false; t.distance = ; t.predecessor = null; s.distance = 0; repeat { Find the vertex v with the smallest distance from the source s among those not included in the SPT yet; If not found break; // If all vertices have been included then we re done. else v.included = true; // mark v as included (i.e., chosen) for each vertex w adjacent to v { if (!w.included and (v.distance + weight(v,w) < w.distance)) { decrease w.distance to v.distance+weight(v,w); w.predecessor = v; // add (v,w) as a candidate If w had a different predecessor, u, then w.predecessor = v replaces it with v. That is, discard the candidate (u,w) and add a new candidate (v,w).

23 Dijkstra s algorithm: example (/) Start vertex: A Ack: Clifford Shaffer for the graph chosen candidate discarded A C B D F E 7 5 A C B D F E E A C B D F A C B D F E A C B D F E A C B D F E Dijkstra s algorithm: example (/) A C B D F E A C B D F E

24 Dijkstra s algorithm: analysis Repeated V times Repeated V times Repeated O( E ) times void Dijkstra(Vertex s) { for each vertex t { // initialize the vertex information t.included = false; t.distance = ; t.predecessor = null; s.distance = 0; repeat { Find the vertex v with the smallest distance from the source s among those not included in the SPT yet; If not found break; // If all vertices have been included then we re done. else v.included = true; // mark v as included (i.e., chosen) for each vertex w adjacent to v { if (!w.included and (v.distance + weight(v,w) < w.distance)) { decrease w.distance to v.distance+weight(v,w); w.predecessor = v; // add (v,w) as a candidate Repeated E times The running time varies depending on the implementation of the blue lines. 7 Dijkstra s algorithm implementation using an array void Dijkstra(int s) { for each vertex Bk[t] (t [0, V -]) { // initialize the vertex information Bk[t].included = false; Bk[t].distance = ; Bk[t].predecessor = null; // Θ() Bk[s].distance = 0; repeat { min_distance = ; for each vertex Bk[v] (v [0, V -]) { if (!Bk[v].included && Bk[v].distance < min_distance) { min_distance = Bk[v].distance; min_v = Bk[v]; If (min_distance = ) break; // not found else min_v.included = true; // mark v as included. for each vertex Bk[w] adjacent to min_v { ( V ) if (!Bk[w].included and (min_v.distance + weight(min_v, w) < Bk[w].distance)) { Bk[w].distance = min_v.distance+weight(min_v,w); // Θ() Bk[w].predecessor = min_v; 8

25 Dijkstra s algorithm implementation using an array: running time O( V + V V + E ) = O( V + E ) = O( V ) ( V - E ( V -) V /) = O( E ) if the graph is dense O( E ) if the graph is sparse Using a priority queue is a better implementation (not covered in this course, with O( E log E ) ) if the graph is sparse. Chapter Graphs: Summary. Definitions and Representation (Section.). Graph traversal algorithms (Section.). Topological sort algorithm (Section.). The shortest path problems (Section.) 5. Other Topics (Not Covered in Class) Network flow algorithms (Section.) Minimum spanning tree algorithms (Section.5) 50 5

Basic Graph Definitions

CMSC 341 Graphs Basic Graph Definitions A graph G = (V,E) consists of a finite set of vertices, V, and a finite set of edges, E. Each edge is a pair (v,w) where v, w V. V and E are sets, so each vertex