lecture 19
•Download as PPT, PDF•
0 likes•396 views
The document discusses depth-first search (DFS) graph algorithms. DFS explores a graph by going as deep as possible at each step and backtracking when no further progress can be made. It distinguishes between different types of edges discovered: tree edges connect newly found nodes, back edges connect to ancestors, and cross/forward edges connect between subtrees or ancestors and descendants. DFS runs in O(V+E) time and can detect cycles in O(V) time by checking for back edges.
Report
Share
Report
Share
![Review: Depth-First Search ,[object Object],[object Object],[object Object],[object Object]](data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)
Recommended
DFS & BFS Graph
The document discusses depth-first search (DFS) and breadth-first search (BFS) graph traversal algorithms. It provides details on how DFS uses a stack to search deeper in the graph first by exploring edges from the most recently discovered vertex. BFS uses a queue to search outward from the starting node to neighboring nodes first before searching further. An example of DFS running on a graph is shown with each step of the algorithm.
Bfs and Dfs
The document discusses graph traversal algorithms breadth-first search (BFS) and depth-first search (DFS). It provides examples of how BFS and DFS work, including pseudocode for algorithms. It also discusses applications of BFS such as finding shortest paths and detecting bipartitions. Applications of DFS include finding connected components and topological sorting.
Depth First Search ( DFS )
Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) and explores as far as possible along each branch before backtracking
Depth firstsearchalgorithm
The document discusses Depth First Search (DFS) graph traversal algorithms. It explains that DFS traverses the graph by going as deep as possible along each branch before backtracking. It provides examples of DFS on graphs, showing the order of vertex visits and maintaining discovery/finish times. Key aspects of DFS include using recursion to visit nodes, marking nodes gray while discovering and black when finished, and distinguishing tree, back, forward and cross edges. The time complexity of DFS is O(V+E) where V is vertices and E is edges. Applications mentioned are topological sorting and finding strongly connected components.
Graph traversals in Data Structures
Graph traversal techniques are used to search vertices in a graph and determine the order to visit vertices. There are two main techniques: breadth-first search (BFS) and depth-first search (DFS). BFS uses a queue and visits the nearest vertices first, producing a spanning tree. DFS uses a stack and visits vertices by going as deep as possible first, also producing a spanning tree. Both techniques involve marking visited vertices to avoid loops.
2.5 bfs & dfs 02
The document provides information on graph traversals including depth-first search (DFS) and breadth-first search (BFS). It explains that DFS uses a stack and visits nodes in a recursive, preorder manner. BFS uses a queue and visits nodes level-by-level starting from the root. Examples of DFS and BFS on sample graphs are given to illustrate the traversal order.
DFS and BFS
This document discusses and provides examples of depth-first search (DFS) and breadth-first search (BFS) algorithms for traversing graphs. It explains that DFS involves recursively exploring all branches of the graph as deep as possible before backtracking, while BFS involves searching the neighbors of the starting node first before moving to the next level. Examples are given showing the step-by-step process of applying DFS and BFS to traverse graphs and mark visited vertices.
Breadth first search and depth first search
breadth first search (BFS), depth first search (DFS), BFS and DFS for traversing and searching in a Graph
Recommended
DFS & BFS Graph
The document discusses depth-first search (DFS) and breadth-first search (BFS) graph traversal algorithms. It provides details on how DFS uses a stack to search deeper in the graph first by exploring edges from the most recently discovered vertex. BFS uses a queue to search outward from the starting node to neighboring nodes first before searching further. An example of DFS running on a graph is shown with each step of the algorithm.
Bfs and Dfs
The document discusses graph traversal algorithms breadth-first search (BFS) and depth-first search (DFS). It provides examples of how BFS and DFS work, including pseudocode for algorithms. It also discusses applications of BFS such as finding shortest paths and detecting bipartitions. Applications of DFS include finding connected components and topological sorting.
Depth First Search ( DFS )
Depth-first search (DFS) is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node (selecting some arbitrary node as the root node in the case of a graph) and explores as far as possible along each branch before backtracking
Depth firstsearchalgorithm
The document discusses Depth First Search (DFS) graph traversal algorithms. It explains that DFS traverses the graph by going as deep as possible along each branch before backtracking. It provides examples of DFS on graphs, showing the order of vertex visits and maintaining discovery/finish times. Key aspects of DFS include using recursion to visit nodes, marking nodes gray while discovering and black when finished, and distinguishing tree, back, forward and cross edges. The time complexity of DFS is O(V+E) where V is vertices and E is edges. Applications mentioned are topological sorting and finding strongly connected components.
Graph traversals in Data Structures
Graph traversal techniques are used to search vertices in a graph and determine the order to visit vertices. There are two main techniques: breadth-first search (BFS) and depth-first search (DFS). BFS uses a queue and visits the nearest vertices first, producing a spanning tree. DFS uses a stack and visits vertices by going as deep as possible first, also producing a spanning tree. Both techniques involve marking visited vertices to avoid loops.
2.5 bfs & dfs 02
The document provides information on graph traversals including depth-first search (DFS) and breadth-first search (BFS). It explains that DFS uses a stack and visits nodes in a recursive, preorder manner. BFS uses a queue and visits nodes level-by-level starting from the root. Examples of DFS and BFS on sample graphs are given to illustrate the traversal order.
DFS and BFS
This document discusses and provides examples of depth-first search (DFS) and breadth-first search (BFS) algorithms for traversing graphs. It explains that DFS involves recursively exploring all branches of the graph as deep as possible before backtracking, while BFS involves searching the neighbors of the starting node first before moving to the next level. Examples are given showing the step-by-step process of applying DFS and BFS to traverse graphs and mark visited vertices.
Breadth first search and depth first search
breadth first search (BFS), depth first search (DFS), BFS and DFS for traversing and searching in a Graph
Depth-First Search
This document discusses depth-first search (DFS), a graph search algorithm that explores edges deeper whenever possible. It uses a LIFO queue and colors vertices as white, gray, or black to track the search process. DFS recursively visits unexplored neighbor vertices, coloring them gray before exploring their edges. The running time is O(V+E) as DFS calls itself once per vertex and explores each edge once.
Graph traversal-BFS & DFS
The document discusses graph traversal algorithms depth-first search (DFS) and breadth-first search (BFS). DFS uses a stack and visits nodes by traversing as deep as possible before backtracking. BFS uses a queue and visits all nodes at each level from the starting node before moving to the next level. Examples are given applying DFS and BFS to a sample graph. Applications of DFS and BFS are also listed such as computing distances, checking for cycles/bipartiteness, and topological sorting.
Depth first search and breadth first searching
1. Depth first search is an algorithm for traversing tree and graph data structures where one starts at the root node and explores as deep as possible along each branch before backtracking.
2. It can be implemented using a stack and explores edges out of the most recently discovered vertex before backtracking to explore other paths.
3. Breadth first search begins at a root node and inspects all neighboring nodes before exploring nodes further away, implementing it using a queue.
Bfs dfs
Breadth-first search (BFS) and depth-first search (DFS) are two graph traversal algorithms that systematically visit all vertices and edges of a graph. BFS discovers vertices in order of distance from the source vertex, allowing it to compute shortest paths. DFS recursively explores as far as possible along each branch before backtracking, imposing a tree structure on the graph. Both algorithms run in O(V+E) time, where V is the number of vertices and E is the number of edges. DFS classifies edges as tree, forward, back, or cross edges and can detect cycles based on the presence of back edges.
Depth first search [dfs]
Depth-first search (DFS) is an algorithm that explores all the vertices reachable from a starting vertex by traversing edges in a depth-first manner. DFS uses a stack data structure to keep track of vertices to visit. It colors vertices white, gray, and black to indicate their status. DFS runs in O(V+E) time and can be used for applications like topological sorting and finding strongly connected components. The edges discovered during DFS can be classified as tree, back, forward, or cross edges based on the order in which vertices are discovered.
Bfs & dfs application
The document introduces breadth-first search (BFS) and depth-first search (DFS), two algorithms for traversing graphs. It provides explanations of how BFS and DFS work, including pseudocode algorithms. Examples of simulations of BFS and DFS on sample graphs are shown step-by-step with diagrams. Potential applications of BFS and DFS in areas like cycle detection, finding connected components, and topological sorting are also discussed.
DFS algorithm
The document discusses depth-first search (DFS) algorithms. It provides pseudocode for performing DFS on a graph and walks through an example of running DFS on a sample graph. It explains that DFS classifies edges in the original graph as tree edges, back edges, forward edges, or cross edges based on how vertices are encountered during the algorithm's execution.
Presentation on Breadth First Search (BFS)
This document contains a presentation on Breadth-First Search (BFS) given to students. The presentation includes:
- An introduction to BFS and its inventor Konrad Zuse.
- Definitions of key terms like graph, tree, vertex, level-order traversal.
- An example visualization of BFS on a graph with 14 steps.
- Pseudocode and a Java program implementing BFS.
- Applications of BFS like shortest paths, social networks, web crawlers.
- The time and space complexity of BFS is O(V+E) and O(V).
- A conclusion that BFS is an important algorithm that traverses
Articulation point
The document discusses articulation points in graphs. An articulation point is a vertex whose removal disconnects the graph into two or more components. The document presents an algorithm to find all articulation points in a graph using depth-first search (DFS) in O(V+E) time. It traverses the DFS tree, and a vertex is an articulation point if it is the root of the tree with two or more children, or if it is not the root and has a child such that no vertex in the child's subtree has a back edge to an ancestor of that vertex. Pseudocode for the algorithm is also provided.
Graphs bfs dfs
The document discusses Breadth First Search (BFS) and Depth First Search (DFS) algorithms for graphs. It defines key graph terminology and describes how to represent graphs using adjacency lists and matrices. It then explains how BFS and DFS work by exploring the graph in different ways, keeping track of vertex colors and paths/trees produced. Both algorithms run in O(V+E) time and have different applications like routing, sorting, and finding connected components.
Bfs and dfs in data structure
The document discusses graph algorithms breadth-first search (BFS) and depth-first search (DFS). It provides pseudocode for BFS and DFS algorithms and explains key aspects of each. BFS uses a queue to explore all neighbors of a node before moving to the next level, building a breadth-first tree. DFS uses recursion to explore as deep as possible along each branch before backtracking, resulting in a depth-first tree structure. Both algorithms run in O(V+E) time on a graph with V vertices and E edges.
Graph
This document discusses various graph algorithms including depth-first search (DFS), breadth-first search (BFS), union find, Kruskal's algorithm, Floyd-Warshall's algorithm, Dijkstra's algorithm, and bipartite graphs. It provides definitions, pseudocode, sample code, and sample problems for implementing each algorithm.
Dfs presentation
The document describes depth-first search (DFS), an algorithm for traversing or searching trees or graphs. It defines DFS, explains the process as visiting nodes by going deeper until reaching the end and then backtracking, provides pseudocode for the algorithm, gives an example on a directed graph, and discusses time complexity (O(V+E)), advantages like linear memory usage, and disadvantages like possible infinite traversal without a cutoff depth.
Data structures and algorithms lab7
This document summarizes a lab on data structures and algorithms related to graphs. It introduces graphs and their representations, as well as graph traversal algorithms like depth-first search (DFS) and breadth-first search (BFS). It also discusses bipartite graphs. The lab objectives are to learn about graphs, DFS, BFS, and bipartite graphs. Various exercises are provided to apply these graph concepts.
BFS (Breadth First Search) Tree Traversal
1) Breadth-first search (BFS) is an algorithm for traversing or searching tree or graph data structures. It starts at the tree root (or some arbitrary node of a graph) and explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level.
2) BFS uses a queue to keep track of nodes to visit at each level, processing nodes level-by-level from the queue in a FIFO order. It marks visited nodes to avoid processing them again.
3) The time complexity of BFS is O(V+E) where V is the number of vertices and E is the number of edges. BFS can be used to
BFS
This document describes graph search algorithms like breadth-first search (BFS) and their applications. It provides details on how BFS works, including that it maintains queues to search levels outwards from the starting vertex, and outputs the distance and predecessor of each vertex. BFS runs in O(V+E) time by visiting each vertex and edge once. The document also discusses how BFS can be used to find connected components in a graph and determine if a graph is bipartite.
articulation points in graph
This document discusses how to find articulation points in a graph using depth-first search (DFS). It begins by reviewing the DFS algorithm and concepts like discovery time. It then makes two key observations: (1) roots with two or more children and (2) internal vertices where a subtree has no back edge climbing higher are articulation points. It introduces the concept of low(v) to track the lowest discovery time reachable from v to determine if a subtree can climb higher. The algorithm runs DFS to compute low(v) values and identifies articulation points based on the two observations. The running time is O(V+E).
2.5 dfs & bfs
This document discusses different graph traversal algorithms: depth-first traversal, breadth-first traversal, and their implementations. Depth-first traversal uses a stack and can output nodes in either preorder or postorder. Breadth-first traversal uses a queue and outputs nodes level-by-level. Pseudocode and examples are provided for both algorithms. Review questions ask the reader to trace the output order of different traversals on sample graphs.
Breadth first search (Bfs)
This document provides an overview of the Breadth-First Search (BFS) graph traversal algorithm. It begins by explaining that BFS starts at the root node and explores all neighboring nodes, selecting the nearest unexplored node at each step. It then provides examples of BFS traversing different graphs and describes the key aspects of the BFS algorithm, including maintaining a queue, coloring nodes as white/gray/black to track explored status, and updating distance and predecessor values at each step. In the end, it analyzes the properties of BFS, such as finding the shortest path distances, and discusses applications like finding connected components.
Graphs
The document discusses different types of graphs including directed and undirected graphs. It describes graph implementations using adjacency matrices and adjacency lists. It also covers graph traversal algorithms like depth-first search (DFS) and breadth-first search (BFS). DFS prioritizes exploring paths as deeply as possible while BFS explores all paths at the same depth level before moving deeper. Real-world examples of graphs include social networks and transportation networks.
lecture 18
The document discusses the algorithms of breadth-first search (BFS) and depth-first search (DFS) on graphs. It provides pseudocode for BFS and DFS, and examples of running the algorithms on sample graphs. Key points include:
- BFS uses a queue to explore all neighbors of a vertex before moving to the next level. It finds the shortest paths from the source.
- DFS uses recursion to explore as deep as possible before backtracking. It identifies tree edges, back edges, and forward edges.
- Both BFS and DFS run in O(V+E) time on a graph with V vertices and E edges.
lecture24.ppt
The document discusses depth-first search (DFS) algorithms for exploring graphs. It begins by reviewing DFS, noting that it explores deeper in the graph whenever possible by exploring edges out of the most recently discovered vertex. It then shows pseudocode for performing DFS on a graph. The document proceeds to provide an example run of DFS on a graph, demonstrating the discovery order of vertices and labeling of tree, back, forward, and cross edges. It concludes by discussing properties of DFS, such as only producing tree and back edges in undirected graphs and using DFS to detect cycles in O(V+E) time.
More Related Content
What's hot
Depth-First Search
This document discusses depth-first search (DFS), a graph search algorithm that explores edges deeper whenever possible. It uses a LIFO queue and colors vertices as white, gray, or black to track the search process. DFS recursively visits unexplored neighbor vertices, coloring them gray before exploring their edges. The running time is O(V+E) as DFS calls itself once per vertex and explores each edge once.
Graph traversal-BFS & DFS
The document discusses graph traversal algorithms depth-first search (DFS) and breadth-first search (BFS). DFS uses a stack and visits nodes by traversing as deep as possible before backtracking. BFS uses a queue and visits all nodes at each level from the starting node before moving to the next level. Examples are given applying DFS and BFS to a sample graph. Applications of DFS and BFS are also listed such as computing distances, checking for cycles/bipartiteness, and topological sorting.
Depth first search and breadth first searching
1. Depth first search is an algorithm for traversing tree and graph data structures where one starts at the root node and explores as deep as possible along each branch before backtracking.
2. It can be implemented using a stack and explores edges out of the most recently discovered vertex before backtracking to explore other paths.
3. Breadth first search begins at a root node and inspects all neighboring nodes before exploring nodes further away, implementing it using a queue.
Bfs dfs
Breadth-first search (BFS) and depth-first search (DFS) are two graph traversal algorithms that systematically visit all vertices and edges of a graph. BFS discovers vertices in order of distance from the source vertex, allowing it to compute shortest paths. DFS recursively explores as far as possible along each branch before backtracking, imposing a tree structure on the graph. Both algorithms run in O(V+E) time, where V is the number of vertices and E is the number of edges. DFS classifies edges as tree, forward, back, or cross edges and can detect cycles based on the presence of back edges.
Depth first search [dfs]
Depth-first search (DFS) is an algorithm that explores all the vertices reachable from a starting vertex by traversing edges in a depth-first manner. DFS uses a stack data structure to keep track of vertices to visit. It colors vertices white, gray, and black to indicate their status. DFS runs in O(V+E) time and can be used for applications like topological sorting and finding strongly connected components. The edges discovered during DFS can be classified as tree, back, forward, or cross edges based on the order in which vertices are discovered.
Bfs & dfs application
The document introduces breadth-first search (BFS) and depth-first search (DFS), two algorithms for traversing graphs. It provides explanations of how BFS and DFS work, including pseudocode algorithms. Examples of simulations of BFS and DFS on sample graphs are shown step-by-step with diagrams. Potential applications of BFS and DFS in areas like cycle detection, finding connected components, and topological sorting are also discussed.
DFS algorithm
The document discusses depth-first search (DFS) algorithms. It provides pseudocode for performing DFS on a graph and walks through an example of running DFS on a sample graph. It explains that DFS classifies edges in the original graph as tree edges, back edges, forward edges, or cross edges based on how vertices are encountered during the algorithm's execution.
Presentation on Breadth First Search (BFS)
This document contains a presentation on Breadth-First Search (BFS) given to students. The presentation includes:
- An introduction to BFS and its inventor Konrad Zuse.
- Definitions of key terms like graph, tree, vertex, level-order traversal.
- An example visualization of BFS on a graph with 14 steps.
- Pseudocode and a Java program implementing BFS.
- Applications of BFS like shortest paths, social networks, web crawlers.
- The time and space complexity of BFS is O(V+E) and O(V).
- A conclusion that BFS is an important algorithm that traverses
Articulation point
The document discusses articulation points in graphs. An articulation point is a vertex whose removal disconnects the graph into two or more components. The document presents an algorithm to find all articulation points in a graph using depth-first search (DFS) in O(V+E) time. It traverses the DFS tree, and a vertex is an articulation point if it is the root of the tree with two or more children, or if it is not the root and has a child such that no vertex in the child's subtree has a back edge to an ancestor of that vertex. Pseudocode for the algorithm is also provided.
Graphs bfs dfs
The document discusses Breadth First Search (BFS) and Depth First Search (DFS) algorithms for graphs. It defines key graph terminology and describes how to represent graphs using adjacency lists and matrices. It then explains how BFS and DFS work by exploring the graph in different ways, keeping track of vertex colors and paths/trees produced. Both algorithms run in O(V+E) time and have different applications like routing, sorting, and finding connected components.
Bfs and dfs in data structure
The document discusses graph algorithms breadth-first search (BFS) and depth-first search (DFS). It provides pseudocode for BFS and DFS algorithms and explains key aspects of each. BFS uses a queue to explore all neighbors of a node before moving to the next level, building a breadth-first tree. DFS uses recursion to explore as deep as possible along each branch before backtracking, resulting in a depth-first tree structure. Both algorithms run in O(V+E) time on a graph with V vertices and E edges.
Graph
This document discusses various graph algorithms including depth-first search (DFS), breadth-first search (BFS), union find, Kruskal's algorithm, Floyd-Warshall's algorithm, Dijkstra's algorithm, and bipartite graphs. It provides definitions, pseudocode, sample code, and sample problems for implementing each algorithm.
Dfs presentation
The document describes depth-first search (DFS), an algorithm for traversing or searching trees or graphs. It defines DFS, explains the process as visiting nodes by going deeper until reaching the end and then backtracking, provides pseudocode for the algorithm, gives an example on a directed graph, and discusses time complexity (O(V+E)), advantages like linear memory usage, and disadvantages like possible infinite traversal without a cutoff depth.
Data structures and algorithms lab7
This document summarizes a lab on data structures and algorithms related to graphs. It introduces graphs and their representations, as well as graph traversal algorithms like depth-first search (DFS) and breadth-first search (BFS). It also discusses bipartite graphs. The lab objectives are to learn about graphs, DFS, BFS, and bipartite graphs. Various exercises are provided to apply these graph concepts.
BFS (Breadth First Search) Tree Traversal
1) Breadth-first search (BFS) is an algorithm for traversing or searching tree or graph data structures. It starts at the tree root (or some arbitrary node of a graph) and explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level.
2) BFS uses a queue to keep track of nodes to visit at each level, processing nodes level-by-level from the queue in a FIFO order. It marks visited nodes to avoid processing them again.
3) The time complexity of BFS is O(V+E) where V is the number of vertices and E is the number of edges. BFS can be used to
BFS
This document describes graph search algorithms like breadth-first search (BFS) and their applications. It provides details on how BFS works, including that it maintains queues to search levels outwards from the starting vertex, and outputs the distance and predecessor of each vertex. BFS runs in O(V+E) time by visiting each vertex and edge once. The document also discusses how BFS can be used to find connected components in a graph and determine if a graph is bipartite.
articulation points in graph
This document discusses how to find articulation points in a graph using depth-first search (DFS). It begins by reviewing the DFS algorithm and concepts like discovery time. It then makes two key observations: (1) roots with two or more children and (2) internal vertices where a subtree has no back edge climbing higher are articulation points. It introduces the concept of low(v) to track the lowest discovery time reachable from v to determine if a subtree can climb higher. The algorithm runs DFS to compute low(v) values and identifies articulation points based on the two observations. The running time is O(V+E).
2.5 dfs & bfs
This document discusses different graph traversal algorithms: depth-first traversal, breadth-first traversal, and their implementations. Depth-first traversal uses a stack and can output nodes in either preorder or postorder. Breadth-first traversal uses a queue and outputs nodes level-by-level. Pseudocode and examples are provided for both algorithms. Review questions ask the reader to trace the output order of different traversals on sample graphs.
Breadth first search (Bfs)
This document provides an overview of the Breadth-First Search (BFS) graph traversal algorithm. It begins by explaining that BFS starts at the root node and explores all neighboring nodes, selecting the nearest unexplored node at each step. It then provides examples of BFS traversing different graphs and describes the key aspects of the BFS algorithm, including maintaining a queue, coloring nodes as white/gray/black to track explored status, and updating distance and predecessor values at each step. In the end, it analyzes the properties of BFS, such as finding the shortest path distances, and discusses applications like finding connected components.
Graphs
The document discusses different types of graphs including directed and undirected graphs. It describes graph implementations using adjacency matrices and adjacency lists. It also covers graph traversal algorithms like depth-first search (DFS) and breadth-first search (BFS). DFS prioritizes exploring paths as deeply as possible while BFS explores all paths at the same depth level before moving deeper. Real-world examples of graphs include social networks and transportation networks.
What's hot (20)
Similar to lecture 19
lecture 18
The document discusses the algorithms of breadth-first search (BFS) and depth-first search (DFS) on graphs. It provides pseudocode for BFS and DFS, and examples of running the algorithms on sample graphs. Key points include:
- BFS uses a queue to explore all neighbors of a vertex before moving to the next level. It finds the shortest paths from the source.
- DFS uses recursion to explore as deep as possible before backtracking. It identifies tree edges, back edges, and forward edges.
- Both BFS and DFS run in O(V+E) time on a graph with V vertices and E edges.
lecture24.ppt
The document discusses depth-first search (DFS) algorithms for exploring graphs. It begins by reviewing DFS, noting that it explores deeper in the graph whenever possible by exploring edges out of the most recently discovered vertex. It then shows pseudocode for performing DFS on a graph. The document proceeds to provide an example run of DFS on a graph, demonstrating the discovery order of vertices and labeling of tree, back, forward, and cross edges. It concludes by discussing properties of DFS, such as only producing tree and back edges in undirected graphs and using DFS to detect cycles in O(V+E) time.
graphin-c1.pnggraphin-c1.txt1 22 3 83 44 5.docx
graphin-c1.png
graphin-c1.txt
1: 2
2: 3 8
3: 4
4: 5
5: 3
6: 7
7: 3 6 8
8: 1 9
9: 1
graphin-c2.jpg
graphin-c2.txt
1: 2 9
2: 3 8
3: 4
4: 5 9
5: 3
6: 7
7: 3 6 8
8: 1
9:
graphin-DAG.png
graphin-DAG.txt
1: 2
2: 3 8
3: 4
4: 5
5: 9
6: 4 7
7: 3 8
8: 9
9:
CS 340 Programming Assignment III:
Topological Sort
Description: You are to implement the Depth-First Search (DFS) based algorithm for (i)
testing whether or not the input directed graph G is acyclic (a DAG), and (ii) if G is a DAG,
topologically sorting the vertices of G and outputting the topologically sorted order.
I/O Specifications: You will prompt the user from the console to select an input graph
filename, including the sample file graphin.txt as an option. The graph input files must be of
the following adjacency list representation where each xij is the j'th neighbor of vertex i (vertex
labels are 1 through n):
1: x11 x12 x13 ...
2: x21 x22 x23 ...
.
.
n: xn1 xn2 xn3 ...
Your output will be to the console. You will first output whether or not the graph is acyclic. If
the graph is NOT acyclic, then you will output the set of back edges you have detected during
DFS. Otherwise, if the graph is acyclic, then you will output the vertices in topologically
sorted order.
Algorithmic specifications:
Your algorithm must use DFS appropriately and run in O(E + V) time on any input graph. You will
need to keep track of edge types and finish times so that you can use DFS for detecting
cyclicity/acyclicity and topologically sorting if the graph is a DAG. You may implement your graph
class as you wish so long as your overall algorithm runs correctly and efficiently.
What to Turn in: You must turn in a single zipped file containing your source code, a Makefile
if your language must be compiled, appropriate input and output files, and a README file
indicating how to execute your program (especially if not written in C++ or Java). Refer to
proglag.pdf for further specifications.
This assignment is due by MIDNIGHT of Monday, February 19. Late submissions
carry a minus 40% per-day late penalty.
Sheet1Name:Possible:Score:Comments:10Graph structure with adjacency list representationDFS16Correct and O(V+E) time10Detecting cycles, is graph DAG?Topological Sort16Correctness of Topo-Sort algorithm and output18No problems in compilation and execution? Non-compiling projects receive max total 10 points, and code that compiles but crashes during execution receives max total 18 points.700Total
&"Helvetica,Regular"&12&K000000&P
Sheet2
&"Helvetica,Regular"&12&K000000&P
Sheet3
&"Helvetica,Regular"&12&K000000&P
DFS and topological sort
CS340
Depth first search
breadth
depth
Search "deeper" whenever possible
*example shows discovery times
Depth first search
Input: G = (V,E), directed or undirected.
No source vertex is given!
Output: 2 timestamps on each vertex:
v.d discovery time
v.f finishing time
These will be useful ...
Breadth first search
BFS is the most commonly used approach. BFS is a traversing algorithm where you should start traversing from a selected node (source or starting node) and traverse the graph layerwise thus exploring the neighbor nodes (nodes which are directly connected to the source node.
Graph Traversal Algorithms - Depth First Search Traversal
This document discusses graph traversal techniques, specifically depth-first search (DFS) and breadth-first search (BFS). It provides pseudocode for DFS and explains key properties like edge classification, time complexity of O(V+E), and applications such as finding connected components and articulation points.
Skiena algorithm 2007 lecture12 topological sort connectivity
1. The document discusses depth-first search (DFS), including its recursive implementation which eliminates the need for an explicit stack. 2. DFS classifies the edges of a graph as tree edges, back edges, forward edges, or cross edges. Tree edges and back edges are the only possible edge types in an undirected graph searched with DFS. 3. Applications of DFS include finding cycles, articulation vertices, topological sorting of directed acyclic graphs, and finding strongly connected components.
DFS ppt.pdf
DFS explores a path fully before backtracking, coloring nodes white, gray, then black. It uses two timestamps, discover and finish times. The DFS algorithm initializes colors and timestamps, then calls DFS_VISIT on each white node to explore its subtree and color neighbors. DFS runs in O(V+E) time. It is used for topological sorting and finding strongly connected components. Edges are classified as tree, back, forward, or cross based on node colors during exploration.
Algorithm Design and Complexity - Course 7
The document discusses algorithms for graphs, including breadth-first search (BFS) and depth-first search (DFS). BFS uses a queue to traverse nodes level-by-level from a starting node, computing the shortest path. DFS uses a stack, exploring as far as possible along each branch before backtracking, and computes discovery and finish times for nodes. Both algorithms color nodes white, gray, black to track explored status and maintain predecessor pointers to reconstruct paths. Common graph representations like adjacency lists and matrices are also covered.
kumattt).pptx
This document provides an overview of depth-first search (DFS) and breadth-first search (BFS) algorithms. It introduces the presenter, Kumar Ayush Singh Deo, and their subject on analyzing and digitizing algorithms. Key topics covered include definitions of graphs, how DFS and BFS work by exploring adjacent vertices, analysis of time complexity when using adjacency lists or matrices, examples of DFS on directed and undirected graphs illustrated with pseudocode, and applications of DFS and BFS.
DFS & BFS in Computer Algorithm
This document discusses breadth-first search (BFS) and depth-first search (DFS) algorithms for traversing graphs. It provides examples of how BFS uses a queue to search all neighbors at the current level before moving to the next level, while DFS uses a stack and explores each branch as far as possible before backtracking. The document compares key differences between BFS and DFS such as their time and space complexities, usefulness for finding shortest paths, and whether queues or stacks are used. Application areas for each algorithm are also mentioned.
Biconnected components (13024116056)
This document discusses bi-connected components in graphs. It defines an articulation point as a vertex in a connected graph whose removal would disconnect the graph. A bi-connected component is a maximal subgraph that contains no articulation points. The document presents algorithms for identifying articulation points and bi-connected components in a graph using depth-first search (DFS). It introduces the concepts of tree edges, back edges, forward edges and cross edges in a DFS tree and explains how to use these edge types to determine if a vertex is an articulation point based on the minimum discovery time of its descendant vertices.
Topological sort
Topological sort is an algorithm that finds an ordering of tasks that respects their dependencies. It works by performing a depth-first search (DFS) on a directed graph where vertices represent tasks and edges represent dependencies. During DFS, each vertex is assigned a finishing time. The topological sort orders the tasks according to decreasing finishing time, so that all dependencies are satisfied. The algorithm runs in O(V+E) time, where V is the number of vertices and E is the number of edges.
Graps 2
The document discusses breadth-first search (BFS) algorithms for graphs. It explains that BFS runs in O(n^2) time on adjacency matrices due to checking all elements in each row, but in O(n+m) time on adjacency lists where m is the number of edges. It then describes how to modify BFS to record the shortest path between nodes using a predecessor array. The rest of the document provides examples of how BFS works and applications such as finding connected components and directed acyclic graphs.
Algorithm Design and Complexity - Course 8
The document discusses algorithms for finding strongly connected components (SCCs) in directed graphs. It describes Kosaraju's algorithm, which uses two depth-first searches (DFS) to find the SCCs. The first DFS computes a finishing time ordering, while the second DFS uses the transpose graph and the finishing time ordering to find the SCCs, outputting each SCC as a separate DFS tree. The algorithm runs in O(V+E) time and uses the property that the first DFS provides a topological sorting of the SCCs graph.
YCMOU_FYBCA_DS_Unit-7.ppt
The document discusses graph theory concepts including representations of graphs like adjacency matrix and adjacency list, and graph traversal algorithms like depth-first search (DFS) and breadth-first search (BFS). It provides pseudocode for DFS and BFS algorithms and examples of their use. It also notes that graph theory is used for shortest path algorithms like Dijkstra's, Prim's and Kruskal's.
B.tech admission in india
The document discusses graphs and graph algorithms. It defines graphs and their representations using adjacency lists and matrices. It then describes the Breadth-First Search (BFS) and Depth-First Search (DFS) algorithms for traversing graphs. BFS uses a queue to explore the neighbors of each vertex level-by-level, while DFS uses a stack to explore as deep as possible first before backtracking. Pseudocode and examples are provided to illustrate how the algorithms work.
Graphs
The document discusses graphs and graph algorithms. It defines what a graph is - a non-linear data structure consisting of vertices connected by edges. It describes different graph representations like adjacency matrix, incidence matrix and adjacency list. It also explains graph traversal algorithms like depth-first search and breadth-first search. Finally, it covers minimum spanning tree algorithms like Kruskal's and Prim's algorithms for finding minimum cost spanning trees in graphs.
Elementary Graph Algo.ppt
This document discusses elementary graph algorithms, including breadth-first search (BFS) and depth-first search (DFS). It provides background on graph representations using adjacency lists and matrices. It then describes the key steps of BFS and DFS, including initializing data structures, exploring edges, and classifying edge types. BFS finds the shortest path between two nodes by exploring the closest nodes first. DFS searches deeper whenever possible and backtracks to explore other branches.
Graphs
adjacency matrix ppt, bfs ppt, dfs ppt, graph representations, graph traversals, introduction to graphs, krushkal minimum spanning tree ppt, minimum spanning tree, prims minimum spanning tree ppt, topological sort ppt
topological_sort_strongly Connected Components
The document describes algorithms for depth-first search (DFS) and how it can be used to find strongly connected components (SCCs) in a directed graph. DFS assigns discovery and finish times to vertices and classifies graph edges. It can determine if a graph is acyclic by checking for back edges. To find SCCs, DFS is run on the original graph and its transpose to group vertices reachable from each other into components. The result is a directed acyclic graph of components. Lemmas are presented about paths between components based on discovery/finish times.
Similar to lecture 19 (20)
Graph Traversal Algorithms - Depth First Search Traversal
Graph Traversal Algorithms - Depth First Search Traversal
Skiena algorithm 2007 lecture12 topological sort connectivity
Skiena algorithm 2007 lecture12 topological sort connectivity
More from sajinsc
lecture 30
The document reviews concepts related to NP-completeness, including reductions between problems. It provides examples of reducing the directed Hamiltonian cycle problem to the undirected version. It also reduces 3-SAT to the clique problem by transforming a Boolean formula to a graph, then further reduces clique to vertex cover. Hundreds of problems have been shown to be NP-complete through relatively simple reductions like these that leverage previous results.
lecture 29
The document discusses reductions between problems to prove NP-completeness. It first reviews P, NP, reductions, NP-hard and NP-complete problems. It then walks through reducing directed Hamiltonian cycle to undirected Hamiltonian cycle to traveling salesman problem (TSP) to prove that TSP is NP-complete in 3 steps or less.
lecture 28
This document discusses NP-completeness and algorithms. It begins by reviewing tractable versus intractable problems, and the complexity classes P and NP. P contains problems solvable in polynomial time, while NP includes problems verifiable in polynomial time. The document then discusses NP-complete problems, which are the hardest problems in NP. It notes that reducing one problem to another shows the first problem is no harder than the second. The document concludes by outlining the steps to prove a problem is NP-complete: choosing a known NP-complete problem, reducing it to the target problem in polynomial time, and showing the target is in NP.
lecture 27
The document discusses NP-completeness and algorithms. It introduces dynamic programming and greedy algorithms. It then discusses the activity selection problem and shows it can be solved greedily by choosing the activity with the earliest finish time at each step. Finally, it defines the classes P and NP, introduces the concept of reductions to show problems are NP-complete, and states that if any NP-complete problem can be solved in polynomial time, then P=NP.
lecture 26
The document discusses various algorithms techniques including greedy algorithms, dynamic programming, and their application to problems like the activity selection problem and knapsack problem. It provides examples of optimal subproblems, overlapping subproblems, and how dynamic programming and greedy algorithms can be used to solve problems exhibiting these properties.
lecture 25
The document describes the 0-1 knapsack problem and how to solve it using dynamic programming. The 0-1 knapsack problem involves packing items of different weights and values into a knapsack of maximum capacity to maximize the total value without exceeding the weight limit. A dynamic programming algorithm is presented that breaks the problem down into subproblems and uses optimal substructure and overlapping subproblems to arrive at the optimal solution in O(nW) time, improving on the brute force O(2^n) time. An example is shown step-by-step to illustrate the algorithm.
lecture 24
The document discusses dynamic programming and its application to solving the longest common subsequence (LCS) problem. It presents the LCS algorithm, which uses dynamic programming to find the length and sequence of the longest subsequence common to two strings X and Y in O(mn) time, where m and n are the lengths of X and Y, respectively. It provides an example running the LCS algorithm on strings X="ABCB" and Y="BDCAB" to determine their longest common subsequence is "BCB".
lecture 23
The document discusses dynamic programming and amortized analysis. It reviews how dynamic tables use amortized analysis to achieve an overall cost of O(1) per insertion by occasionally doubling the table size and reinserting all elements. This results in a worst case cost of O(n) for a single insertion but averages to O(1) over many insertions. It also discusses using an accounting method with a $3 charge per insertion to pay for future table resizes, achieving an amortized cost of O(1) per operation. Finally, it introduces dynamic programming and uses the longest common subsequence problem to illustrate how it breaks problems into optimal subrecurring subproblems.
lecture 22
The document discusses algorithms and data structures covered in a CS algorithms course, including Dijkstra's algorithm, Bellman-Ford algorithm, shortest paths in DAGs, Kruskal's algorithm for minimum spanning trees, and disjoint-set union data structures. It provides examples and explanations of how each algorithm works.
lecture 21
The document discusses algorithms for solving the single-source shortest path problem, including Dijkstra's algorithm, Bellman-Ford algorithm, and shortest paths in directed acyclic graphs (DAGs). It reviews the key ideas behind relaxation and how algorithms like Bellman-Ford and Dijkstra's use relaxation to iteratively improve the upper bound on shortest path distances. Running times of the algorithms are analyzed, with Dijkstra's algorithm taking O(ElogV) time and Bellman-Ford taking O(VE) time.
lecture 20
The document describes Prim's algorithm for finding a minimum spanning tree (MST) of a weighted undirected graph. It shows the pseudocode for Prim's algorithm and step-by-step workings on an example graph to build up the MST. It notes that the key operation is decreasing the key value, which is called once for each edge in the MST, and the running time depends on the priority queue implementation, being O(ElgV) for a binary heap and O(VlgV+E) for a Fibonacci heap.
lecture 17
The document discusses interval trees and breadth-first search (BFS) algorithms. Interval trees are used to maintain a set of intervals and efficiently find overlapping intervals given a query. BFS is a graph search algorithm that explores all neighboring vertices of a starting node before moving to neighbors of neighbors. BFS builds a breadth-first tree and calculates the shortest path distances from the source node in O(V+E) time and space.
lecture 16
The document discusses algorithms for finding minimum spanning trees in graphs. It describes two common algorithms: Kruskal's algorithm and Prim's algorithm. Kruskal's algorithm sorts the edges by weight and builds up the spanning tree by adding edges that do not create cycles. Prim's algorithm maintains a set of vertices in the spanning tree and iteratively adds the lowest weight edge connecting a vertex outside the set to one inside. Both run in O((V+E)logV) time using efficient data structures.
lecture 15
The document discusses two algorithms for matrix multiplication and finding the median of an unsorted list:
1) Strassen's algorithm improves on the traditional O(n^3) matrix multiplication algorithm by using divide and conquer to achieve O(n^lg7) time complexity.
2) Finding the median can be done in expected O(n) time using quickselect, or deterministically in O(n) time by choosing the median of medians as the pivot.
lecture 14
The document discusses red-black trees and their operations. It reviews the properties of red-black trees that guarantee logarithmic height. It then describes that inserting nodes can violate properties and requires recoloring nodes or rotating the tree. The key steps of insertion involve adding the new node as red, then fixing any violations by moving them up the tree through recoloring and rotations.
lecture 13
The document discusses red-black trees, which are binary search trees augmented with node colors to guarantee a height of O(log n). It describes the properties that red-black trees must satisfy, including that every node is red or black, leaves are black, and if a node is red its children are black. It then proves that these properties ensure the height is O(log n) by showing a subtree has at least 2^bh - 1 nodes, where bh is the black-height. Finally, it notes that common operations like search, insert and delete run in O(log n) time on red-black trees.
lecture 12
The document discusses binary search trees (BSTs) and their use as a data structure for dynamic sets. It covers BST properties, operations like search, insert, delete and their running times. It also discusses using BSTs to sort an array in O(n lg n) time by inserting elements, similar to quicksort. Maintaining a height of O(lg n) is important for efficient operations.
lecture 11
This document discusses binary search trees (BSTs) and their use for dynamic sets and sorting. It covers BST operations like search, insert, find minimum/maximum, and delete. It explains that BST sorting runs in O(n log n) time like quicksort. Maintaining a height of O(log n) can lead to efficient implementations of priority queues and other dynamic set applications using BSTs.
lecture 10
The document discusses various sorting algorithms and their time complexities:
1. Comparison sorts like merge sort and quicksort have a best case time complexity of O(n log n).
2. Counting sort runs in O(n+k) time where k is the range of input values, and is not a comparison sort.
3. Radix sort treats input as d-digit numbers in some base k and uses counting sort to sort on each digit, achieving O(dn+dk) time which is O(n) when d and k are constants.
4. A randomized selection algorithm finds the ith order statistic in expected O(n) time using randomized partition.
lecture 9
The document discusses various sorting algorithms and their time complexities, including:
- Insertion sort runs in O(n^2) time in the worst case.
- Merge sort and heap sort run in O(nlogn) time in the worst case.
- Any comparison-based sorting algorithm requires Ω(nlogn) time.
- Counting sort and radix sort can run in O(n) time by avoiding comparisons, but have additional requirements on the key range.
More from sajinsc (20)
Recently uploaded
BÀI TẬP BỔ TRỢ TIẾNG ANH 8 CẢ NĂM - GLOBAL SUCCESS - NĂM HỌC 2023-2024 (CÓ FI...
BÀI TẬP BỔ TRỢ TIẾNG ANH 8 CẢ NĂM - GLOBAL SUCCESS - NĂM HỌC 2023-2024 (CÓ FI...Nguyen Thanh Tu Collection
https://app.box.com/s/y977uz6bpd3af4qsebv7r9b7s21935vdAzure Interview Questions and Answers PDF By ScholarHat
Azure Interview Questions and Answers PDF By ScholarHat
Main Java[All of the Base Concepts}.docx
This is part 1 of my Java Learning Journey. This Contains Custom methods, classes, constructors, packages, multithreading , try- catch block, finally block and more.
Executive Directors Chat Leveraging AI for Diversity, Equity, and Inclusion
Let’s explore the intersection of technology and equity in the final session of our DEI series. Discover how AI tools, like ChatGPT, can be used to support and enhance your nonprofit's DEI initiatives. Participants will gain insights into practical AI applications and get tips for leveraging technology to advance their DEI goals.
How to Build a Module in Odoo 17 Using the Scaffold Method
Odoo provides an option for creating a module by using a single line command. By using this command the user can make a whole structure of a module. It is very easy for a beginner to make a module. There is no need to make each file manually. This slide will show how to create a module using the scaffold method.
DRUGS AND ITS classification slide share
Any substance (other than food) that is used to prevent, diagnose, treat, or relieve symptoms of a
disease or abnormal condition
Hindi varnamala | hindi alphabet PPT.pdf
हिंदी वर्णमाला पीपीटी, hindi alphabet PPT presentation, hindi varnamala PPT, Hindi Varnamala pdf, हिंदी स्वर, हिंदी व्यंजन, sikhiye hindi varnmala, dr. mulla adam ali, hindi language and literature, hindi alphabet with drawing, hindi alphabet pdf, hindi varnamala for childrens, hindi language, hindi varnamala practice for kids, https://www.drmullaadamali.com
Digital Artifact 1 - 10VCD Environments Unit
Digital Artifact 1 - 10VCD Environments Unit - NGV Pavilion Concept Design
Pollock and Snow "DEIA in the Scholarly Landscape, Session One: Setting Expec...
Pollock and Snow "DEIA in the Scholarly Landscape, Session One: Setting Expec...National Information Standards Organization (NISO)
This presentation was provided by Steph Pollock of The American Psychological Association’s Journals Program, and Damita Snow, of The American Society of Civil Engineers (ASCE), for the initial session of NISO's 2024 Training Series "DEIA in the Scholarly Landscape." Session One: 'Setting Expectations: a DEIA Primer,' was held June 6, 2024.Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Natural birth techniques - Mrs.Akanksha Trivedi Rama UniversityAkanksha trivedi rama nursing college kanpur.
Natural birth techniques are various type such as/ water birth , alexender method, hypnosis, bradley method, lamaze method etcWalmart Business+ and Spark Good for Nonprofits.pdf
"Learn about all the ways Walmart supports nonprofit organizations.
You will hear from Liz Willett, the Head of Nonprofits, and hear about what Walmart is doing to help nonprofits, including Walmart Business and Spark Good. Walmart Business+ is a new offer for nonprofits that offers discounts and also streamlines nonprofits order and expense tracking, saving time and money.
The webinar may also give some examples on how nonprofits can best leverage Walmart Business+.
The event will cover the following::
Walmart Business + (https://business.walmart.com/plus) is a new shopping experience for nonprofits, schools, and local business customers that connects an exclusive online shopping experience to stores. Benefits include free delivery and shipping, a 'Spend Analytics” feature, special discounts, deals and tax-exempt shopping.
Special TechSoup offer for a free 180 days membership, and up to $150 in discounts on eligible orders.
Spark Good (walmart.com/sparkgood) is a charitable platform that enables nonprofits to receive donations directly from customers and associates.
Answers about how you can do more with Walmart!"
Advanced Java[Extra Concepts, Not Difficult].docx
This is part 2 of my Java Learning Journey. This contains Hashing, ArrayList, LinkedList, Date and Time Classes, Calendar Class and more.
Community pharmacy- Social and preventive pharmacy UNIT 5
Covered community pharmacy topic of the subject Social and preventive pharmacy for Diploma and Bachelor of pharmacy
How to Add Chatter in the odoo 17 ERP Module
In Odoo, the chatter is like a chat tool that helps you work together on records. You can leave notes and track things, making it easier to talk with your team and partners. Inside chatter, all communication history, activity, and changes will be displayed.
How to Manage Your Lost Opportunities in Odoo 17 CRM
Odoo 17 CRM allows us to track why we lose sales opportunities with "Lost Reasons." This helps analyze our sales process and identify areas for improvement. Here's how to configure lost reasons in Odoo 17 CRM
Your Skill Boost Masterclass: Strategies for Effective Upskilling
Your Skill Boost Masterclass: Strategies for Effective UpskillingExcellence Foundation for South Sudan
Strategies for Effective Upskilling is a presentation by Chinwendu Peace in a Your Skill Boost Masterclass organisation by the Excellence Foundation for South Sudan on 08th and 09th June 2024 from 1 PM to 3 PM on each day.Recently uploaded (20)
BÀI TẬP BỔ TRỢ TIẾNG ANH 8 CẢ NĂM - GLOBAL SUCCESS - NĂM HỌC 2023-2024 (CÓ FI...
BÀI TẬP BỔ TRỢ TIẾNG ANH 8 CẢ NĂM - GLOBAL SUCCESS - NĂM HỌC 2023-2024 (CÓ FI...
Azure Interview Questions and Answers PDF By ScholarHat
Azure Interview Questions and Answers PDF By ScholarHat
Executive Directors Chat Leveraging AI for Diversity, Equity, and Inclusion
Executive Directors Chat Leveraging AI for Diversity, Equity, and Inclusion
How to Build a Module in Odoo 17 Using the Scaffold Method
How to Build a Module in Odoo 17 Using the Scaffold Method
Pollock and Snow "DEIA in the Scholarly Landscape, Session One: Setting Expec...
Pollock and Snow "DEIA in the Scholarly Landscape, Session One: Setting Expec...
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Walmart Business+ and Spark Good for Nonprofits.pdf
Walmart Business+ and Spark Good for Nonprofits.pdf
Liberal Approach to the Study of Indian Politics.pdf
Liberal Approach to the Study of Indian Politics.pdf
Community pharmacy- Social and preventive pharmacy UNIT 5
Community pharmacy- Social and preventive pharmacy UNIT 5
How to Manage Your Lost Opportunities in Odoo 17 CRM
How to Manage Your Lost Opportunities in Odoo 17 CRM
Your Skill Boost Masterclass: Strategies for Effective Upskilling
Your Skill Boost Masterclass: Strategies for Effective Upskilling
Film vocab for eal 3 students: Australia the movie
Film vocab for eal 3 students: Australia the movie
lecture 19
- 1. CS 332: Algorithms Graph Algorithms
- 4. DFS Example source vertex
- 5. DFS Example 1 | | | | | | | | source vertex d f
- 6. DFS Example 1 | | | | | | 2 | | source vertex d f
- 7. DFS Example 1 | | | | | 3 | 2 | | source vertex d f
- 8. DFS Example 1 | | | | | 3 | 4 2 | | source vertex d f
- 9. DFS Example 1 | | | | 5 | 3 | 4 2 | | source vertex d f
- 10. DFS Example 1 | | | | 5 | 6 3 | 4 2 | | source vertex d f
- 11. DFS Example 1 | 8 | | | 5 | 6 3 | 4 2 | 7 | source vertex d f
- 12. DFS Example 1 | 8 | | | 5 | 6 3 | 4 2 | 7 | source vertex d f
- 13. DFS Example 1 | 8 | | | 5 | 6 3 | 4 2 | 7 9 | source vertex d f What is the structure of the yellow vertices? What do they represent?
- 14. DFS Example 1 | 8 | | | 5 | 6 3 | 4 2 | 7 9 |10 source vertex d f
- 15. DFS Example 1 | 8 |11 | | 5 | 6 3 | 4 2 | 7 9 |10 source vertex d f
- 16. DFS Example 1 |12 8 |11 | | 5 | 6 3 | 4 2 | 7 9 |10 source vertex d f
- 17. DFS Example 1 |12 8 |11 13| | 5 | 6 3 | 4 2 | 7 9 |10 source vertex d f
- 18. DFS Example 1 |12 8 |11 13| 14| 5 | 6 3 | 4 2 | 7 9 |10 source vertex d f
- 19. DFS Example 1 |12 8 |11 13| 14|15 5 | 6 3 | 4 2 | 7 9 |10 source vertex d f
- 20. DFS Example 1 |12 8 |11 13|16 14|15 5 | 6 3 | 4 2 | 7 9 |10 source vertex d f
- 22. DFS Example 1 |12 8 |11 13|16 14|15 5 | 6 3 | 4 2 | 7 9 |10 source vertex d f Tree edges
- 24. DFS Example 1 |12 8 |11 13|16 14|15 5 | 6 3 | 4 2 | 7 9 |10 source vertex d f Tree edges Back edges
- 26. DFS Example 1 |12 8 |11 13|16 14|15 5 | 6 3 | 4 2 | 7 9 |10 source vertex d f Tree edges Back edges Forward edges
- 28. DFS Example 1 |12 8 |11 13|16 14|15 5 | 6 3 | 4 2 | 7 9 |10 source vertex d f Tree edges Back edges Forward edges Cross edges