Scribd
Upload
61 views44 pages

Graphs 2

The document describes depth-first search (DFS), an algorithm for exploring graphs. It explains that DFS explores "deeper" in the graph whenever possible by exploring edges out of the most recently discovered vertex that still has unexplored edges. Vertices are initially colored white, then gray when discovered, and black when finished. Pseudocode and explanations are provided for the DFS and DFS_Visit functions. Key points like running time, values represented by d and f, and amortized analysis are also discussed.

Uploaded by

vivek singh
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
61 views44 pages

Graphs 2

The document describes depth-first search (DFS), an algorithm for exploring graphs. It explains that DFS explores "deeper" in the graph whenever possible by exploring edges out of the most recently discovered vertex that still has unexplored edges. Vertices are initially colored white, then gray when discovered, and black when finished. Pseudocode and explanations are provided for the DFS and DFS_Visit functions. Key points like running time, values represented by d and f, and amortized analysis are also discussed.

Uploaded by

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

ITCS 6114

Graph Algorithms

1 12/11/2018
Depth-First Search

● Depth-first search is another strategy for


exploring a graph
■ Explore “deeper” in the graph whenever possible
■ Edges are explored out of the most recently
discovered vertex v that still has unexplored edges
■ When all of v’s edges have been explored,
backtrack to the vertex from which v was
discovered

2 12/11/2018
Depth-First Search

● Vertices initially colored white


● Then colored gray when discovered
● Then black when finished

3 12/11/2018
Depth-First Search: The Code
DFS(G) DFS_Visit(u)
{ {
for each vertex u  G->V u->color = GREY;
time = time+1;
{
u->d = time;
u->color = WHITE;
for each v  u->Adj[]
}
{
time = 0;
if (v->color == WHITE)
for each vertex u  G->V
DFS_Visit(v);
{
}
if (u->color == WHITE)
u->color = BLACK;
DFS_Visit(u);
time = time+1;
}
u->f = time;
}
}

4 12/11/2018
Depth-First Search: The Code
DFS(G) DFS_Visit(u)
{ {
for each vertex u  G->V u->color = GREY;
time = time+1;
{
u->d = time;
u->color = WHITE;
for each v  u->Adj[]
}
{
time = 0;
if (v->color == WHITE)
for each vertex u  G->V
DFS_Visit(v);
{
}
if (u->color == WHITE)
u->color = BLACK;
DFS_Visit(u);
time = time+1;
}
u->f = time;
}
}

What does u->d represent?


5 12/11/2018
Depth-First Search: The Code
DFS(G) DFS_Visit(u)
{ {
for each vertex u  G->V u->color = GREY;
time = time+1;
{
u->d = time;
u->color = WHITE;
for each v  u->Adj[]
}
{
time = 0;
if (v->color == WHITE)
for each vertex u  G->V
DFS_Visit(v);
{
}
if (u->color == WHITE)
u->color = BLACK;
DFS_Visit(u);
time = time+1;
}
u->f = time;
}
}

What does u->f represent?


6 12/11/2018
Depth-First Search: The Code
DFS(G) DFS_Visit(u)
{ {
for each vertex u  G->V u->color = GREY;
time = time+1;
{
u->d = time;
u->color = WHITE;
for each v  u->Adj[]
}
{
time = 0;
if (v->color == WHITE)
for each vertex u  G->V
DFS_Visit(v);
{
}
if (u->color == WHITE)
u->color = BLACK;
DFS_Visit(u);
time = time+1;
}
u->f = time;
}
}

Will all vertices eventually be colored black?


7 12/11/2018
Depth-First Search: The Code
DFS(G) DFS_Visit(u)
{ {
for each vertex u  G->V u->color = GREY;
time = time+1;
{
u->d = time;
u->color = WHITE;
for each v  u->Adj[]
}
{
time = 0;
if (v->color == WHITE)
for each vertex u  G->V
DFS_Visit(v);
{
}
if (u->color == WHITE)
u->color = BLACK;
DFS_Visit(u);
time = time+1;
}
u->f = time;
}
}

What will be the running time?


8 12/11/2018
Depth-First Search: The Code
DFS(G) DFS_Visit(u)
{ {
for each vertex u  G->V u->color = GREY;
time = time+1;
{
u->d = time;
u->color = WHITE;
for each v  u->Adj[]
}
{
time = 0;
if (v->color == WHITE)
for each vertex u  G->V
DFS_Visit(v);
{
}
if (u->color == WHITE)
u->color = BLACK;
DFS_Visit(u);
time = time+1;
}
u->f = time;
}
}
Running time: O(n2) because call DFS_Visit on each vertex,
and the loop over Adj[] can run as many as |V| times
9 12/11/2018
Depth-First Search: The Code
DFS(G) DFS_Visit(u)
{ {
for each vertex u  G->V u->color = GREY;
time = time+1;
{
u->d = time;
u->color = WHITE;
for each v  u->Adj[]
}
{
time = 0;
if (v->color == WHITE)
for each vertex u  G->V
DFS_Visit(v);
{
}
if (u->color == WHITE)
u->color = BLACK;
DFS_Visit(u);
time = time+1;
}
u->f = time;
}
}
BUT, there is actually a tighter bound.
How many times will DFS_Visit() actually be called?
10 12/11/2018
Depth-First Search: The Code
DFS(G) DFS_Visit(u)
{ {
for each vertex u  G->V u->color = GREY;
time = time+1;
{
u->d = time;
u->color = WHITE;
for each v  u->Adj[]
}
{
time = 0;
if (v->color == WHITE)
for each vertex u  G->V
DFS_Visit(v);
{
}
if (u->color == WHITE)
u->color = BLACK;
DFS_Visit(u);
time = time+1;
}
u->f = time;
}
}

So, running time of DFS = O(V+E)


11 12/11/2018
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/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

12 12/11/2018
DFS Example
source
vertex

13 12/11/2018
DFS Example
source
vertex
d f
1 | | |

| |

| | |

14 12/11/2018
DFS Example
source
vertex
d f
1 | | |

2 | |

| | |

15 12/11/2018
DFS Example
source
vertex
d f
1 | | |

2 | |

3 | | |

16 12/11/2018
DFS Example
source
vertex
d f
1 | | |

2 | |

3 | 4 | |

17 12/11/2018
DFS Example
source
vertex
d f
1 | | |

2 | |

3 | 4 5 | |

18 12/11/2018
DFS Example
source
vertex
d f
1 | | |

2 | |

3 | 4 5 | 6 |

19 12/11/2018
DFS Example
source
vertex
d f
1 | 8 | |

2 | 7 |

3 | 4 5 | 6 |

20 12/11/2018
DFS Example
source
vertex
d f
1 | 8 | |

2 | 7 |

3 | 4 5 | 6 |

21 12/11/2018
DFS Example
source
vertex
d f
1 | 8 | |

2 | 7 9 |

3 | 4 5 | 6 |

What is the structure of the grey vertices?


What do they represent?
22 12/11/2018
DFS Example
source
vertex
d f
1 | 8 | |

2 | 7 9 |10

3 | 4 5 | 6 |

23 12/11/2018
DFS Example
source
vertex
d f
1 | 8 |11 |

2 | 7 9 |10

3 | 4 5 | 6 |

24 12/11/2018
DFS Example
source
vertex
d f
1 |12 8 |11 |

2 | 7 9 |10

3 | 4 5 | 6 |

25 12/11/2018
DFS Example
source
vertex
d f
1 |12 8 |11 13|

2 | 7 9 |10

3 | 4 5 | 6 |

26 12/11/2018
DFS Example
source
vertex
d f
1 |12 8 |11 13|

2 | 7 9 |10

3 | 4 5 | 6 14|

27 12/11/2018
DFS Example
source
vertex
d f
1 |12 8 |11 13|

2 | 7 9 |10

3 | 4 5 | 6 14|15

28 12/11/2018
DFS Example
source
vertex
d f
1 |12 8 |11 13|16

2 | 7 9 |10

3 | 4 5 | 6 14|15

29 12/11/2018
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?

30 12/11/2018
DFS Example
source
vertex
d f
1 |12 8 |11 13|16

2 | 7 9 |10

3 | 4 5 | 6 14|15

Tree edges

31 12/11/2018
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)

32 12/11/2018
DFS Example
source
vertex
d f
1 |12 8 |11 13|16

2 | 7 9 |10

3 | 4 5 | 6 14|15

Tree edges Back edges

33 12/11/2018
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

34 12/11/2018
DFS Example
source
vertex
d f
1 |12 8 |11 13|16

2 | 7 9 |10

3 | 4 5 | 6 14|15

Tree edges Back edges Forward edges

35 12/11/2018
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

36 12/11/2018
DFS Example
source
vertex
d f
1 |12 8 |11 13|16

2 | 7 9 |10

3 | 4 5 | 6 14|15

Tree edges Back edges Forward edges Cross edges

37 12/11/2018
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

38 12/11/2018
DFS: Kinds Of Edges

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


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

39 12/11/2018
DFS: Kinds Of Edges

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


only tree and back edges
● Proof by contradiction: source
■ Assume there’s a cross edge
○ 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
40 12/11/2018
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
41 12/11/2018
DFS And Cycles
● How would you modify the code to detect cycles?
DFS(G) DFS_Visit(u)
{ {
for each vertex u  G->V u->color = GREY;
time = time+1;
{
u->d = time;
u->color = WHITE;
for each v  u->Adj[]
}
{
time = 0;
if (v->color == WHITE)
for each vertex u  G->V
DFS_Visit(v);
{
}
if (u->color == WHITE)
u->color = BLACK;
DFS_Visit(u);
time = time+1;
}
u->f = time;
}
}
42 12/11/2018
DFS And Cycles
● What will be the running time?
DFS(G) DFS_Visit(u)
{ {
for each vertex u  G->V u->color = GREY;
time = time+1;
{
u->d = time;
u->color = WHITE;
for each v  u->Adj[]
}
{
time = 0;
if (v->color == WHITE)
for each vertex u  G->V
DFS_Visit(v);
{
}
if (u->color == WHITE)
u->color = BLACK;
DFS_Visit(u);
time = time+1;
}
u->f = time;
}
}
43 12/11/2018
DFS And Cycles

● What will be the running time?


● 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

44 12/11/2018

You might also like