Data Structures and Algorithms for Engineers
|
|
|
- Spencer Golden
- 6 years ago
- Views:
Transcription
1 -6 Data Structures and Algorithms for Engineers David Vernon Carnegie Mellon University Africa Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
2 Lecture 9 Graphs Types of graph Adjacency matrix representation Adjacency list representation Breadth-First Search traversal Depth-First Search traversal Topological Sorting Minimum Spanning Tree Prim s Algorithm Kruskal s algorithm Shortest Path Algorithms Dijkstra s algorithm Floyd s algorithm Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
3 Traversing a Graph Visit every edge and every vertex in a systematic way Key idea: mark each vertex when we first visit it & keep track of what we have not yet completely explored Each vertex will exist in one of three states. Undiscovered the vertex is in its initial untouched state. Discovered the vertex has been found, but we have not yet checked out all its incident edges. Processed the vertex after we have visited all its incident edges Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
4 Traversing a Graph Keep a record of all the vertices discovered but not yet completely processed Begin with a starting vertex Explore each vertex Evaluate each edge leaving it If the edge goes to an undiscovered vertex Mark it discovered Add it to the list of work to do If the edge goes to a processed vertex, ignore it If the edge goes to a discovered unprocessed vertex, ignore it Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
5 Traversing a Graph There are two primary graph traversal algorithms Breadth-first search (BFS) Depth-first search (DFS) The difference is the order in which they explore vertices Data Structures and Algorithms for Engineers 5 Carnegie Mellon University Africa
6 Traversing a Graph The order depends completely on the container data structure used to store the discovered but not processed vertices BFS uses a queue By storing the vertices in a FIFO queue, we explore the oldest unexplored vertices first Thus explorations radiate out slowly from the starting vertex DFS uses a stack By storing the vertices in a LIFO stack, we explore the vertices by diving down a path, visiting a new neighbour if one is available, and backing up only when we are surrounded by previously discovered vertices Thus explorations quickly wander away from out starting vertex Data Structures and Algorithms for Engineers 6 Carnegie Mellon University Africa
7 Traversing a Graph Breadth-first search (BFS) Data Structures and Algorithms for Engineers 7 Carnegie Mellon University Africa
8 Traversing a Graph Breadth-first search (BFS) Data Structures and Algorithms for Engineers 8 Carnegie Mellon University Africa
9 Traversing a Graph Depth-first search (DFS) Data Structures and Algorithms for Engineers 9 Carnegie Mellon University Africa
10 Traversing a Graph Depth-first search (DFS) Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
11 Breadth-First Search Assign a direction to each edge, from discoverer vertex u to discovered vertex v Since each node has exactly one parent, except for the root (i.e. start vertex), this defines a tree on the vertices of the graph This tree defines the shortest path from the root to every other node in the tree This makes the BFS very useful for in shortest path problems (in unweighted graphs) Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
12 Breadth-First Search Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
13 Breadth-First Search /* Breadth-First Search */ bool processed[maxv+]; /* which vertices have been processed */ bool discovered[maxv+]; /* which vertices have been found */ int parent[maxv+]; /* discovery relation */ /* Each vertex is initialized as undiscovered: */ initialize_search(graph *g){ int i; /* counter */ for (i=; i<=g->nvertices; i++) { processed[i] = discovered[i] = ; parent[i] = ; Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
14 processed discovered parent degree edges directed nvertices nedges Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
15 Breadth-First Search /* Once a vertex is discovered, it is placed on a queue. */ /* Since we process these vertices in first-in, first-out order, */ /* the oldest vertices are expanded first, which are exactly those */ /* closest to the root */ bfs(graph *g, int start) { queue q; /* queue of vertices to visit */ int v; /* current vertex */ int y; /* successor vertex */ edgenode *p; /* temporary pointer */ init_queue(&q); enqueue(&q,start); discovered[start] = ; Data Structures and Algorithms for Engineers 5 Carnegie Mellon University Africa
16 processed discovered parent degree edges 5 6 v y 8 directed nvertices nedges q Data Structures and Algorithms for Engineers 6 Carnegie Mellon University Africa
17 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = TRUE; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == FALSE) g->directed) process_edge(v,y); if (discovered[y] == FALSE) { enqueue(&q,y); discovered[y] = TRUE; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers 7 Carnegie Mellon University Africa
18 processed discovered parent degree edges 5 6 v y 8 directed nvertices nedges q Data Structures and Algorithms for Engineers 8 Carnegie Mellon University Africa
19 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = TRUE; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == FALSE) g->directed) process_edge(v,y); if (discovered[y] == FALSE) { enqueue(&q,y); discovered[y] = TRUE; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers 9 Carnegie Mellon University Africa
20 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = TRUE; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == FALSE) g->directed) process_edge(v,y); if (discovered[y] == FALSE) { enqueue(&q,y); discovered[y] = TRUE; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
21 processed discovered parent degree edges 5 6 v y 8 directed nvertices nedges q Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
22 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = TRUE; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == FALSE) g->directed) process_edge(v,y); if (discovered[y] == FALSE) { enqueue(&q,y); discovered[y] = TRUE; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
23 processed discovered parent degree edges p 5 6 v y 8 directed nvertices nedges q Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
24 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = TRUE; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == FALSE) g->directed) process_edge(v,y); if (discovered[y] == FALSE) { enqueue(&q,y); discovered[y] = TRUE; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
25 processed discovered parent degree edges p 5 6 v y 8 directed nvertices nedges q Data Structures and Algorithms for Engineers 5 Carnegie Mellon University Africa
26 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = ; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == ) g->directed) process_edge(v,y); if (discovered[y] == ) { enqueue(&q,y); discovered[y] = ; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers 6 Carnegie Mellon University Africa
27 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = ; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == ) g->directed) process_edge(v,y); if (discovered[y] == ) { enqueue(&q,y); discovered[y] = ; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers 7 Carnegie Mellon University Africa
28 processed discovered parent degree edges p 5 6 v y 8 directed nvertices nedges q Data Structures and Algorithms for Engineers 8 Carnegie Mellon University Africa
29 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = ; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == ) g->directed) process_edge(v,y); if (discovered[y] == ) { enqueue(&q,y); discovered[y] = ; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers 9 Carnegie Mellon University Africa
30 processed discovered parent degree edges p 5 6 v y 8 directed nvertices nedges q Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
31 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = ; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == ) g->directed) process_edge(v,y); if (discovered[y] == ) { enqueue(&q,y); discovered[y] = ; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
32 processed discovered parent degree edges p 5 6 v y 8 directed nvertices nedges q Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
33 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = ; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == ) g->directed) process_edge(v,y); if (discovered[y] == ) { enqueue(&q,y); discovered[y] = ; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
34 processed discovered parent degree edges p 5 6 v y 8 directed nvertices nedges q Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
35 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = TRUE; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == FALSE) g->directed) process_edge(v,y); if (discovered[y] == FALSE) { enqueue(&q,y); discovered[y] = TRUE; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers 5 Carnegie Mellon University Africa
36 processed discovered parent degree edges p 5 6 v y 8 directed nvertices nedges q Data Structures and Algorithms for Engineers 6 Carnegie Mellon University Africa
37 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = ; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == ) g->directed) process_edge(v,y); if (discovered[y] == ) { enqueue(&q,y); discovered[y] = ; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers 7 Carnegie Mellon University Africa
38 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = ; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == ) g->directed) process_edge(v,y); if (discovered[y] == ) { enqueue(&q,y); discovered[y] = ; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers 8 Carnegie Mellon University Africa
39 processed discovered parent degree edges p 5 6 v y 8 directed nvertices nedges q Data Structures and Algorithms for Engineers 9 Carnegie Mellon University Africa
40 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = ; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == ) g->directed) process_edge(v,y); if (discovered[y] == ) { enqueue(&q,y); discovered[y] = ; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
41 processed discovered parent degree edges p 5 6 v y 8 directed nvertices nedges q Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
42 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = ; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == ) g->directed) process_edge(v,y); if (discovered[y] == ) { enqueue(&q,y); discovered[y] = ; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
43 processed discovered parent degree edges p 5 6 v y 8 directed nvertices nedges q Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
44 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = ; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == ) g->directed) process_edge(v,y); if (discovered[y] == ) { enqueue(&q,y); discovered[y] = ; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers Carnegie Mellon University Africa
45 processed discovered parent degree edges p == NULL 5 6 v y 8 directed nvertices nedges q Data Structures and Algorithms for Engineers 5 Carnegie Mellon University Africa
46 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = ; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == ) g->directed) process_edge(v,y); if (discovered[y] == ) { enqueue(&q,y); discovered[y] = ; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers 6 Carnegie Mellon University Africa
47 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = ; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == ) g->directed) process_edge(v,y); if (discovered[y] == ) { enqueue(&q,y); discovered[y] = ; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers 7 Carnegie Mellon University Africa
48 processed discovered parent degree edges p == NULL 5 6 v y 8 directed nvertices nedges q Data Structures and Algorithms for Engineers 8 Carnegie Mellon University Africa
49 processed discovered parent degree edges p == NULL 5 6 v y 8 directed nvertices nedges q Data Structures and Algorithms for Engineers 9 Carnegie Mellon University Africa
50 Breadth-First Search while (empty_queue(&q) == FALSE) { v = dequeue(&q); process_vertex_early(v); processed[v] = ; p = g->edges[v]; while (p!= NULL) { y = p->y; if ((processed[y] == ) g->directed) process_edge(v,y); if (discovered[y] == ) { enqueue(&q,y); discovered[y] = ; parent[y] = v; p = p->next; process_vertex_late(v); Data Structures and Algorithms for Engineers 5 Carnegie Mellon University Africa
51 processed discovered parent degree edges p 5 6 v y 8 directed nvertices nedges q Data Structures and Algorithms for Engineers 5 Carnegie Mellon University Africa
52 Breadth-First Search /* The exact behaviour of bfs depends on the functions */ /* process vertex early() */ /* process vertex late() */ /* process edge() */ /* These functions allow us to customize what the traversal does */ /* as it makes its official visit to each edge and each vertex. */ /* Here, e.g., we will do all of vertex processing on entry */ /* (to print each vertex and edge exactly once) */ /* so process vertex late() returns without action */ process_vertex_late(int v) { process_vertex_early(int v){ printf("processed vertex %d\n",v); process_edge(int x, int y) { printf("processed edge (%d,%d)\n",x,y); Data Structures and Algorithms for Engineers 5 Carnegie Mellon University Africa
53 Breadth-First Search /* this version just counts the number of edges */ process_edge(int x, int y) { nedges = nedges + ; Data Structures and Algorithms for Engineers 5 Carnegie Mellon University Africa
54 Breadth-First Search Finding Paths The parent array in bfs() is very useful for finding interesting paths through a graph The vertex that discovered vertex i is defined as parent[i] Data Structures and Algorithms for Engineers 5 Carnegie Mellon University Africa
55 Breadth-First Search Finding Paths Every vertex is discovered during the course of a traversal so every node has a parent (except the root) The parent relation defines a tree of discovery with the initial search node as the root of the tree Because vertices are discovered in order of increasing distance from the root, this tree has a very important property The unique tree path from the root to each node uses the smallest number of edges (and intermediate nodes) possible on any path from the root to that vertex Thus BFS can be used to find shortest paths in an unweighted graph Data Structures and Algorithms for Engineers 55 Carnegie Mellon University Africa
56 Breadth-First Search Finding Paths To reconstruct a path we follow the chain of ancestors from the destination node x to the root Note we have to work backwards (we only know the parents) We find the path from to the root and Either store it and explicitly reverse it using a stack Or construct the path recursively (in which case the stack is implicit) Data Structures and Algorithms for Engineers 56 Carnegie Mellon University Africa
57 Breadth-First Search bool find_path(int start, int end, int parents[]) { bool is_path; if (end == ) { is_path = ; // some vertex on the path back from the end // has no parent (not counting start) else if ((start == end)) { printf("\n%d",start); is_path = ; // we have reached the start vertex else { is_path = find_path(start,parents[end],parents); printf(" %d",end); return(is_path); Data Structures and Algorithms for Engineers 57 Carnegie Mellon University Africa
58 find_path(,,parent) Breadth-First Search -> find_path(,5,parent) -> find_path(,,parent) -> printf() printf() printf(5) Data Structures and Algorithms for Engineers 58 Carnegie Mellon University Africa
59 Breadth-First Search Applications of Breadth-First Search Identifying connected components A graph is connected if there is a path between any two vertices A connected component of an undirected graph is a maximal set of vertices such that there is a path between every pair of vertices The components are separate pieces of the graph such that there is no connection between the pieces Many complicated problems reduce to finding or counting connected components How would you find and label all the components in a graph? Data Structures and Algorithms for Engineers 59 Carnegie Mellon University Africa
60 Breadth-First Search Applications of Breadth-First Search Two-Colouring Graphs The vertex-colouring problem seeks to assign a label (or colour) to each vertex of a graph such that no edge links any two vertices of the same colour The goal is use as few colours as possible A graph is bipartite if it can be coloured without conflicts using only two colours Data Structures and Algorithms for Engineers 6 Carnegie Mellon University Africa
61 Breadth-First Search Applications of Breadth-First Search Robot path-planning Data Structures and Algorithms for Engineers 6 Carnegie Mellon University Africa
62 Breadth-First Search Applications of Breadth-First Search Robot path-planning Data Structures and Algorithms for Engineers 6 Carnegie Mellon University Africa
63 Breadth-First Search Applications of Breadth-First Search Robot path-planning Represent the map of the environment as an occupancy grid Data Structures and Algorithms for Engineers 6 Carnegie Mellon University Africa
64 Breadth-First Search Applications of Breadth-First Search Robot path-planning Represent the map of the environment as an occupancy grid Data Structures and Algorithms for Engineers 6 Carnegie Mellon University Africa
65 Breadth-First Search Applications of Breadth-First Search Robot path-planning Convert this to a graph Data Structures and Algorithms for Engineers 65 Carnegie Mellon University Africa
66 Breadth-First Search Applications of Breadth-First Search Robot path-planning Convert this to a graph Data Structures and Algorithms for Engineers 66 Carnegie Mellon University Africa
67 Breadth-First Search Applications of Breadth-First Search Robot path-planning Do a BFS from the robot start position... To find the shortest path to all other vertices Data Structures and Algorithms for Engineers 67 Carnegie Mellon University Africa
68 Breadth-First Search Applications of Breadth-First Search Robot path-planning Mark the path from the robot start position to the goal position on the occupancy grid Data Structures and Algorithms for Engineers 68 Carnegie Mellon University Africa
69 Breadth-First Search Applications of Breadth-First Search Robot path-planning Mark the path from the robot start position to the goal position on the occupancy grid Data Structures and Algorithms for Engineers 69 Carnegie Mellon University Africa
70 Breadth-First Search Applications of Breadth-First Search Robot path-planning Data Structures and Algorithms for Engineers 7 Carnegie Mellon University Africa
71 Breadth-First Search Applications of Breadth-First Search Robot path-planning Data Structures and Algorithms for Engineers 7 Carnegie Mellon University Africa
72 Depth-First Search This implementation of DFS uses the idea of a traversal time for each vertex The clock ticks each time we enter or exit any vertex We keep track of the entry and exit time for each vertex These entry and exit times are useful in many applications of DFS (e.g. topological sort; see later) process_vertex_early() take action on entry process_vertex_late() take action on exit DFS uses a stack but we can avoid using an explicit stack if we use recursion Data Structures and Algorithms for Engineers 7 Carnegie Mellon University Africa
73 Depth-First Search DFS partitions edges of an undirected graph into exactly two classes Tree edges Back edges Tree edges discover new vertices Encoded in the parent relation Back edges link a vertex to an ancestor of the vertex being expanded Data Structures and Algorithms for Engineers 7 Carnegie Mellon University Africa
74 Depth-First Search Data Structures and Algorithms for Engineers 7 Carnegie Mellon University Africa
75 Depth-First Search /* Depth-First Search */ dfs(graph *g, int v){ edgenode *p; /* temporary pointer */ int y; /* successor vertex */ if (finished) return; /* allow for search termination */ discovered[v] = TRUE; time = time + ; entry_time[v] = time; process_vertex_early(v); Data Structures and Algorithms for Engineers 75 Carnegie Mellon University Africa
76 Depth-First Search p = g->edges[v]; while (p!= NULL) { y = p->y; if (discovered[y] == FALSE) { parent[y] = v; process_edge(v,y); dfs(g,y); else if ((!processed[y]) (g->directed)) process_edge(v,y); if (finished) return; p = p->next; process_vertex_late(v); time = time + ; exit_time[v] = time; processed[v] = TRUE; Data Structures and Algorithms for Engineers 76 Carnegie Mellon University Africa
77 Depth-First Search Depth-First Search uses essentially the same idea as backtracking Exhaustively searching all possibilities by advancing if it is possible And backing up as soon as there is no unexplored possibility for further advancement Both are most easily understood as recursive algorithms DFS organizes vertices by entry/exit times DFS classifies edges as either tree edges or back edges Data Structures and Algorithms for Engineers 77 Carnegie Mellon University Africa
78 Depth-First Search Applications of Depth-First Search Finding Cycles If there are no back edges, then all edges are tree edges and no cycles exist Finding a back edge identifies a cycle Data Structures and Algorithms for Engineers 78 Carnegie Mellon University Africa
79 Depth-First Search Applications of Depth-First Search Finding Articulation Vertices ( also known as a cut node): weakest points in a graph/network Data Structures and Algorithms for Engineers 79 Carnegie Mellon University Africa
80 Depth-First Search Depth-First Search on Directed Graphs When traversing undirected graphs, every edge is either in the depth-first search tree or it is a back edge to an ancestor in the tree For directed graphs, there are depth-first search labellings Data Structures and Algorithms for Engineers 8 Carnegie Mellon University Africa
81 Depth-First Search int edge_classification(int x, int y){ if (parent[y] == x) return(tree); if (discovered[y] &&!processed[y]) return(back); if (processed[y] && (entry_time[y]>entry_time[x])) return(forward); if (processed[y] && (entry_time[y]<entry_time[x])) return(cross); printf("warning: unclassified edge (%d,%d)\n",x,y); Data Structures and Algorithms for Engineers 8 Carnegie Mellon University Africa
82 Topological Sorting The most important operation on directed acyclic graphs (DAGs) It orders the vertices on a line such that all directed edges go from left to right Not possible if the graph contains a directed cycle It provides a ordering to process each vertex before any of its successors E.g. edges represent precedence constraints, such that the edge (x, y) means job x must be done before job y Any topological sort defines a valid schedule Each DAG has at least one topological sort Data Structures and Algorithms for Engineers 8 Carnegie Mellon University Africa
83 Topological Sorting Data Structures and Algorithms for Engineers 8 Carnegie Mellon University Africa
84 Topological Sorting Topological sorting can be performed using DFS A directed graph is a DAG iff there are no back edges Labelling the vertices in the reverse order in which they are processed (completed) finds the topological sort of a DAG Data Structures and Algorithms for Engineers 8 Carnegie Mellon University Africa
85 Topological Sorting Why? Consider what happens to each directed edge (x, y) as we encounter it exploring vertex x If y is currently undiscovered, then we start a DFS of y before we can continue with x. Thus y is marked processed/completed before x is, and x appears before y in the topological order If y is discovered but not processed/completed, then (x, y) is a back edge, which is forbidden in a DAG If y is processed/completed, then it will have been so labeled before x. Therefore, x appears before y in the topological order Data Structures and Algorithms for Engineers 85 Carnegie Mellon University Africa
86 Topological Sorting process_vertex_late(int v){ push(&sorted,v); // explicit stack for the sorted vertices process_edge(int x, int y){ int class; /* edge class */ class = edge_classification(x,y); if (class == BACK) printf("warning: directed cycle found, not a DAG\n"); Data Structures and Algorithms for Engineers 86 Carnegie Mellon University Africa
87 Topological Sorting /* Perform topological sort by doing a DFS on the graph, */ /* pushing each vertex on a stack as soon as we have evaluated */ /* all outgoing edges. */ /* The top vertex on the stack always as no incoming edges from any */ /* vertex on the stack. */ /* After the DFS, repeatedly popping the vertices from the stack */ /* yields a topological ordering */ topsort(graph *g) { int i; init_stack(&sorted); for (i=; i<=g->nvertices; i++) if (discovered[i] == FALSE) dfs(g,i); // push(&sorted,i) when processed print_stack(&sorted); /* report topological order */ Data Structures and Algorithms for Engineers 87 Carnegie Mellon University Africa
88 Topological Sorting DFS(g,A)-> DFS(g,B) -> DFS(g,C) -> DFS(g,E) -> DFS(g,D) -> Push(D) Push(E) -> DFS(g,F) Push(F) Push(C) Push(B) Push(A) DFS(g,G)-> Push(G) Order of discovery: A, B, C, E, D, F, G Order of processing: D, E, F, C, B, A, G Stack: G A B C F E D Topological Sort: G, A, B, C, F, E, D Data Structures and Algorithms for Engineers 88 Carnegie Mellon University Africa
Data Structures and Algorithms for Engineers
4-63 Data Structures and Algorithms for Engineers David Vernon Carnegie Mellon University Africa vernon@cmuedu wwwvernoneu Data Structures and Algorithms for Engineers 1 Carnegie Mellon University Africa
CS 310 Advanced Data Structures and Algorithms
CS 31 Advanced Data Structures and Algorithms Graphs July 18, 17 Tong Wang UMass Boston CS 31 July 18, 17 1 / 4 Graph Definitions Graph a mathematical construction that describes objects and relations
Graph Traversal. 9.1 Flavors of Graphs
9 Graph Traversal Graphs are one of the unifying themes of computer science an abstract representation which describes the organization of transportation systems, electrical circuits, human interactions,
Lecture 9 Graph Traversal
Lecture 9 Graph Traversal Euiseong Seo (euiseong@skku.edu) SWE004: Principles in Programming Spring 0 Euiseong Seo (euiseong@skku.edu) Need for Graphs One of unifying themes of computer science Closely
Lecture 9 Graph Traversal
Lecture 9 Graph Traversal Euiseong Seo (euiseong@skku.edu) SWE00: Principles in Programming Spring 0 Euiseong Seo (euiseong@skku.edu) Need for Graphs One of unifying themes of computer science Closely
Unweighted Graphs & Algorithms
Unweighted Graphs & Algorithms Zachary Friggstad Programming Club Meeting References Chapter 4: Graph (Section 4.2) Chapter 22: Elementary Graph Algorithms Graphs Features: vertices/nodes/dots and edges/links/lines
Lecture 9 Graph Traversal
Lecture 9 Graph Traversal Euiseong Seo (euiseong@skku.edu) Need for Graphs One of unifying themes of computer science Closely related to many daily life problems Navigation Circuit generation Social network
CS 125 Section #6 Graph Traversal and Linear Programs 10/13/14
CS 125 Section #6 Graph Traversal and Linear Programs 10/13/14 1 Depth first search 1.1 The Algorithm Besides breadth first search, which we saw in class in relation to Dijkstra s algorithm, there is one
MA/CSSE 473 Day 12. Questions? Insertion sort analysis Depth first Search Breadth first Search. (Introduce permutation and subset generation)
MA/CSSE 473 Day 12 Interpolation Search Insertion Sort quick review DFS, BFS Topological Sort MA/CSSE 473 Day 12 Questions? Interpolation Search Insertion sort analysis Depth first Search Breadth first
Graphs & Digraphs Tuesday, November 06, 2007
Graphs & Digraphs Tuesday, November 06, 2007 10:34 PM 16.1 Directed Graphs (digraphs) like a tree but w/ no root node & no guarantee of paths between nodes consists of: nodes/vertices - a set of elements
Computer Science & Engineering 423/823 Design and Analysis of Algorithms
Computer Science & Engineering 423/823 Design and Analysis of Algorithms Lecture 04 Elementary Graph Algorithms (Chapter 22) Stephen Scott (Adapted from Vinodchandran N. Variyam) sscott@cse.unl.edu Introduction
Computer Science & Engineering 423/823 Design and Analysis of Algorithms
s of s Computer Science & Engineering 423/823 Design and Analysis of Lecture 03 (Chapter 22) Stephen Scott (Adapted from Vinodchandran N. Variyam) 1 / 29 s of s s are abstract data types that are applicable
Elementary Graph Algorithms. Ref: Chapter 22 of the text by Cormen et al. Representing a graph:
Elementary Graph Algorithms Ref: Chapter 22 of the text by Cormen et al. Representing a graph: Graph G(V, E): V set of nodes (vertices); E set of edges. Notation: n = V and m = E. (Vertices are numbered
Lecture 3: Graphs and flows
Chapter 3 Lecture 3: Graphs and flows Graphs: a useful combinatorial structure. Definitions: graph, directed and undirected graph, edge as ordered pair, path, cycle, connected graph, strongly connected
Graph. Vertex. edge. Directed Graph. Undirected Graph
Module : Graphs Dr. Natarajan Meghanathan Professor of Computer Science Jackson State University Jackson, MS E-mail: natarajan.meghanathan@jsums.edu Graph Graph is a data structure that is a collection
Minimum Spanning Trees Ch 23 Traversing graphs
Next: Graph Algorithms Graphs Ch 22 Graph representations adjacency list adjacency matrix Minimum Spanning Trees Ch 23 Traversing graphs Breadth-First Search Depth-First Search 11/30/17 CSE 3101 1 Graphs
Chapter 14. Graphs Pearson Addison-Wesley. All rights reserved 14 A-1
Chapter 14 Graphs 2011 Pearson Addison-Wesley. All rights reserved 14 A-1 Terminology G = {V, E} A graph G consists of two sets A set V of vertices, or nodes A set E of edges A subgraph Consists of a subset
Graph: representation and traversal
Graph: representation and traversal CISC4080, Computer Algorithms CIS, Fordham Univ. Instructor: X. Zhang! Acknowledgement The set of slides have use materials from the following resources Slides for textbook
Islip. Figure 5.1: Modeling road networks and electronic circuits as graphs
5 Graph Traversal Graphs are one of the unifying themes of computer science an abstract representation that describes the organization of transportation systems, human interactions, and telecommunication
Undirected Graphs. DSA - lecture 6 - T.U.Cluj-Napoca - M. Joldos 1
Undirected Graphs Terminology. Free Trees. Representations. Minimum Spanning Trees (algorithms: Prim, Kruskal). Graph Traversals (dfs, bfs). Articulation points & Biconnected Components. Graph Matching
Graph Theory. Many problems are mapped to graphs. Problems. traffic VLSI circuits social network communication networks web pages relationship
Graph Graph Usage I want to visit all the known famous places starting from Seoul ending in Seoul Knowledge: distances, costs Find the optimal(distance or cost) path Graph Theory Many problems are mapped
Info 2950, Lecture 16
Info 2950, Lecture 16 28 Mar 2017 Prob Set 5: due Fri night 31 Mar Breadth first search (BFS) and Depth First Search (DFS) Must have an ordering on the vertices of the graph. In most examples here, the
Graph Algorithms. Chapter 22. CPTR 430 Algorithms Graph Algorithms 1
Graph Algorithms Chapter 22 CPTR 430 Algorithms Graph Algorithms Why Study Graph Algorithms? Mathematical graphs seem to be relatively specialized and abstract Why spend so much time and effort on algorithms
CSI 604 Elementary Graph Algorithms
CSI 604 Elementary Graph Algorithms Ref: Chapter 22 of the text by Cormen et al. (Second edition) 1 / 25 Graphs: Basic Definitions Undirected Graph G(V, E): V is set of nodes (or vertices) and E is the
Lecture 14: Shortest Paths Steven Skiena
Lecture 14: Shortest Paths Steven Skiena Department of Computer Science State University of New York Stony Brook, NY 11794 4400 http://www.cs.stonybrook.edu/ skiena Problem of the Day Suppose we are given
Chapter 5. Decrease-and-Conquer. Copyright 2007 Pearson Addison-Wesley. All rights reserved.
Chapter 5 Decrease-and-Conquer Copyright 2007 Pearson Addison-Wesley. All rights reserved. Decrease-and-Conquer 1. Reduce problem instance to smaller instance of the same problem 2. Solve smaller instance
Graph Algorithms. Imran Rashid. Jan 16, University of Washington
Graph Algorithms Imran Rashid University of Washington Jan 16, 2008 1 / 26 Lecture Outline 1 BFS Bipartite Graphs 2 DAGs & Topological Ordering 3 DFS 2 / 26 Lecture Outline 1 BFS Bipartite Graphs 2 DAGs
LEC13: SHORTEST PATH. CSE 373 Analysis of Algorithms Fall 2016 Instructor: Prof. Sael Lee. Lecture slide courtesy of Prof.
CSE 373 Analysis of Algorithms Fall 2016 Instructor: Prof. Sael Lee LEC13: SHORTEST PATH 1 SHORTEST PATHS Finding the shortest path between two nodes in a graph arises in many different applications: Transportation
Outline. Graphs. Divide and Conquer.
GRAPHS COMP 321 McGill University These slides are mainly compiled from the following resources. - Professor Jaehyun Park slides CS 97SI - Top-coder tutorials. - Programming Challenges books. Outline Graphs.
22.3 Depth First Search
22.3 Depth First Search Depth-First Search(DFS) always visits a neighbour of the most recently visited vertex with an unvisited neighbour. This means the search moves forward when possible, and only backtracks
Graph Representation
Graph Representation Adjacency list representation of G = (V, E) An array of V lists, one for each vertex in V Each list Adj[u] contains all the vertices v such that there is an edge between u and v Adj[u]
Algorithms: Lecture 10. Chalmers University of Technology
Algorithms: Lecture 10 Chalmers University of Technology Today s Topics Basic Definitions Path, Cycle, Tree, Connectivity, etc. Graph Traversal Depth First Search Breadth First Search Testing Bipartatiness
1. Graph and Representation
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
Copyright 2000, Kevin Wayne 1
Chapter 3 - Graphs Undirected Graphs Undirected graph. G = (V, E) V = nodes. E = edges between pairs of nodes. Captures pairwise relationship between objects. Graph size parameters: n = V, m = E. Directed
UNIT 5 GRAPH. Application of Graph Structure in real world:- Graph Terminologies:
UNIT 5 CSE 103 - Unit V- Graph GRAPH Graph is another important non-linear data structure. In tree Structure, there is a hierarchical relationship between, parent and children that is one-to-many relationship.
W4231: Analysis of Algorithms
W4231: Analysis of Algorithms 10/21/1999 Definitions for graphs Breadth First Search and Depth First Search Topological Sort. Graphs AgraphG is given by a set of vertices V and a set of edges E. Normally
Homework Assignment #3 Graph
CISC 4080 Computer Algorithms Spring, 2019 Homework Assignment #3 Graph Some of the problems are adapted from problems in the book Introduction to Algorithms by Cormen, Leiserson and Rivest, and some are
Plan. CMPSCI 311: Introduction to Algorithms. Recall. Adjacency List Representation. DFS Descriptions. BFS Description
Plan CMPSCI 311: Introduction to Algorithms Akshay Krishnamurthy and Andrew McGregor University of Massachusetts Review: Breadth First Search Depth First Search Traversal Implementation and Running Time
Undirected Graphs. V = { 1, 2, 3, 4, 5, 6, 7, 8 } E = { 1-2, 1-3, 2-3, 2-4, 2-5, 3-5, 3-7, 3-8, 4-5, 5-6 } n = 8 m = 11
Chapter 3 - Graphs Undirected Graphs Undirected graph. G = (V, E) V = nodes. E = edges between pairs of nodes. Captures pairwise relationship between objects. Graph size parameters: n = V, m = E. V = {
GRAPHICAL ALGORITHMS. UNIT _II Lecture-12 Slides No. 3-7 Lecture Slides No Lecture Slides No
GRAPHICAL ALGORITHMS UNIT _II Lecture-12 Slides No. 3-7 Lecture-13-16 Slides No. 8-26 Lecture-17-19 Slides No. 27-42 Topics Covered Graphs & Trees ( Some Basic Terminologies) Spanning Trees (BFS & DFS)
DHANALAKSHMI COLLEGE OF ENGINEERING, CHENNAI. Department of Computer Science and Engineering CS6301 PROGRAMMING DATA STRUCTURES II
DHANALAKSHMI COLLEGE OF ENGINEERING, CHENNAI Department of Computer Science and Engineering CS6301 PROGRAMMING DATA STRUCTURES II Anna University 2 & 16 Mark Questions & Answers Year / Semester: II / III
Basic Graph Algorithms
Basic Graph Algorithms 1 Representations of Graphs There are two standard ways to represent a graph G(V, E) where V is the set of vertices and E is the set of edges. adjacency list representation adjacency
12 Abstract Data Types
12 Abstract Data Types 12.1 Foundations of Computer Science Cengage Learning Objectives After studying this chapter, the student should be able to: Define the concept of an abstract data type (ADT). Define
Introduction to Algorithms
6.006- Introduction to Algorithms Lecture 13 Prof. Constantinos Daskalakis CLRS 22.4-22.5 Graphs G=(V,E) V a set of vertices Usually number denoted by n E VxV a set of edges (pairs of vertices) Usually
UNIT Name the different ways of representing a graph? a.adjacencymatrix b. Adjacency list
UNIT-4 Graph: Terminology, Representation, Traversals Applications - spanning trees, shortest path and Transitive closure, Topological sort. Sets: Representation - Operations on sets Applications. 1. Name
CS521 \ Notes for the Final Exam
CS521 \ Notes for final exam 1 Ariel Stolerman Asymptotic Notations: CS521 \ Notes for the Final Exam Notation Definition Limit Big-O ( ) Small-o ( ) Big- ( ) Small- ( ) Big- ( ) Notes: ( ) ( ) ( ) ( )
Algorithm Design and Analysis
Algorithm Design and Analysis LECTURE 4 Graphs Definitions Traversals Adam Smith 9/8/10 Exercise How can you simulate an array with two unbounded stacks and a small amount of memory? (Hint: think of a
CS 270 Algorithms. Oliver Kullmann. Breadth-first search. Analysing BFS. Depth-first. search. Analysing DFS. Dags and topological sorting.
Week 5 General remarks and 2 We consider the simplest graph- algorithm, breadth-first (). We apply to compute shortest paths. Then we consider the second main graph- algorithm, depth-first (). And we consider
Fundamental Algorithms
Fundamental Algorithms Chapter 8: Graphs Jan Křetínský Winter 2017/18 Chapter 8: Graphs, Winter 2017/18 1 Graphs Definition (Graph) A graph G = (V, E) consists of a set V of vertices (nodes) and a set
Graph Algorithms. Textbook reading. Chapter 3 Chapter 4. CSci 3110 Graph Algorithms 1/41
CSci 3110 Graph Algorithms 1/41 Graph Algorithms Textbook reading Chapter 3 Chapter 4 CSci 3110 Graph Algorithms 2/41 Overview Design principle: Learn the structure of a graph by systematic exploration
Lecture 10 Graph algorithms: testing graph properties
Lecture 10 Graph algorithms: testing graph properties COMP 523: Advanced Algorithmic Techniques Lecturer: Dariusz Kowalski Lecture 10: Testing Graph Properties 1 Overview Previous lectures: Representation
CS 270 Algorithms. Oliver Kullmann. Analysing BFS. Depth-first search. Analysing DFS. Dags and topological sorting.
General remarks Week 5 2 We finish, by analysing it. Then we consider the second main graph- algorithm, depth-first (). And we consider one application of, of graphs. Reading from CLRS for week 5 Chapter
Part VI Graph algorithms. Chapter 22 Elementary Graph Algorithms Chapter 23 Minimum Spanning Trees Chapter 24 Single-source Shortest Paths
Part VI Graph algorithms Chapter 22 Elementary Graph Algorithms Chapter 23 Minimum Spanning Trees Chapter 24 Single-source Shortest Paths 1 Chapter 22 Elementary Graph Algorithms Representations of graphs
Graph Algorithms. Definition
Graph Algorithms Many problems in CS can be modeled as graph problems. Algorithms for solving graph problems are fundamental to the field of algorithm design. Definition A graph G = (V, E) consists of
SELF-BALANCING SEARCH TREES. Chapter 11
SELF-BALANCING SEARCH TREES Chapter 11 Tree Balance and Rotation Section 11.1 Algorithm for Rotation BTNode root = left right = data = 10 BTNode = left right = data = 20 BTNode NULL = left right = NULL
Graph Representation DFS BFS Dijkstra A* Search Bellman-Ford Floyd-Warshall Iterative? Non-iterative? MST Flow Edmond-Karp
Charles Lin Graph Representation DFS BFS Dijkstra A* Search Bellman-Ford Floyd-Warshall Iterative? Non-iterative? MST Flow Edmond-Karp Adjacency Matrix bool way[100][100]; cin >> i >> j; way[i][j] = true;
Homework 5: Graphs, Minimum Spanning Trees, and Dijkstra Shortest-Path
Homework 5: Graphs, Minimum Spanning Trees, and Dijkstra Shortest-Path 1. (4 points) A graph is Hamiltonian if there is a cycle in the graph visiting each vertex exactly once. Give an example of an Eulerian
CS781 Lecture 2 January 13, Graph Traversals, Search, and Ordering
CS781 Lecture 2 January 13, 2010 Graph Traversals, Search, and Ordering Review of Lecture 1 Notions of Algorithm Scalability Worst-Case and Average-Case Analysis Asymptotic Growth Rates: Big-Oh Prototypical
CS/COE 1501 cs.pitt.edu/~bill/1501/ Graphs
CS/COE 1501 cs.pitt.edu/~bill/1501/ Graphs 5 3 2 4 1 0 2 Graphs A graph G = (V, E) Where V is a set of vertices E is a set of edges connecting vertex pairs Example: V = {0, 1, 2, 3, 4, 5} E = {(0, 1),
Data Structures. Elementary Graph Algorithms BFS, DFS & Topological Sort
Data Structures Elementary Graph Algorithms BFS, DFS & Topological Sort 1 Graphs A graph, G = (V, E), consists of two sets: V is a finite non-empty set of vertices. E is a set of pairs of vertices, called
ECE4050 Data Structures and Algorithms. Lecture 8: Graphs
ECE4050 Data Structures and Algorithms Lecture 8: Graphs 1 Graphs A graph G = (V, E) consists of a set of vertices V, and a set of edges E, such that each edge in E is a connection between a pair of vertices
TIE Graph algorithms
TIE-20106 239 11 Graph algorithms This chapter discusses the data structure that is a collection of points (called nodes or vertices) and connections between them (called edges or arcs) a graph. The common
Graphs. CSE 2320 Algorithms and Data Structures Alexandra Stefan and Vassilis Athitsos University of Texas at Arlington
Graphs CSE 2320 Algorithms and Data Structures Alexandra Stefan and Vassilis Athitsos University of Texas at Arlington 1 Representation Adjacency matrix??adjacency lists?? Review Graphs (from CSE 2315)
CS 341: Algorithms. Douglas R. Stinson. David R. Cheriton School of Computer Science University of Waterloo. February 26, 2019
CS 341: Algorithms Douglas R. Stinson David R. Cheriton School of Computer Science University of Waterloo February 26, 2019 D.R. Stinson (SCS) CS 341 February 26, 2019 1 / 296 1 Course Information 2 Introduction
Computer Science & Engineering 423/823 Design and Analysis of Algorithms
s of s Computer Science & Engineering 423/823 Design and Analysis of Lecture 03 (Chapter 22) Stephen Scott (Adapted from Vinodchandran N. Variyam) 1 / 29 Spring 2010 s of s s are abstract data types that
CSE 100: GRAPH ALGORITHMS
CSE 100: GRAPH ALGORITHMS 2 Graphs: Example A directed graph V5 V = { V = E = { E Path: 3 Graphs: Definitions A directed graph V5 V6 A graph G = (V,E) consists of a set of vertices V and a set of edges
GRAPHS Lecture 19 CS2110 Spring 2013
GRAPHS Lecture 19 CS2110 Spring 2013 Announcements 2 Prelim 2: Two and a half weeks from now Tuesday, April16, 7:30-9pm, Statler Exam conflicts? We need to hear about them and can arrange a makeup It would
Graphs. Part I: Basic algorithms. Laura Toma Algorithms (csci2200), Bowdoin College
Laura Toma Algorithms (csci2200), Bowdoin College Undirected graphs Concepts: connectivity, connected components paths (undirected) cycles Basic problems, given undirected graph G: is G connected how many
Week 5. 1 Analysing BFS. 2 Depth-first search. 3 Analysing DFS. 4 Dags and topological sorting. 5 Detecting cycles. CS 270 Algorithms.
1 2 Week 5 3 4 5 General remarks We finish, by analysing it. Then we consider the second main graph- algorithm, depth-first (). And we consider one application of, of graphs. Reading from CLRS for week
Problem Score Maximum MC 34 (25/17) = 50 Total 100
Stony Brook University Midterm 2 CSE 373 Analysis of Algorithms November 22, 2016 Midterm Exam Name: ID #: Signature: Circle one: GRAD / UNDERGRAD INSTRUCTIONS: This is a closed book, closed mouth exam.
CS 125 Section #5 Graph Traversal and Linear Programs October 6, 2016
CS 125 Section #5 Graph Traversal and Linear Programs October 6, 2016 1 Depth first search 1.1 The Algorithm Besides breadth first search, which we saw in class in relation to Dijkstra s algorithm, there
CSE 100 Minimum Spanning Trees Prim s and Kruskal
CSE 100 Minimum Spanning Trees Prim s and Kruskal Your Turn The array of vertices, which include dist, prev, and done fields (initialize dist to INFINITY and done to false ): V0: dist= prev= done= adj:
Lecture 10 Graph Algorithms
Lecture 10 Graph Algorithms Euiseong Seo (euiseong@skku.edu) 1 Graph Theory Study of the properties of graph structures It provides us with a language with which to talk about graphs Keys to solving problems
( ) ( ) C. " 1 n. ( ) $ f n. ( ) B. " log( n! ) ( ) and that you already know ( ) ( ) " % g( n) ( ) " #&
CSE 0 Name Test Summer 008 Last 4 Digits of Mav ID # Multiple Choice. Write your answer to the LEFT of each problem. points each. The time for the following code is in which set? for (i=0; i
TIE Graph algorithms
TIE-20106 1 1 Graph algorithms This chapter discusses the data structure that is a collection of points (called nodes or vertices) and connections between them (called edges or arcs) a graph. The common
COMP 251 Winter 2017 Online quizzes with answers
COMP 251 Winter 2017 Online quizzes with answers Open Addressing (2) Which of the following assertions are true about open address tables? A. You cannot store more records than the total number of slots
Graph Traversals. CS200 - Graphs 1
Graph Traversals CS200 - Graphs 1 Tree traversal reminder A Pre order A B D G H C E F I B C In order G D H B A E C F I D E F Post order G H D B E I F C A G H I Level order A B C D E F G H I Connected Components
Algorithms and Theory of Computation. Lecture 3: Graph Algorithms
Algorithms and Theory of Computation Lecture 3: Graph Algorithms Xiaohui Bei MAS 714 August 20, 2018 Nanyang Technological University MAS 714 August 20, 2018 1 / 18 Connectivity In a undirected graph G
Graphs: basic concepts and algorithms
: basic concepts and algorithms Topics covered by this lecture: - Reminder Trees Trees (in-order,post-order,pre-order) s (BFS, DFS) Denitions: Reminder Directed graph (digraph): G = (V, E), V - vertex
Graph Representations and Traversal
COMPSCI 330: Design and Analysis of Algorithms 02/08/2017-02/20/2017 Graph Representations and Traversal Lecturer: Debmalya Panigrahi Scribe: Tianqi Song, Fred Zhang, Tianyu Wang 1 Overview This lecture
LECTURE NOTES OF ALGORITHMS: DESIGN TECHNIQUES AND ANALYSIS
Department of Computer Science University of Babylon LECTURE NOTES OF ALGORITHMS: DESIGN TECHNIQUES AND ANALYSIS By Faculty of Science for Women( SCIW), University of Babylon, Iraq Samaher@uobabylon.edu.iq
CS4800: Algorithms & Data Jonathan Ullman
CS4800: Algorithms & Data Jonathan Ullman Lecture 11: Graphs Graph Traversals: BFS Feb 16, 2018 What s Next What s Next Graph Algorithms: Graphs: Key Definitions, Properties, Representations Exploring
Algorithm Analysis Graph algorithm. Chung-Ang University, Jaesung Lee
Algorithm Analysis Graph algorithm Chung-Ang University, Jaesung Lee Basic definitions Graph = (, ) where is a set of vertices and is a set of edges Directed graph = where consists of ordered pairs
Goals! CSE 417: Algorithms and Computational Complexity!
Goals! CSE : Algorithms and Computational Complexity! Graphs: defns, examples, utility, terminology! Representation: input, internal! Traversal: Breadth- & Depth-first search! Three Algorithms:!!Connected
Announcements. HW3 is graded. Average is 81%
CSC263 Week 9 Announcements HW3 is graded. Average is 81% Announcements Problem Set 4 is due this Tuesday! Due Tuesday (Nov 17) Recap The Graph ADT definition and data structures BFS gives us single-source
CS 512: Comments on Graph Search 16:198:512 Instructor: Wes Cowan
CS 512: Comments on Graph Search 16:198:512 Instructor: Wes Cowan 1 General Graph Search In general terms, the generic graph search algorithm looks like the following: def GenerateGraphSearchTree(G, root):
Graph Search. Adnan Aziz
Graph Search Adnan Aziz Based on CLRS, Ch 22. Recall encountered graphs several weeks ago (CLRS B.4) restricted our attention to definitions, terminology, properties Now we ll see how to perform basic
The ADT priority queue Orders its items by a priority value The first item removed is the one having the highest priority value
The ADT priority queue Orders its items by a priority value The first item removed is the one having the highest priority value 1 Possible implementations Sorted linear implementations o Appropriate if
GRAPHS Lecture 17 CS2110 Spring 2014
GRAPHS Lecture 17 CS2110 Spring 2014 These are not Graphs 2...not the kind we mean, anyway These are Graphs 3 K 5 K 3,3 = Applications of Graphs 4 Communication networks The internet is a huge graph Routing
3.4 Testing Bipartiteness
3.4 Testing Bipartiteness Bipartite Graphs Def. An undirected graph G = (V, E) is bipartite (2-colorable) if the nodes can be colored red or blue such that no edge has both ends the same color. Applications.
Graph Algorithms: Chapters Part 1: Introductory graph concepts
UMass Lowell Computer Science 91.503 Algorithms Dr. Haim Levkowitz Fall, 2007 Graph Algorithms: Chapters 22-25 Part 1: Introductory graph concepts 1 91.404 Graph Review Elementary Graph Algorithms Minimum
( ) D. Θ ( ) ( ) Ο f ( n) ( ) Ω. C. T n C. Θ. B. n logn Ο
CSE 0 Name Test Fall 0 Multiple Choice. Write your answer to the LEFT of each problem. points each. The expected time for insertion sort for n keys is in which set? (All n! input permutations are equally
CSE 373 Final Exam 3/14/06 Sample Solution
Question 1. (6 points) A priority queue is a data structure that supports storing a set of values, each of which has an associated key. Each key-value pair is an entry in the priority queue. The basic
Chapter 22. Elementary Graph Algorithms
Graph Algorithms - Spring 2011 Set 7. Lecturer: Huilan Chang Reference: (1) Cormen, Leiserson, Rivest, and Stein, Introduction to Algorithms, 2nd Edition, The MIT Press. (2) Lecture notes from C. Y. Chen
Chapter 22 Elementary Graph Algorithms
Chapter 22 Elementary Graph Algorithms Graph Representations Graph G = (V,E) Directed Undirected Adjacency Lists Adjacency Matrix Graph Representations Adjacency List: Undirected Memory: Adjacency: Graph
E.G.S. PILLAY ENGINEERING COLLEGE (An Autonomous Institution, Affiliated to Anna University, Chennai) Nagore Post, Nagapattinam , Tamilnadu.
17CA 104DATA STRUCTURES Academic Year : 018-019 Programme : MCA Year / Semester : I / I Question Bank Course Coordinator: Mrs. C.Mallika Course Objectives The student should be able to 1. To understand
D. Θ nlogn ( ) D. Ο. ). Which of the following is not necessarily true? . Which of the following cannot be shown as an improvement? D.
CSE 0 Name Test Fall 00 Last Digits of Mav ID # Multiple Choice. Write your answer to the LEFT of each problem. points each. The time to convert an array, with priorities stored at subscripts through n,
Undirected Graphs. Hwansoo Han
Undirected Graphs Hwansoo Han Definitions Undirected graph (simply graph) G = (V, E) V : set of vertexes (vertices, nodes, points) E : set of edges (lines) An edge is an unordered pair Edge (v, w) = (w,
Chapter 9 Graph Algorithms
Chapter 9 Graph Algorithms 2 Introduction graph theory useful in practice represent many real-life problems can be slow if not careful with data structures 3 Definitions an undirected graph G = (V, E)
CS/COE
CS/COE 151 www.cs.pitt.edu/~lipschultz/cs151/ Graphs 5 3 2 4 1 Graphs A graph G = (V, E) Where V is a set of vertices E is a set of edges connecting vertex pairs Example: V = {, 1, 2, 3, 4, 5} E = {(,