E.G.M. PetrakisGraphs1  Graph G(V,E): finite set V of nodes (vertices) plus a finite set E of arcs (or edges) between nodes  V = {A, B, C, D, E, F, G}

Slides:



Advertisements
Similar presentations
Lecture 15. Graph Algorithms
Advertisements

IKI 10100: Data Structures & Algorithms Ruli Manurung (acknowledgments to Denny & Ade Azurat) 1 Fasilkom UI Ruli Manurung (Fasilkom UI)IKI10100: Lecture10.
CS 206 Introduction to Computer Science II 03 / 27 / 2009 Instructor: Michael Eckmann.
Chapter 8, Part I Graph Algorithms.
Data Structures Using C++
Graph II MST, Shortest Path. Graph Terminology Node (vertex) Edge (arc) Directed graph, undirected graph Degree, in-degree, out-degree Subgraph Simple.
Graph.
Graph & BFS.
1 Graphs: shortest paths & Minimum Spanning Tree(MST) Fundamental Data Structures and Algorithms Ananda Guna April 8, 2003.
E.G.M. PetrakisGraphs1  Graph G(V,E): finite set V of nodes (vertices) plus a finite set E of arcs (or edges) between nodes  V = {A, B, C, D, E, F, G}
CS 311 Graph Algorithms. Definitions A Graph G = (V, E) where V is a set of vertices and E is a set of edges, An edge is a pair (u,v) where u,v  V. If.
1 Data Structures and Algorithms Graphs I: Representation and Search Gal A. Kaminka Computer Science Department.
Greedy Algorithms Reading Material: Chapter 8 (Except Section 8.5)
Graphs. Graphs Many interesting situations can be modeled by a graph. Many interesting situations can be modeled by a graph. Ex. Mass transportation system,
Chapter 9 Graph algorithms Lec 21 Dec 1, Sample Graph Problems Path problems. Connectedness problems. Spanning tree problems.
CSE 780 Algorithms Advanced Algorithms Graph Algorithms Representations BFS.
CS Data Structures Chapter 6 Graphs.
Greedy Algorithms Like dynamic programming algorithms, greedy algorithms are usually designed to solve optimization problems Unlike dynamic programming.
More Graph Algorithms Weiss ch Exercise: MST idea from yesterday Alternative minimum spanning tree algorithm idea Idea: Look at smallest edge not.
Review of Graphs A graph is composed of edges E and vertices V that link the nodes together. A graph G is often denoted G=(V,E) where V is the set of vertices.
C o n f i d e n t i a l HOME NEXT Subject Name: Data Structure Using C Unit Title: Graphs.
GRAPHS Education is what remains after one has forgotten what one has learned in school. Albert Einstein Albert Einstein Smitha N Pai.
IS 2610: Data Structures Graph April 5, 2004.
Graphs CS 400/600 – Data Structures. Graphs2 Graphs  Used to represent all kinds of problems Networks and routing State diagrams Flow and capacity.
Course notes CS2606: Data Structures and Object-Oriented Development Graphs Department of Computer Science Virginia Tech Spring 2008 (The following notes.
UNCA CSCI November, 2001 These notes were prepared by the text’s author Clifford A. Shaffer Department of Computer Science Virginia Tech Copyright.
Graphs. Motivating Problem Konigsberg bridge problem (1736): Konigsberg bridge problem (1736): C A B D ab c d e f g Starting in one land area, is it possible.
Copyright Networking Laboratory Chapter 6. GRAPHS Horowitz, Sahni, and Anderson-Freed Fundamentals of Data Structures in C, 2nd Edition Computer.
Been-Chian Chien, Wei-Pang Yang, and Wen-Yang Lin 6-1 Chapter 6 Graphs Introduction to Data Structure CHAPTER 6 GRAPHS 6.1 The Graph Abstract Data Type.
Chapter 9 – Graphs A graph G=(V,E) – vertices and edges
Chapter 2 Graph Algorithms.
Chapter 14 Graphs. © 2004 Pearson Addison-Wesley. All rights reserved Terminology G = {V, E} A graph G consists of two sets –A set V of vertices,
CS200 Algorithms and Data StructuresColorado State University Part 10. Graphs CS 200 Algorithms and Data Structures 1.
Graphs. What is a graph? A data structure that consists of a set of nodes (vertices) and a set of edges that relate the nodes to each other The set of.
Nyhoff, ADTs, Data Structures and Problem Solving with C++, Second Edition, © 2005 Pearson Education, Inc. All rights reserved Graphs.
Elementary Graph Algorithms CLRS Chapter 22. Graph A graph is a structure that consists of a set of vertices and a set of edges between pairs of vertices.
Graphs. Definitions A graph is two sets. A graph is two sets. –A set of nodes or vertices V –A set of edges E Edges connect nodes. Edges connect nodes.
10 Copyright © William C. Cheng Data Structures - CSCI 102 Graph Terminology A graph consists of a set of Vertices and a set of Edges C A B D a c b d e.
Graphs. Graphs Similar to the graphs you’ve known since the 5 th grade: line graphs, bar graphs, etc., but more general. Those mathematical graphs are.
CMSC 341 Graphs. 8/3/2007 UMBC CMSC 341 Graphs 2 Basic Graph Definitions A graph G = (V,E) consists of a finite set of vertices, V, and a finite set of.
1 Directed Graphs Chapter 8. 2 Objectives You will be able to: Say what a directed graph is. Describe two ways to represent a directed graph: Adjacency.
E.G.M. PetrakisGraphs1 Graph G(V,E): finite set V of nodes (vertices) plus a finite set E of arcs (or edges) between nodes –V = {A, B, C, D, E, F, G} –E.
– Graphs 1 Graph Categories Strong Components Example of Digraph
Graphs 2015, Fall Pusan National University Ki-Joune Li.
Graphs and Paths : Chapter 15 Saurav Karmakar
Graph Searching CSIT 402 Data Structures II. 2 Graph Searching Methodology Depth-First Search (DFS) Depth-First Search (DFS) ›Searches down one path as.
Data Structures and Algorithm Analysis Graph Algorithms Lecturer: Jing Liu Homepage:
Lecture #13. Topics 1.The Graph Abstract Data Type. 2.Graph Representations. 3.Elementary Graph Operations.
1 GRAPHS – Definitions A graph G = (V, E) consists of –a set of vertices, V, and –a set of edges, E, where each edge is a pair (v,w) s.t. v,w  V Vertices.
1 Data Structures and Algorithms Graphs. 2 Graphs Basic Definitions Paths and Cycles Connectivity Other Properties Representation Examples of Graph Algorithms:
CMSC 341 Graphs. 2 Basic Graph Definitions A graph G = (V,E) consists of a finite set of vertices, V, and a set of edges, E. Each edge is a pair (v,w)
BCA-II Data Structure Using C Submitted By: Veenu Saini
Data Structures 13th Week
COMP108 Algorithmic Foundations Greedy methods
Minimum Spanning Trees and Shortest Paths
Introduction to Graphs
CS202 - Fundamental Structures of Computer Science II
Graphs Graph transversals.
CSE 373 Data Structures and Algorithms
Graphs.
What is a Graph? a b c d e V= {a,b,c,d,e} E= {(a,b),(a,c),(a,d),
CSCI 333 Graphs Chapter 11 20, 22, and 25 November 2002.
Chapter 11 Graphs.
CMSC 341 Lecture 20.
2017, Fall Pusan National University Ki-Joune Li
GRAPHS G=<V,E> Adjacent vertices Undirected graph
CSE 373: Data Structures and Algorithms
GRAPH – Definitions A graph G = (V, E) consists of
INTRODUCTION A graph G=(V,E) consists of a finite non empty set of vertices V , and a finite set of edges E which connect pairs of vertices .
Presentation transcript:

E.G.M. PetrakisGraphs1  Graph G(V,E): finite set V of nodes (vertices) plus a finite set E of arcs (or edges) between nodes  V = {A, B, C, D, E, F, G}  E = {AA, AB, AD, CD, DE, BF, EF, FG, EG } A B G C E F D

E.G.M. PetrakisGraphs2 Terminology  Two vertices are adjacent if they are connected with an edge  Adjacent or neighbor vertices  Subgraph of G=(V,E): a graph G’=(V’,E’) where V’, E’ are subsets of V, E  |V|,|E|: number of nodes, edges of G  Complete graph: contains all possible edges  |E| in Θ(|V| 2 )

E.G.M. PetrakisGraphs3 Undirected Graphs  The edges are not directed from one vertex to another G E H A B C F D

E.G.M. PetrakisGraphs4 Directed Graphs  The edges are directed from one vertex to another G E H A B C F D

E.G.M. PetrakisGraphs5 G E A BC FD A D BC

E.G.M. PetrakisGraphs6 More Definitions  Vertex degree: maximum number of incoming or outgoing edges  in-degree: number of incoming edges  out-degree: number outgoing edges  Relation R on A: R = { | x, y ∊ N}  x < y  x mod y = odd  Labeled graph: labels on vertices or edges  Weighted graph: weights on edges

E.G.M. PetrakisGraphs relation weighted

E.G.M. PetrakisGraphs8 Paths  There exist edges connecting two nodes  Length of path: number of edges  Weighted graphs: sum of weights on path  Cycle: path (of length 3 or more) connecting a vertex with itself  Cyclic graph: contains cycle  Acyclic graph: does not contain cycle  DAG: Directed Acyclic Graph

E.G.M. PetrakisGraphs9 Connected Graphs  An undirected graph is connected if there is a path between any two vertices  Connected components: maximally connected subgraphs

E.G.M. PetrakisGraphs10 Operations on Graphs  join (a,b)  join (a,b,x)  remv[wt] (a,b,x)  adjacent (a,b) a b a b a b a b x a b c adjacent (a,b) = true adjacent (a,c) = false a b a b

E.G.M. PetrakisGraphs11 Build a Graph read(n);// number of nodes read and create n nodes label them from 1.. n while not eof(..) { read(node 1, node 2, w 12 ); joinwt(node 1, node 2, w 12 ); } any graph algorithm

E.G.M. PetrakisGraphs12 Representation of Directed Graphs directed graph adjacency matrix adjacency list

E.G.M. PetrakisGraphs13 Representation of Undirected Graphs undirected graph adjacency list adjacency matrix

E.G.M. PetrakisGraphs14 Matrix Implementation  Simple but difficult to process edges, unused space in matrix  mark: 1D array marking vertices  mark[i] = 1 if vertex i has been visited  typedef int * Edge;  matrix: the actual Graph implemented as an 1D array of size n 2  edge (i, j) is found at matrix[i * n + j]  if edge exists matrix[i * n + j] = wt  otherwise matrix[i * n + j] = NOEDGE

E.G.M. PetrakisGraphs15 Graph class: Adjacency Matrix template class Graph { private: Edge* matrix;// the edge matrix int numVertex, numEdge;// number of vertices, edges bool* Mark;// the mark array public: Graph( ); ~Graph( ); // constructor, destructor int n( ), e ( )// number of vertices, edges Edge first(int);// get the first edge for a vertex bool isEdge(Edge);// TRUE if this is an edge Edge next(Edge);// get next edge for a vertex int v1(Edge), v2(Edge)// vertex edge comes from, goes to int weight(int, int);// return weight of edge int weight(Edge);// return weight of edge };

E.G.M. PetrakisGraphs16 Constructor, Destructor template Graph ::Graph( ) { mark = NULL; matrix = NULL; } template Graph ::~Graph( ) { if (mark != NULL) delete [ ] mark; if (matrix != NULL) delete [ ] matrix; }

E.G.M. PetrakisGraphs17 Member Functions template int Graph ::n( ) { return numVertex; } template int Graph ::e( ) { return numEdge; }

E.G.M. PetrakisGraphs18 Member Functions (cont.) template Edge Graph ::first(int v) {//first edge of node int stop = (v+1) * numVertex; // pos. at end of v’s row for ( int pos = v * numVertex; pos < stop; pos++) //scans entire row if ( matrix[pos] != NOEDGE) return &matrix[pos]; return NULL; }

E.G.M. PetrakisGraphs19 Member Functions (cont.) template bool Graph ::isEdge(Edge w) { return w != NULL; } template Edge Graph ::next(Edge w) { // next edge of (w,0) int stop = (v1(w) + 1) * numVertex; // pos at end of row for (int pos = (w – matrix) + 1; pos < stop; pos++) if (matrix[pos] != NOEDGE)return &matrix[pos]; return NULL; }

E.G.M. PetrakisGraphs20 Member Functions (cont.) template int Graph ::v1(Edge w) // 1 st vertex of edge { return ( w – matrix ) / numVertex; } template int Graph ::v2(Edge w) // 2 nd vertex edge { return ( w – matrix ) % numVertex; }

E.G.M. PetrakisGraphs21 Member Functions (cont.) template int Graph ::weight( int i, int j) {// return weight of edge if ( matrix[ i * numVertex + j ] == NOEDGE ) return INFINITY; else return matrix[ i * numVertex + j ]; } template int Graph ::weight(Edge w) {// return weight of edge if ( * w == NOEDGE ) return INFINITY; else return * w; }

E.G.M. PetrakisGraphs22 Graph Class: Adjacency List template class Graph { private: Edge * list;// the vertex list int numVertex;// number of vertices int numEdge;// number of edges bool * Mark;// the mark array public: Graph( ); ~Graph( ); // constructor, destructor int n( ), e( );// number of vertices, edges Edge first(int);// get the first edge of vertex bool isEdge(Edge);// TRUE if this is an edge Edge next(Edge);// get next edge for a vertex int v1(Edge), v2(Edge);// return vertex edge comes from, goes to int v2(Edge);// return vertex edge goes to int weight(int, int),// return weight of edge int weight(weight);// return weight of edge };

E.G.M. PetrakisGraphs23 A Singly-Linked List Node  class EdgeLink { public: int weight;// edge weight int v1;// 1 st vertex of edge int v2; // 2 nd vertex of edge EdgeLink * next;// pointer to next edge in list EdgeLink(int vt1, int vt2, int w, EdgeLink * nxt = NULL) // constructor { v1 = vt; v2 = vt2; weight = w; next = nxt; } };  Graph g;

E.G.M. PetrakisGraphs24 Member Functions template Graph ::Graph( ) {// constructor Mark = NULL;list = NULL; } template Graph ::~Graph( ) {// destructor: return allocated space if (Mark != NULL) delete [ ] Mark; if (list != NULL) {// remove all of the edges for (int v = 0; v < n( ); v++)// for each vertex return all edges while (list[v] != NULL) { list[v]= list[v]  next; delete temp; } delete [ ] list;// remove the vertex list headers }

E.G.M. PetrakisGraphs25 Member Functions (cont.) template int Graph ::n( ) { return numVertex; } // number of vertices template int Graph ::e( ) { return numEdge; } // number of edges template Edge Graph ::first(int v) // get the first edge {return list[v]; } template bool Graph ::isEdge(Edge w) // TRUE if it is an edge { return w != NULL; }

E.G.M. PetrakisGraphs26 Member Functions (cont.) template Edge Graph ::next(Edge w) {// get next edge for a vertex if (w == NULL) return NULL; else return w  next; } template int Graph ::v1(Edge w)// return vertex edge comes from { return w  v1; } template int Graph ::v2(Edge w)// return vertex edge goes to { return w  v2; }

E.G.M. PetrakisGraphs27 Member Functions (cont.) template int Graph ::weight( int i, int j) {// return weight of edge for (Edge curr = list[i]; curr != NULL; curr = curr->next) if (curr  v2 == j ) return curr-> weight; return INFINITY; } template int Graph ::weight(Edge w) {// return weight of edge if ( w == NULL ) return INFINITY; else return w -> weight; }

E.G.M. PetrakisGraphs28 A Better Implementation ndptr: pointer to adjacent node nextarc: pointer to next edge arcptrinfonextnode info: data arcptr: pointer to an adjacent node nextnode: pointer to a graph node ndptrnextarc E A B C D

E.G.M. PetrakisGraphs29 AΒ nilnil CDE nilnil nilnil nilnil nilnil nilnil graph

E.G.M. PetrakisGraphs30 Graph Traversal  Trees  preorder  inorder  postorder  Graphs  Depth First Search (DFS)  Breadth First Search (BFS)

E.G.M. PetrakisGraphs31 Depth First Search (DFS)  Starting from vertex v, initially all vertices are “ unvisited ”  void DFS(v) { Mark(v) = true; for each vertex w adjacent to v if (!Mark(w)) DFS(w) }

E.G.M. PetrakisGraphs32 Complexity of DFS  O(|V| + |E|): adjacency list representation  O(|V| 2 ) in dense graphs  O(|V| 2 ): matrix representation

E.G.M. PetrakisGraphs33 DFS : V 1 V 2 V 4 V 8 V 5 V 6 V 3 V 7 v = v 1 v1v1 v2v2 v3v3 v4v4 v5v5 v6v6 v7v7 v8v8 v3v3 v2v2 v1v1 v6v6 v5v5 v4v4 v8v8 v7v

E.G.M. PetrakisGraphs34 Breadth-First Search (BFS) ΒFS : V 1 V 2 V 3 V 4 V 5 V 6 V 7 V 8 v = v 1 v1v1 v2v2 v3v3 v4v4 v5v5 v6v6 v7v7 v8v8

E.G.M. PetrakisGraphs35 BFS (cont.)  Starting from vertex v, all nodes “ unvisited ”, visit adjacent nodes (use a queue) void DFS(v) { visited(v) = true; enqueue(v, Q); while ( Q ≠ 0 ) { x = dequeue(Q); for each y adjacent x do if ! Mark(y) { Mark(y) = TRUE; enqueue(y,Q); }

E.G.M. PetrakisGraphs36 v1v1 front rear v3v3 v2v2 front rear output(v 1 ) v3v3 front rear v5v5 v4v4 output(v 2 ) output(v 3 ) v4v4 front rear v7v7 v5v5 v6v6 v5v5 front rear v8v8 v6v6 v7v7 output(v 4 ) v6v6 front v7v7 v8v8 output(v 5 ) v6v6 front v8v8 output(v 6 ) output(v 7 ) v = v 1 v1v1 v2v2 v3v3 v4v4 v5v5 v6v6 v7v7 v8v8

E.G.M. PetrakisGraphs37 Complexity of BFS  O(|V|+|E|) : adjacency list representation  d 1 + d d n = |E|  d i = degree (v i )  O(|V| 2 ) : adjacency matrix representation

E.G.M. PetrakisGraphs38 DFS Algorithm template void DFS (Graph & G, int v) { action(G,v); G.Mark[v] = VISITED; for ( Edge w = G.first(v); G.isEdge(w); w = G.next(w)) if (G.Mark[G.v 2 (w)] = = UNVISITED) DFS ( G, G.v 2 (w)); action(G,v); }

E.G.M. PetrakisGraphs39 BFS Algorithm template void BFS (Graph & G, int start) { Queue Q(G.n( )); Q.enqueue(start); G.Mark[start] = VISITED; While ( !Q.isempty( )){ int v = Q.dequeue( ); action(G,v); for ( Edge w = G.first(v); G.isEdge(w); w = G.next(w)) if (G.Mark[G.v 2 (w)] = = UNVISITED) { G.Mark[G.v 2 (w)] = VISITED; Q.enqueue(G.v 2 (w)); } action(G,v); }

E.G.M. PetrakisGraphs40 Connected - Unconnected A BC D E connected components E F G A B C D connected graph: undirected graph, there is a path connecting any two nodes unconnected graph: not always a path

E.G.M. PetrakisGraphs41 Connected Components  If there exist unconnected nodes in a DFS or BFS traversal of G then G is unconnected  Find all connected components: void COMP(G, n) { for i = 1 to n if Mark(i) == UNVISITED then DFS(i) [or BFS(i)]; }  Complexity: O(|V| + |E|)

E.G.M. PetrakisGraphs42 Spanning Trees (G,E) Tree formed from edges and nodes of G Spanning Tree

E.G.M. PetrakisGraphs43 Spanning Forest  Set of disjoint spanning trees T i of G=(V,E)  T i = ( V i, E i ) 1≤ i ≤ k, V i,E i :subsets of V, E  DFS produces depth first spanning trees or forest  BFS breadth first spanning trees or forest  Undirected graphs provide more traversals  produce less but short spanning trees  Directed graphs provide less traversals  produce more and higher spanning trees

E.G.M. PetrakisGraphs44 DFS DFS spanning tree D BC E A DFS C B DE A C BF E A G D D C EGF B A DFS spanning forest

E.G.M. PetrakisGraphs45 BFS BFS spanning tree ΒFS E BC F A D GE BC F A D G BFS spanning forest C BF E A H D C H DE F B A ΒFS

E.G.M. PetrakisGraphs46 Min. Cost Spanning Tree cost T = Prim’s algorithm: Complexity O(|V| 2 )

E.G.M. PetrakisGraphs47 Prim’s Algorithm template void Prim(Graph & G, int s){/ /prim’s MST algorithm int D[G.n( )];// distance vertex int V[G.n( )];// who’s closest for (int i=0; i<G.n( ); i++); D[i] = INFINITY; // initialize D[s] = 0; for ( i=0; i<G.n( ); i++){// process the vertices int v = minVertex(G, D); G.Mark[v] = VISITED; if ( v != s ) AddEdgetoMST(V[v], v);// add this edge to MST if (D[v] = = INFINITY ) return;// unreachable vertices for ( Edge w = G.first(v); G.isEdge(w); w = G.next(w)) if (D[G.v2(w)] > G.weight(w)) { D[G.v2(w)] = G.weight(w);// update distance and V[G.v2(w)] = v;// who it came from }

E.G.M. PetrakisGraphs48 Prim’s Algorithm (cont.) template ){ // find min cost vertex void minVertex(Graph & G, int* D int v; for (int i = 0; i < G.n( ); i++)// initialize if (G.Mark[i] = = UNVISITED){ v = i; break; } for ( i=0; i<G.n( ); i++)// find smallest value if ((G.Mark[i] = = UNVISITED) && ( D[i] < D[v] )) v = i; return v; }

E.G.M. PetrakisGraphs49 Dijkstra’s Algorithm  Find the shortest path from a given node to every other node in a graph G  no better algorithm for single ending node  Notation:  G = (V,E) : input graph  C[i,j] : distance between nodes i, j  V : starting node  S : set of nodes for which the shortest path from v has been computed  D(W) : length of shortest path from v to w passing through nodes in S

E.G.M. PetrakisGraphs starting point: v = 1 stepSWD(2)D(3)D(4)D(5) 1{1}-10i nfinite {1,2} {1,2,4} {1,2,4,3} {1,2,4,3,5}

E.G.M. PetrakisGraphs51 Dijkstra’s Algorithm (cont.) Dijkstra(G: graph, int v) { S = {1}; for i = 2 to n D[i] = C[i,j]; while (S != V) { choose w from V-S: D[w] = minimum S = S + {w}; for each v in V–S: D[v] = min{D[v], D[w]+[w,v]}*; } * If D[w]+C[w,v] < D[v] then P[v] = w: keep path in array

E.G.M. PetrakisGraphs52 Compute Shortest Path template void Dijkstra(Graph & G, int s) { int D[G.n( )]; for (int i=0; i < G.n( ); i++) // initialize D[i] = INFINITY; D[s] = 0; for (i = 0; i < G.n( ); i++) { // process the vertices int v = minVertex(G, D); if (D[v] == INFINITY) return; // remaining vertices unreachable G.setMark(v, VISITED); for (Edge w = G.first(v); G.isEdge(w); w = G.next(w)) if (D[G.v2(w)] > (D[v] + G.weight(w))) D[G.v2(w)] = D[v] + G.weight(w); }

E.G.M. PetrakisGraphs53 Find Min. Cost Vertex template int minVertex(Graph & G, int* D) { int v; for (int i = 0; i < G.n( ); i++) if (G.getMark(i) == UNVISITED) { v = i; break; } for (i++; i < G.n( ); i++) // find smallest D value if ((G.getMark(i) == UNVISITED) && (D[i] < D[v])) v = i; return v; }  minVertex: scans through the list of vertices for the min. value  O(|V|) time  Complexity: O(|V| 2 + |E|) = O(|V| 2 ) since O(|E|) is O(|V| 2 )