1 / 46

Graphs

B. F. G. A. C. D. E. Graphs. 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 }. Terminology. Two vertices are adjacent if they are connected with an edge

anitra
Download Presentation

Graphs

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. B F G A C D E Graphs • 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 } Graphs

  2. Terminology • Two vertices are adjacent if they are connected with an edge • 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 and edges of G • Complete graph: contains all possible edges • |E| in Θ(|V|2) Graphs

  3. B C A G E D H F • Undirected graphs: the edges are not directed • from one vertex to another Graphs

  4. B C A G E D H F Directed Graphs: the edges are directed Graphs

  5. A A B C B C D D E F G Graphs

  6. Vertex degree : maximum number of incoming or outgoing edges. • In-degree: number of incoming edges • Out-degree: number outgoing edges • RelationRonA: R = {<x,y>| x,y ∊ N} • x < y • x mod y = odd • Labeled graph: labels are associated to vertices or edges • Weighted graph: weights on edges Graphs

  7. 1 3 Relation 10 3 Weighted 10 7 3 1 5 8 5 8 17 17 1 5 6 6 Graphs

  8. Vertices (V1,V2,…Vn) form a path if there exist edges from Vi to Vi+1 for 1<= i <= n • V1,V2,…Vn :adjacent • 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 Graphs

  9. 7 0 2 6 4 5 3 1 • An undirected graph is connected if there is at least one path between any two vertices • Connected components: maximally connected subgraphs • Free tree of graph: connected, undirected, acyclic subgraph of the graph • A free tree has |V| nodes and |V|-1 edges Graphs

  10. a a b b a a b b x x a b a b a b c Operations on graphs • join (a,b) • join (a,b,x) • remv[wt] (a,b,x) • adjacent (a,b) adjacent (a,b) = true adjacent (a,c) = false Graphs

  11. Build Graphs read(n); // number of nodes read and create n nodes label them from 1 .. n While not eof(..) { read(node1, node2, w12); joinwt(node1, node2, w12); } any graph algorithm Graphs

  12. 0 1 2 3 4 Directed Graph 0 2 0 1 1 1 1 4 2 1 1 3 3 1 4 1 adjacency matrix 0 1 4 1 3 2 4 3 2 adjacency list 4 1 Representation of Directed Graphs Graphs

  13. 0 1 2 3 4 Undirected Graph 0 1 1 0 2 1 1 1 1 2 1 1 4 3 1 1 1 4 1 1 1 3 Adjacency Matrix 0 1 4 1 0 3 4 2 3 4 3 1 2 Adjacency List 4 0 1 2 Representation of Undirected Graphs Graphs

  14. Graph Implementation • Matrix representation, Adjacency list • simple implementation • difficult to process edges • unused space in matrix • auxiliary functions and structures • Mark: 1D array marking vertices • Mark[i] = 1 if vertex i has been processed (visited) • typedef int *Edge; • matrix: the actual Graph implemented as an 1D array of size n2 • edge (i, j) is found at matrix[i*n + j] • if edge exists matrix[i*n + j] = wt • otherwise matrix[i*n + j] = NOEDGE Graphs

  15. Class Graph { //Graph class: Adjacency matrix private: int* matrix; //The edge matrix int numVertex; //Number of vertices int numEdge; //Number of edges bool* Mark; //The mark array public: Graph( ); //Constructor ~Graph( ); //Destructor int n( ); //Number of vertices for graph int e( ); //Number of edges for graph 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); //Return vertex edge comes from int v2(Edge); //Return vertex edge goes to int weight(int, int); //Return weight of edge int weight(Edge); //Return weight of edge } Graphs

  16. Graph::Graph( ) { //Constructor Mark = NULL; matrix = NULL;//plus code for creating graph } Graph::~Graph( ) { //Destructor: return allocated space if (Mark != NULL) delete [ ] Mark; if (matrix != NULL) delete [ ] matrix; } int Graph::n( ){ return numVertex; } //Num. of vertices for the graph int Graph::e( ) //Number of edges { return numEdge; } Edge Graph::first(int v) { //Get the first edge for a vertex int stop = (v+1) * numVertex; //Position 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; } Graphs

  17. bool Graph::isEdge(Edge w) //TRUE if (w,0) is an edge { return w != NULL; } Edge Graph::next(Edge w) { //Get next edge of (w,0) int stop = (v1(w) + 1) * numVertex; //Position at end of row for (int pos = (w – matrix) + 1; pos < stop; pos++) if (matrix[pos] != NOEDGE) return &matrix[pos]; return NULL; } int Graph::v1(Edge w) //Return 1st vertex of edge { return ( w – matrix ) / numVertex; } //Pointer arithmetic int Graph::v2(Edge w) //Return 2nd vertex edge { return ( w – matrix ) % numVertex; } //Pointer arithmetic 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 ]; } int Graph::weight(Edge w) { //Return weight of edge if ( *w = = NOEDGE ) return INFINITY; else return *w; } Graphs

  18. Class Graph { //Graph class: Adjacency list private: Edge *list; //The vertex list int numVertex; //Number of vertices int numEdge; //Number of edges bool *Mark; //The mark array public: Graph( ); //Constructor ~Graph( ); //Destructor int n( ); //Number of vertices for graph int e( ); //Number of edges for graph 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); //Return vertex edge comes from int v2(Edge); //Return vertex edge goes to int weight(int, int); //Return weight of edge int weight(weight); //Return weight of edge }; Graphs

  19. class EdgeLink { //A singly-linked list node public: int weight; //Edge weight int v1; //1st vertex of edge int v2; //2nd 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; } }; Typedef EdgeLink* Edge; Graphs

  20. Graph::Graph( ) { //Constructor Mark = NULL; list = NULL; // the code for creating a graph follows } 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 while (list[v] != NULL) { //return its edges Edge temp = list[v]; list[v]= list[v]next; delete temp; } delete [ ] list; //Now remove the vertex list headers } } int Graph::n( ) { return numVertex; } //Number of vertices int Graph::e( ) { return numEdge; } //Number of edges Graphs

  21. Edge Graph::first(int v) //Get the first edge for a vertex {return list[v]; } bool Graph::isEdge(Edge w) //TRUE if this is an edge { return w != NULL; } Edge Graph::next(Edge w) { //Get next edge for a vertex if (w == NULL) return NULL; else return wnext; } int Graph::v1(Edge w) //Return vertex edge comes from { return wv1; } int Graph::v2(Edge w) //Return vertex edge goes to { return wv2; } Graphs

  22. 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; } int Graph::weight(Edge w) { //Return weight of edge if ( w = = NULL ) return INFINITY; else return w  weight; } Graphs

  23. arcptr info nextnode B A D C E An even better representation ndptr nextarc info: data arcptr: pointer to an adjacent node nextnode: pointer to a graph node ndptr: pointer to adjacent node nextarc: pointer to next edge Graphs

  24. graph C D n i l E n i l n i l n i l Β A <D,B> n i l <C,E> n i l <A,B> <A,C> <A,D> <A,E> Graphs

  25. Graph Traversals • Trees • preorder • inorder • postorder • Graphs • Depth first search • Breadth first search Graphs

  26. Depth First Search: • Starting from vertex v, initially all vertices unvisited void DFS(v) { Mark(v) = true; for each vertex w adjacent to v if (!Mark(w)) DFS(w) } • Complexity DFS : • O(|V| + |E|): adjacency list representation • O(|V|2) in dense graphs • O(|V|2):matrix representation Graphs

  27. v = v1 7 v3 v2 v1 v6 v5 v4 v8 v7 1 1 7 5 6 8 2 2 5 3 3 4 2 4 6 8 8 8 3 DFS :V1V2V4V8V5V6V3V7 v1 v2 v3 v7 v4 v5 v6 v8 Graphs

  28. v = v1 ΒFS : V1V2V3V4V5V6V7V8 v1 v2 v3 v7 v4 v5 v6 v8 Breadth-First Search Graphs

  29. Breadth First Search (BFS): • Starting from vertex |V|, Initially all nodes are“unvisited” • Visit adjacent nodes of current 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); } } } Graphs

  30. front rear v4 v2 v3 v3 v1 v5 v8 v4 v7 v8 v7 v5 v6 v5 v8 v6 v7 v6 v6 output(v1) v1 front v2 v3 output(v2) rear v7 v4 v5 v6 output(v3) front front v8 front output(v4) rear rear rear front output(v5) output(v6) front output(v7) v = v1 Graphs

  31. Complexity of BFS: • O(|V|+|E|) : adjacency list representation • d1 + d2 + ...+ dn = |E| • di= degree (vi) • O(|V|2) : adjacency matrix representation Graphs

  32. void DFS (Graph& G, int v){//Depth-First Search action(G,v); G.Mark[v] = VISITED; for ( Edge w = G.first(v); G.isEdge(w); w = G.next(w)) if (G.Mark[G.v2(w)] = = UNVISITED)DFS ( G, G.v2(w)); action(G,v); } void BFS (Graph& G, int start){//Breadth-First Search 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.v2(w)] = = UNVISITED){ G.Mark[G.v2(w)] = VISITED;Q.enqueue(G.v2(w)); } action(G,v); } Graphs

  33. B C A D E F A E B G C D connected components • connected graphs: undirected graph, there is a path connecting any two nodes • unconnected graphs: not always a path Graphs

  34. 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|) Graphs

  35. (G,E) Spanning Trees • Tree formed from edges and nodes of G • Spanning Trees of G: Graphs

  36. Spanning forest ofG = ( V, E ): set of disjoint spanning trees of G • Ti = ( Vi , Ei ) 1≤ i ≤ k where Vi and Ei are subsets of V and E • DFS producesdepth first spanning trees or forest • BFS breadth first spanning trees / forest • Undirected graphs provide more traversals • produce less but short spanning trees • Directed graphs provide less traversals • produce more and higher spanning trees Graphs

  37. DFS spanning tree A A B B C C D E A DFS A D E B F DFS spanning forest DFS B C C E F D D E G G DFS Graphs

  38. A ΒFS A B F B C E C F D D E H H BFS A A BFS spanning tree ΒFS B C D B C D E F G E F G BFS spanning forest Graphs

  39. 1 6 5 1 5 5 2 3 4 6 4 2 3 5 6 6 1 1 1 1 1 1 1 1 1 1 5 5 3 3 3 4 2 3 4 2 3 4 4 4 2 4 2 4 2 3 6 6 6 5 6 Minimum Cost Spanning Tree Prim’s algorithm: Complexity O(|V|2) costT = 1 + 5 + 2 + 4 + 3 Graphs

  40. 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 } } } Graphs

  41. void minVertex(Graph& G, int* D){//Find min cost vertex int v; //Initialize v to any unvisited vertex for (int i = 0; i < G.n( ); i++) //Initialize if (G.Mark[i] = = UNVISITED) { v = i; break; } for ( i=0; i<G.n( ); i++) //Now find smallest value if ((G.Mark[i] = = UNVISITED) && ( D[i] < D[v] )) v = i; return v; } Graphs

  42. 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 Graphs

  43. starting point: v = 1 1 10 100 30 2 5 10 60 50 4 3 20 Graphs

  44. function 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 Graphs

  45. void Dijkstra(Graph& G, int s) { // Compute shortest path distances 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); } } Graphs

  46. int minVertex(Graph& G, int* D) { // Find min cost vertex int v; // Initialize v to any unvisited vertex; for (int i=0; i <G.n(); i++) if (G.getMark(i) == UNVISITED) { v = i; break; } for (i++; i <G.n(); i++) // Now find smallest D value if ((G.getMark(i) == UNVISITED) && (D[i] < D[v])) v = i; return v; } minVertex:scans through the list of vertices searching for the min value  O(|V|) time Complexity: O(|V|2 + |E|) = O(|V|2) since O(|E|) is O(|V|2) Graphs

More Related