Scribd
Upload
87 views56 pages

Graph-2 Dfs

The document discusses depth-first search (DFS) and breadth-first search (BFS) graph algorithms. It provides pseudocode for DFS that uses data structures like color, time, prev, d, and f arrays to track the state of vertices as the search progresses from one to the next. The code explores edges deeper first whenever possible before backtracking. An example run on a sample graph is shown with timestamps to illustrate the process.

Uploaded by

Nuzhat Afrin
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
87 views56 pages

Graph-2 Dfs

The document discusses depth-first search (DFS) and breadth-first search (BFS) graph algorithms. It provides pseudocode for DFS that uses data structures like color, time, prev, d, and f arrays to track the state of vertices as the search progresses from one to the next. The code explores edges deeper first whenever possible before backtracking. An example run on a sample graph is shown with timestamps to illustrate the process.

Uploaded by

Nuzhat Afrin
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 56

CSE 304

DFS

1
Last Class’s Topic

● Graph Representation
■ Adjacency Matrix
■ Adjacency List
● BFS – Breadth First Search

2
Breadth-First Search: The Code
Data: color[V], prev[V],d[V] While(Q not empty)
{
BFS(G) // starts from here u = DEQUEUE(Q);
{ for each v ∈ adj[u]{
for each vertex u ∈ if (color[v] == WHITE){
V-{s} color[v] = GREY;
{ d[v] = d[u] + 1;
color[u]=WHITE; prev[v] = u;
prev[u]=NIL; Enqueue(Q, v);
d[u]=inf; }
} }
color[s]=GRAY; color[u] = BLACK;
d[s]=0; prev[s]=NIL; }
Q=empty; }
ENQUEUE(Q,s);

3
Breadth-First Search: Print Path
Data: color[V], prev[V],d[V]

Print-Path(G, s, v)
{
if(v==s)
print(s)
else if(prev[v]==NIL)
print(No path);
else{
Print-Path(G,s,prev[v]);
print(v);
}
}

4
BFS – Questions
● Find the shortest path between “A” and “B” (with
path)? When will it fail?
● Find the most distant node from start node “A”
● How can we detect that there exists no path between
A and B using BFS?
● Print all of those nodes that are at distance 2 from
source vertex “S”.
● How can we modify BFS algorithm to check the
bipartiteness of a graph?
● Is it possible to answer that there exists more than one
path from “S” to “T” with minimum path cost?
5
Depth-First Search

● Input: 1 2
■ G = (V, E) (No source vertex given!) 3
● Goal: 5 4
■ Explore the edges of G to “discover” every vertex in V starting at the most
current visited node
■ Search may be repeated from multiple sources

● Output:
■ 2 timestamps on each vertex:
○ d[v] = discovery time
○ f[v] = finishing time (done with examining v’s adjacency list)

■ Depth-first forest
Depth-First Search

● Search “deeper” in the graph whenever possible 1 2


● Edges are explored out of the most recently 3
discovered vertex v that still has unexplored edges 5 4

• After all edges of v have been explored, the search


“backtracks” from the parent of v
• The process continues until all vertices reachable from the
original source have been discovered
• If undiscovered vertices remain, choose one of them as a
new source and repeat the search from that vertex
• DFS creates a “depth-first forest”
DFS Additional Data Structures
● Global variable: time-stamp
■ Incremented when nodes are discovered or finished
● color[u] – similar to BFS
■ White before discovery, gray while processing and black
when finished processing
● prev[u] – predecessor of u
● d[u], f[u] – discovery and finish times
1 ≤ d[u] < f [u] ≤ 2 |V|

WHIT GRAY BLAC


0 E d[u f[u K 2
] ] V
Depth-First Search: The Code
Data: color[V], time, DFS_Visit(u)
prev[V],d[V], f[V] {
DFS(G) // where prog starts color[u] = GREY;
{ Initialize time = time+1;
for each vertex u ∈ V d[u] = time;
{ for each v ∈ Adj[u]
color[u] = WHITE; {
prev[u]=NIL; if(color[v] == WHITE){
f[u]=inf; d[u]=inf; prev[v]=u;
} DFS_Visit(v);}
time = 0; }
for each vertex u ∈ V color[u] = BLACK;
if (color[u] == WHITE) time = time+1;
DFS_Visit(u); f[u] = time;
} }
9
Depth-First Search: The Code
Data: color[V], time, DFS_Visit(u)
prev[V],d[V], f[V] {
DFS(G) // where prog starts color[u] = GREY;
{ time = time+1;
for each vertex u ∈ V d[u] = time;
{ for each v ∈ Adj[u]
color[u] = WHITE; {
prev[u]=NIL; if(color[v] == WHITE){
f[u]=inf; d[u]=inf; prev[v]=u;
} DFS_Visit(v);}
time = 0; }
for each vertex u ∈ V color[u] = BLACK;
if (color[u] == WHITE) time = time+1;
DFS_Visit(u); f[u] = time;
} }
10 What does u[d] represent?
Depth-First Search: The Code
Data: color[V], time, DFS_Visit(u)
prev[V],d[V], f[V] {
DFS(G) // where prog starts color[u] = GREY;
{ time = time+1;
for each vertex u ∈ V d[u] = time;
{ for each v ∈ Adj[u]
color[u] = WHITE; {
prev[u]=NIL; if(color[v] == WHITE){
f[u]=inf; d[u]=inf; prev[v]=u;
} DFS_Visit(v);}
time = 0; }
for each vertex u ∈ V color[u] = BLACK;
if (color[u] == WHITE) time = time+1;
DFS_Visit(u); f[u] = time;
} }
11 What does f[d] represent?
Depth-First Search: The Code
Data: color[V], time, DFS_Visit(u)
prev[V],d[V], f[V] {
DFS(G) // where prog starts color[u] = GREY;
{ time = time+1;
for each vertex u ∈ V d[u] = time;
{ for each v ∈ Adj[u]
color[u] = WHITE; {
prev[u]=NIL; if(color[v] == WHITE){
f[u]=inf; d[u]=inf; prev[v]=u;
} DFS_Visit(v);
time = 0; }}
for each vertex u ∈ V color[u] = BLACK;
if (color[u] == WHITE) time = time+1;
DFS_Visit(u); f[u] = time;
} }
Will all vertices eventually be colored black?
12
DFS Example
source
vertex
S D F

B C G

13
DFS Example
source
vertex d
S D F
f
1 | | |

A
| |
E

| | |
B C G

14
DFS Example
source
vertex d
S D F
f
1 | | |

A
2 | |
E

| | |
B C G

15
DFS Example
source
vertex d
S D F
f
1 | | |

A
2 | |
E

3 | | |
B C G

16
DFS Example
source
vertex d
S D F
f
1 | | |

A
2 | |
E
3 |
| |
4
B C G

17
DFS Example
source
vertex d
S D F
f
1 | | |

A
2 | |
E
3 |
5 | |
4
B C G

18
DFS Example
source
vertex d
S D F
f
1 | | |

A
2 | |
E
3 | 5 |
|
4 6
B C G

19
DFS Example
source
vertex d
S D F
f
1 | | |

A
2 |
|
7
E
3 | 5 |
|
4 6
B C G

20
DFS Example
source
vertex d
S D F
f
1 | 8 | |

A
2 |
|
7
E
3 | 5 |
|
4 6
B C G

21
DFS Example
source
vertex d
S D F
f
1 | 8 | |

A
2 |
9 |
7
E
3 | 5 |
|
4 6
B C G
What is the structure of the grey vertices?
What do they represent?
22
DFS Example
source
vertex d
S D F
f
1 | 8 | |

A
2 | 9
7 |10
E
3 | 5 |
|
4 6
B C G

23
DFS Example
source
vertex d
S D F
f
8
1 | |
|11
A
2 | 9
7 |10
E
3 | 5 |
|
4 6
B C G

24
DFS Example
source
vertex d
S D F
f
1 8
|
|12 |11
A
2 | 9
7 |10
E
3 | 5 |
|
4 6
B C G

25
DFS Example
source
vertex d
S D F
f
1 8
13|
|12 |11
A
2 | 9
7 |10
E
3 | 5 |
|
4 6
B C G

26
DFS Example
source
vertex d
S D F
f
1 8
13|
|12 |11
A
2 | 9
7 |10
E
3 | 5 |
14|
4 6
B C G

27
DFS Example
source
vertex d
S D F
f
1 8
13|
|12 |11
A
2 | 9
7 |10
E
3 | 5 | 14|
4 6 15
B C G

28
DFS Example
source
vertex d
S D F
f
1 8 13|
|12 |11 16
A
2 | 9
7 |10
E
3 | 5 | 14|
4 6 15
B C G

29
Depth-First Search: The Code
Data: color[V], time, DFS_Visit(u)
prev[V],d[V], f[V] {
DFS(G) // where prog starts color[u] = GREY;
{ time = time+1;
for each vertex u ∈ V d[u] = time;
{ for each v ∈ Adj[u]
color[u] = WHITE; {
prev[u]=NIL; if (color[v] == WHITE)
f[u]=inf; d[u]=inf; prev[v]=u;
} DFS_Visit(v);
time = 0; }
for each vertex u ∈ V color[u] = BLACK;
if (color[u] == WHITE) time = time+1;
DFS_Visit(u); f[u] = time;
} }
What will be the running time?
30
Depth-First Search: The Code
Data: color[V], time, DFS_Visit(u)
prev[V],d[V], f[V] {
DFS(G) // where prog starts color[u] = GREY;
{ time = time+1;
for each vertex u ∈ V d[u] = time;
{ for each v ∈ Adj[u] O(V)
color[u] = WHITE; {
prev[u]=NIL; O(V) if (color[v] == WHITE)
f[u]=inf; d[u]=inf; prev[v]=u;
} DFS_Visit(v);
time = 0; }
for each vertex u ∈ VO(V) color[u] = BLACK;
if (color[u] == WHITE) time = time+1;
DFS_Visit(u); f[u] = time;
} 2 }
Running time: O(V ) because call DFS_Visit on each vertex,
and the31loop over Adj[] can run as many as |V| times
Depth-First Search: The Code
Data: color[V], time, DFS_Visit(u)
prev[V],d[V], f[V] {
DFS(G) // where prog starts color[u] = GREY;
{ time = time+1;
for each vertex u ∈ V d[u] = time;
{ for each v ∈ Adj[u]
color[u] = WHITE; {
prev[u]=NIL; if (color[v] == WHITE)
f[u]=inf; d[u]=inf; prev[v]=u;
} DFS_Visit(v);
time = 0; }
for each vertex u ∈ V color[u] = BLACK;
if (color[u] == WHITE) time = time+1;
DFS_Visit(u); f[u] = time;
} BUT, there is actually
} a tighter bound.
How many times will DFS_Visit() actually be called?
32
Depth-First Search: The Code
Data: color[V], time, DFS_Visit(u)
prev[V],d[V], f[V] {
DFS(G) // where prog starts color[u] = GREY;
{ time = time+1;
for each vertex u ∈ V d[u] = time;
{ for each v ∈ Adj[u]
color[u] = WHITE; {
prev[u]=NIL; if (color[v] == WHITE)
f[u]=inf; d[u]=inf; prev[v]=u;
} DFS_Visit(v);
time = 0; }
for each vertex u ∈ V color[u] = BLACK;
if (color[u] == WHITE) time = time+1;
DFS_Visit(u); f[u] = time;
} }
So, running time of DFS = O(V+E)
33
Depth-First Sort Analysis

● This running time argument is an informal


example of amortized analysis
■ “Charge” the exploration of edge to the edge:
○ Each loop in DFS_Visit can be attributed to an edge in
the graph
○ Runs once per edge if directed graph, twice if undirected
○ Thus loop will run in O(E) time, algorithm O(V+E)
◆ Considered linear for graph, b/c adj list requires O(V+E) storage
■ Important to be comfortable with this kind of
reasoning and analysis

34
DFS: Kinds of edges

● DFS introduces an important distinction


among edges in the original graph:
■ Tree edge: encounter new (white) vertex
○ The tree edges form a spanning forest
○ Can tree edges form cycles? Why or why not?
◆ No

35
DFS Example
source
vertex d
f
1 8 13|
|12 |11 16

2 | 9
7 |10

3 | 5 | 14|
4 6 15

Tree edges

36
DFS: Kinds of edges

● DFS introduces an important distinction


among edges in the original graph:
■ Tree edge: encounter new (white) vertex
■ Back edge: from descendent to ancestor
○ Encounter a grey vertex (grey to grey)
○ Self loops are considered as to be back edge.

37
DFS Example
source
vertex d
f
1 8 13|
|12 |11 16

2 | 9
7 |10

3 | 5 | 14|
4 6 15

Tree edges Back edges

38
DFS: Kinds of edges

● DFS introduces an important distinction


among edges in the original graph:
■ Tree edge: encounter new (white) vertex
■ Back edge: from descendent to ancestor
■ Forward edge: from ancestor to descendent
○ Not a tree edge, though
○ From grey node to black node

39
DFS Example
source
vertex d
f
1 8 13|
|12 |11 16

2 | 9
7 |10

3 | 5 | 14|
4 6 15

Tree edges Back edges Forward edges

40
DFS: Kinds of edges

● DFS introduces an important distinction


among edges in the original graph:
■ Tree edge: encounter new (white) vertex
■ Back edge: from descendent to ancestor
■ Forward edge: from ancestor to descendent
■ Cross edge: between a tree or subtrees
○ From a grey node to a black node

41
DFS Example
source
vertex d
f
1 8 13|
|12 |11 16

2 | 9
7 |10

3 | 5 | 14|
4 6 15

Tree edges Back edges Forward edges Cross edges

42
DFS: Kinds of edges

● DFS introduces an important distinction


among edges in the original graph:
■ Tree edge: encounter new (white) vertex
■ Back edge: from descendent to ancestor
■ Forward edge: from ancestor to descendent
■ Cross edge: between a tree or subtrees
● Note: tree & back edges are important; most
algorithms don’t distinguish forward & cross

43
More about the edges

● Let (u,v) is an edge.


■ If (color[v] = WHITE) then (u,v) is a tree edge
■ If (color[v] = GRAY) then (u,v) is a back edge
■ If (color[v] = BLACK) then (u,v) is a
forward/cross edge
○ Forward Edge: d[u]<d[v]
○ Cross Edge: d[u]>d[v]

44
Depth-First Search - Timestamps

a b s c
1/1 11/
3/6 2/9
0 16
B F C
B
12/ 14/
4/5 7/8
C C 13 C 15
d e f g

45
Depth-First Search - Timestamps

s c
C B

F
b f g
C
a e C
B

C
d

46
Depth-First Search: Detect Edge
Data: color[V], time, DFS_Visit(u)
prev[V],d[V], f[V] {
DFS(G) // where prog starts color[u] = GREY;
{ time = time+1;
for each vertex u ∈ V d[u] = time;
{ for each v ∈ Adj[u]
color[u] = WHITE; {
prev[u]=NIL; detect edge type using
f[u]=inf; d[u]=inf; “color[v]”
} if(color[v] == WHITE){
time = 0; prev[v]=u;
for each vertex u ∈ V DFS_Visit(v);
if (color[u] == WHITE) }}
DFS_Visit(u); color[u] = BLACK;
} time = time+1;
f[u] = time;
47
DFS: Kinds Of Edges

● Thm 22.10: If G is undirected, a DFS produces


only tree and back edges
so
● Proof by contradiction: ur
■ Assume there’s a forward edge F? ce
○ But F? edge must actually be a
back edge (why?)

48
DFS: Kinds Of Edges

● Thm 23.9: If G is undirected, a DFS produces


only tree and back edges
so
● Proof by contradiction: ur
■ Assume there’s a cross edge ce
○ But C? edge cannot be cross:
○ must be explored from one of the
vertices it connects, becoming a tree
vertex, before other vertex is explored
○ So in fact the picture is wrong…both
lower tree edges cannot in fact be
C?
tree edges
49
DFS And Graph Cycles

● Thm: An undirected graph is acyclic iff a DFS


yields no back edges
■ If acyclic, no back edges (because a back edge
implies a cycle
■ If no back edges, acyclic
○ No back edges implies only tree edges (Why?)
○ Only tree edges implies we have a tree or a forest
○ Which by definition is acyclic

● Thus, can run DFS to find whether a graph has


a cycle
50
DFS And Cycles
How would you modify the code to detect cycles?

Data: color[V], time, DFS_Visit(u)


prev[V],d[V], f[V] {
DFS(G) // where prog starts color[u] = GREY;
{ time = time+1;
for each vertex u ∈ V d[u] = time;
{ for each v ∈ Adj[u]
color[u] = WHITE; {
prev[u]=NIL; if (color[v]==WHITE){
f[u]=inf; d[u]=inf; prev[v]=u;
} DFS_Visit(v);
time = 0; }
for each vertex u ∈ V }
if (color[u] == WHITE) color[u] = BLACK;
DFS_Visit(u); time = time+1;
} f[u] = time;
51 }
DFS And Cycles
What will be the running time?

Data: color[V], time, DFS_Visit(u)


prev[V],d[V], f[V] {
DFS(G) // where prog starts color[u] = GREY;
{ time = time+1;
for each vertex u ∈ V d[u] = time;
{ for each v ∈ Adj[u]
color[u] = WHITE; {
prev[u]=NIL; if (color[v]==WHITE){
f[u]=inf; d[u]=inf; prev[v]=u;
} DFS_Visit(v); }
time = 0; else {cycle exists;}
for each vertex u ∈ V }
if (color[u] == WHITE) color[u] = BLACK;
DFS_Visit(u); time = time+1;
} f[u] = time;
52 }
DFS And Cycles

● What will be the running time?


● A: O(V+E)
● We can actually determine if cycles exist in
O(V) time
■ How??

53
DFS And Cycles

● What will be the running time for undirected


graph to detect cycle?
● A: O(V+E)
● We can actually determine if cycles exist in
O(V) time:
■ In an undirected acyclic forest, |E| ≤ |V| - 1
■ So count the edges: if ever see |V| distinct edges,
must have seen a back edge along the way

54
DFS And Cycles

● What will be the running time for directed


graph to detect cycle?
● A: O(V+E)

55
Reference

● Cormen –
■ Chapter 22 (Elementary Graph Algorithms)
● Exercise –
■ 22.3-4 –Detect edge using d[u], d[v], f[u], f[v]
■ 22.3-11 – Connected Component
■ 22.3-12 – Singly connected

56

You might also like