Lecture 5

Analysis, Design of Algorithms
CS3610
Dr. Islam Hegazy

Associate Professor
F2023 Analysis, Design of Algorithms 1

Objectives
By the end of this lecture, you will:
Differentiate between the graph traversal techniques DFS and BFS
Know the complexity of each technique

Agenda
01 Depth-First Search 02 Breadth-First Search

Depth-First Search
Search as deep as possible first.
Choose a vertex v (source, usually root of tree)
Explore edges out of v

1. Depth-First Search
When all edges of v have been explored, backtrack to predecessor of v and

explore all edges from predecessor
Continue until all vertices reachable from the original source are discovered

Depth-First Search
Many problems in computer science can be solved using DFS
Analyzing networks
Mapping routes
Scheduling
Finding spanning trees
DFS can also be used as a subroutine to solve complex problems
Matching algorithm
Hopcroft–Karp
Traveling Salesman problem

Depth-First Search
It is convenient to use a stack to trace the operation of depth-first search.
Push a vertex onto the stack when the vertex is reached for the first time (i.e
the visit of the vertex starts)
Pop a vertex off the stack when it becomes a dead end (i.e., the visit of the
vertex ends).

Depth-First Search
0 3
Visited
2
Stack
1 4

Depth-First Search
0 3
0 Visited
2
1 2 3 Stack
1 4

Depth-First Search
0 3
0 1 Visited
2
2 3 Stack
1 4

Depth-First Search
0 3
0 1 2 Visited
2
4 3 Stack
1 4

Depth-First Search
0 3
0 1 2 4 Visited
2
3 Stack
1 4

Depth-First Search
0 3
0 1 2 4 3 Visited
2
Stack
1 4

Depth-First Search
A standard DFS implementation puts each vertex of the graph into one of two
categories:
Visited
Not Visited
The purpose of the algorithm is to mark each vertex as visited while avoiding
cycles.

Depth-First Search
The DFS algorithm works as follows:
Start by putting any one of the graph's vertices on top of a stack.
Take the top item of the stack and add it to the visited list.
Create a list of that vertex's adjacent nodes. Add the ones which aren't in the
visited list to the top of the stack.
Keep repeating steps 2 and 3 until the stack is empty.

Depth-First Search
Implements a depth-first search traversal of a given graph
Input: Graph G = (V, E)
Output: Graph G with its vertices marked with consecutive integers in the order
they are first encountered by the DFS traversal
DFS(G)
mark each vertex in V with 0 as a mark of being “unvisited”
count ←0
for each vertex v in V do
if v is marked with 0
dfs(v)

Depth-First Search
Visit recursively all the unvisited vertices connected to vertex v by a path and
numbers them in the order they are encountered via global variable count
dfs(v)
count ←count + 1;
mark v with count
for each vertex w in V adjacent to v do
if w is marked with 0
dfs(w)

Depth-First Search
Time complexity of DFS
If represented in adjacency matrix = O(V2)
If represented in adjacency list = O(V + E)


Depth-First Search
Applications of DFS
Cycle Detection
Maze Solver
Resolve Dependencies (Topological Sort)

Job Scheduling
Courses Ordering
Find Strongly Connected Components (SCC) in Directed G
…

Agenda
01 Depth-First Search 02 Breadth-First Search

Breadth-First Search
Explore a graph, turning it into a tree

One vertex at a time
Expand frontier of explored vertices across its breadth
2. BreadthFirst Search
Discovers all vertices at distance k from s before those at distance k+1

A level-by-level order traversal
Builds a tree over the graph
Pick a source vertex to be the root
Find (“discover”) all of its children, then all of their children, etc.

Proceeds in a concentric manner by visiting first all the vertices that are
adjacent to a starting vertex,
Then visit unvisited vertices two edges apart from it, and so on, until all the
vertices are visited.

0
1 2 3
4 5 6 7
8

0
1 2 3
4 5 6 7
8

0
1 2 3
4 5 6 7
8

0
1 2 3
4 5 6 7
8

0
1 2 3
4 5 6 7
8

0
1 2 3
4 5 6 7
8

0
1 2 3
4 5 6 7
8

0
1 2 3
4 5 6 7
8

0
1 2 3
4 5 6 7
8

0
1 2 3
4 5 6 7
8
It is convenient to use a queue to trace the operation of breadth-first search.
Add a vertex onto the queue when the vertex is reached for the first time (i.e
the visit of the vertex starts)
Add neighbours of the front vertex to the queue

Remove front vertex and mark it as visited

0 3
Visited
2
Queue
1 4

0 3
0 Visited
2
1 2 3 Queue
1 4

0 3
0 1 Visited
2
2 3 Queue
1 4

0 3
0 1 2 Visited
2
3 4 Queue
1 4

0 3
0 1 2 3 Visited
2
4 Queue
1 4

0 3
0 1 2 3 4 Visited
2
Queue
1 4

Implements a breadth-first search traversal of a given graph
Input: Graph G = V, E
Output: Graph G with its vertices marked with consecutive integers in the order
they are visited by the BFS traversal
BFS(G)
mark each vertex in V with 0 as a mark of being “unvisited”
count ←0
for each vertex v in V do
if v is marked with 0
bfs(v)

Visits all the unvisited vertices connected to vertex v by a path and numbers
them in the order they are visited via global variable count
bfs(v)
count ←count + 1;
mark v with count and initialize a queue with v
while the queue is not empty do
for each vertex w in V adjacent to the front vertex do
if w is marked with 0
count ←count + 1;
mark w with count
add w to the queue
remove the front vertex from the queue
Applications of BFS
Shortest path (un-weighted G)
Find Connected Components in Undirected G

Web Crawling
Social N/W: Friend Finder
Pocket Cube (2x2x2 Rubic Cube)
Garbage Collector
…

DFS BFS
Traversal order Depth Level

Data structure Stack Queue
Time complexity O(V+E) || O(V2) O(V+E) || O(V2)
Space complexity O(V) O(V)


Lecture 5

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lecture 5

Uploaded by

Copyright:

Available Formats

Analysis, Design of Algorithms

Dr. Islam Hegazy

F2023 Analysis, Design of Algorithms 1

By the end of this lecture, you will:

Differentiate between the graph traversal techniques DFS and BFS

Know the complexity of each technique

F2023 Analysis, Design of Algorithms 2

01 Depth-First Search 02 Breadth-First Search

F2023 Analysis, Design of Algorithms 3

Search as deep as possible first.

Choose a vertex v (source, usually root of tree)

Explore edges out of v

When all edges of v have been explored, backtrack to predecessor of v and

F2023 Analysis, Design of Algorithms 4

Many problems in computer science can be solved using DFS

Traveling Salesman problem

It is convenient to use a stack to trace the operation of depth-first search.

F2023 Analysis, Design of Algorithms 6

F2023 Analysis, Design of Algorithms 7

F2023 Analysis, Design of Algorithms 8

F2023 Analysis, Design of Algorithms 9

F2023 Analysis, Design of Algorithms 10

F2023 Analysis, Design of Algorithms 11

F2023 Analysis, Design of Algorithms 12

F2023 Analysis, Design of Algorithms 13

The DFS algorithm works as follows:

Start by putting any one of the graph's vertices on top of a stack.

F2023 Analysis, Design of Algorithms 14

Implements a depth-first search traversal of a given graph

Input: Graph G = (V, E)

they are first encountered by the DFS traversal

F2023 Analysis, Design of Algorithms 15

F2023 Analysis, Design of Algorithms 16

Time complexity of DFS

If represented in adjacency matrix = O(V2)

If represented in adjacency list = O(V + E)

F2023 Analysis, Design of Algorithms 17

Resolve Dependencies (Topological Sort)

F2023 Analysis, Design of Algorithms 18

01 Depth-First Search 02 Breadth-First Search

F2023 Analysis, Design of Algorithms 19

Explore a graph, turning it into a tree

Discovers all vertices at distance k from s before those at distance k+1

F2023 Analysis, Design of Algorithms 20

vertices are visited.

vertices are visited.

vertices are visited.

vertices are visited.

vertices are visited.

vertices are visited.

vertices are visited.

vertices are visited.

vertices are visited.

vertices are visited.

It is convenient to use a queue to trace the operation of breadth-first search.

Add neighbours of the front vertex to the queue

F2023 Analysis, Design of Algorithms 31

F2023 Analysis, Design of Algorithms 32

F2023 Analysis, Design of Algorithms 33

F2023 Analysis, Design of Algorithms 34

F2023 Analysis, Design of Algorithms 35

F2023 Analysis, Design of Algorithms 36