Depth First Search and Breadth First Search

Data Structures and Algorithms – COMS21103

Representing and Exploring Graphs

Depth First Search and Breadth First Search

Benjamin Sach

Graph notation recap

G is a Graph,

Vertex

Edge

V is the set of vertices

E is the set of edges

|V | is the number of vertices

|E| is the number of edges

This lecture focuses on exploring undirected and unweighted graphs

1

3

5

2

4

6

8

7

9

v ∈ V is a vertex

(u, v) ∈ E is an edge from u to v

though everything discussed today will work for directed, unweighted graphs too


an undirected and unweighted graph an directed and unweighted graph

a directed and weighted graphan undirected and weighted graph

374

9

374

2

83




374

9

374

2

83

Today we’refocused on

these graphs




374

9

374

2

83

Today we’refocused on

these graphs

But it all works forthese graphs too

Graph representations

7

1

3

5

2

4

6

9

0 1 1 0 0 0 0 0 0

1 0 1 1 1 0 0 0 0

1 1 0 1 1 0 0 0 0

0 1 1 0 1 1 0 0 0

0 1 1 1 0 1 0 0 0

0 0 0 1 1 0 0 0 0

0 0 0 0 0 0 0 1 1

0 0 0 0 0 0 1 0 1

0 0 0 0 0 0 1 1 0

1

2

3

4

5

6

7

8

9

1 2 3 4 5 6 7 8 9

FRO

M

TO8

V is the set of vertices|V | is the number of vertices

E is the set of edges|E| is the number of edges

Adjacency Matrix

|V |

|V |

We will in general assume that the vertices are numbered 1, 2, 3 . . . |V |


7

1

3

5

2

4

6

9

0 1 1 0 0 0 0 0 0

1 0 1 1 1 0 0 0 0

1 1 0 1 1 0 0 0 0

0 1 1 0 1 1 0 0 0

0 1 1 1 0 1 0 0 0

0 0 0 1 1 0 0 0 0

0 0 0 0 0 0 0 1 1

0 0 0 0 0 0 1 0 1

0 0 0 0 0 0 1 1 0

1

2

3

4

5

6

7

8

9

1 2 3 4 5 6 7 8 9

FRO

M

TO8



Adjacency Matrix

|V |

|V |



7

1

3

5

2

4

6

9

0 1 1 0 0 0 0 0 0

1 0 1 1 1 0 0 0 0

1 1 0 1 1 0 0 0 0

0 1 1 0 1 1 0 0 0

0 1 1 1 0 1 0 0 0

0 0 0 1 1 0 0 0 0

0 0 0 0 0 0 0 1 1

0 0 0 0 0 0 1 0 1

0 0 0 0 0 0 1 1 0

1

2

3

4

5

6

7

8

9

1 2 3 4 5 6 7 8 9

FRO

M

TO8



Adjacency Matrix

|V |

|V |



7

1

3

5

2

4

6

9

0 1 1 0 0 0 0 0 0

1 0 1 1 1 0 0 0 0

1 1 0 1 1 0 0 0 0

0 1 1 0 1 1 0 0 0

0 1 1 1 0 1 0 0 0

0 0 0 1 1 0 0 0 0

0 0 0 0 0 0 0 1 1

0 0 0 0 0 0 1 0 1

0 0 0 0 0 0 1 1 0

1

2

3

4

5

6

7

8

9

1 2 3 4 5 6 7 8 9

FRO

M

TO8



Adjacency Matrix

|V |

|V |



7

1

3

5

2

4

6

9

0 1 1 0 0 0 0 0 0

1 0 1 1 1 0 0 0 0

1 1 0 1 1 0 0 0 0

0 1 1 0 1 1 0 0 0

0 1 1 1 0 1 0 0 0

0 0 0 1 1 0 0 0 0

0 0 0 0 0 0 0 1 1

0 0 0 0 0 0 1 0 1

0 0 0 0 0 0 1 1 0

1

2

3

4

5

6

7

8

9

1 2 3 4 5 6 7 8 9

FRO

M

TO8



Adjacency Matrix

|V |

|V |



7

1

3

5

2

4

6

9

1

3

6

7

8

9

1 3 54

1

2

2 54

3 62

3 62

54

8 9

7 9

7 8

38



Adjacency List(using linked lists)


|V | 5 4

4 5

2


7

1

3

5

2

4

6

9

1

3

6

7

8

9

1 3 54

1

2

2 54

3 62

3 62

54

8 9

7 9

7 8

38





|V | 5 4

4 5

2


7

1

3

5

2

4

6

9

1

3

6

7

8

9

1 3 54

1

2

2 54

3 62

3 62

54

8 9

7 9

7 8

38





|V | 5 4

4 5

2


7

1

3

5

2

4

6

9

1

3

6

7

8

9

1 3 54

1

2

2 54

3 62

3 62

54

8 9

7 9

7 8

38





|V | 5 4

4 5

2


7

1

3

5

2

4

6

9

1

3

6

7

8

9

1 3 54

1

2

2 54

3 62

3 62

54

8 9

7 9

7 8

38





|V | 5 4

4 5

2


7

1

3

5

2

4

6

9

1

3

6

7

8

9

1 3 54

1

2

2 54

3 62

3 62

54

8 9

7 9

7 8

38




both representations are symmetric because the graphs are undirected


|V | 5 4

4 5

2

Basic operations

Adjacency Matrix

Adjacency Matrix



Is there an edge from vertex u to v?

List all the edges leaving u ∈ V

Space



0 1 1 0 0

1 0 1 1 1

1 1 0 1 1

0 1 1 0 1

0 1 1 1 0

1

2

3

4

5

1 2 3 4 5 12345

1

12

2

3

2

3

3

4

2

Basic operations

Adjacency Matrix

Adjacency Matrix





Space Θ(|V |2) Θ(|V |+ |E|)



0 1 1 0 0

1 0 1 1 1

1 1 0 1 1

0 1 1 0 1

0 1 1 1 0

1

2

3

4

5

1 2 3 4 5 12345

1

12

2

3

2

3

3

4

2

Basic operations

Adjacency Matrix

Adjacency Matrix





Space Θ(|V |2) Θ(|V |+ |E|)

O(1) time



0 1 1 0 0

1 0 1 1 1

1 1 0 1 1

0 1 1 0 1

0 1 1 1 0

1

2

3

4

5

1 2 3 4 5 12345

1

12

2

3

2

3

3

4

2

Basic operations

Adjacency Matrix

Adjacency Matrix





Space Θ(|V |2) Θ(|V |+ |E|)

O(1) time O(V ) time



0 1 1 0 0

1 0 1 1 1

1 1 0 1 1

0 1 1 0 1

0 1 1 1 0

1

2

3

4

5

1 2 3 4 5 12345

1

12

2

3

2

3

3

4

2

Basic operations

Adjacency Matrix

Adjacency Matrix





Space Θ(|V |2) Θ(|V |+ |E|)

O(1) time O(deg(u)) time



0 1 1 0 0

1 0 1 1 1

1 1 0 1 1

0 1 1 0 1

0 1 1 1 0

1

2

3

4

5

1 2 3 4 5 12345

1

12

2

3

2

3

3

4

2

Basic operations

Adjacency Matrix

Adjacency Matrix





Space Θ(|V |2) Θ(|V |+ |E|)


deg(u) (the degree of u),

is the number of edges leaving u



0 1 1 0 0

1 0 1 1 1

1 1 0 1 1

0 1 1 0 1

0 1 1 1 0

1

2

3

4

5

1 2 3 4 5 12345

1

12

2

3

2

3

3

4

2

Basic operations

Adjacency Matrix

Adjacency Matrix





Space Θ(|V |2) Θ(|V |+ |E|)






0 1 1 0 0

1 0 1 1 1

1 1 0 1 1

0 1 1 0 1

0 1 1 1 0

1

2

3

4

5

1 2 3 4 5 12345

1

12

2

3

2

3

3

4

2

some vertex u

Basic operations

Adjacency Matrix

Adjacency Matrix





Space Θ(|V |2) Θ(|V |+ |E|)






0 1 1 0 0

1 0 1 1 1

1 1 0 1 1

0 1 1 0 1

0 1 1 1 0

1

2

3

4

5

1 2 3 4 5 12345

1

12

2

3

2

3

3

4

2

some vertex u

deg(u) = 8

Basic operations

Adjacency Matrix

Adjacency Matrix





Space Θ(|V |2) Θ(|V |+ |E|)






0 1 1 0 0

1 0 1 1 1

1 1 0 1 1

0 1 1 0 1

0 1 1 1 0

1

2

3

4

5

1 2 3 4 5 12345

1

12

2

3

2

3

3

4

2

Basic operations

Adjacency Matrix

Adjacency Matrix





Space Θ(|V |2) Θ(|V |+ |E|)

O(1) time

O(V ) time

O(deg(u)) time





0 1 1 0 0

1 0 1 1 1

1 1 0 1 1

0 1 1 0 1

0 1 1 1 0

1

2

3

4

5

1 2 3 4 5 12345

1

12

2

3

2

3

3

4

2

Basic operations

Adjacency Matrix

Adjacency Matrix





Space Θ(|V |2) Θ(|V |+ |E|)

O(1) time

O(V ) time O(deg(u)) time

O(deg(u)) time





0 1 1 0 0

1 0 1 1 1

1 1 0 1 1

0 1 1 0 1

0 1 1 1 0

1

2

3

4

5

1 2 3 4 5 12345

1

12

2

3

2

3

3

4

2

Basic operations

Adjacency Matrix

Adjacency Matrix





Space

Adjacency List(using hash tables)

Θ(|V |2) Θ(|V |+ |E|)

O(1) time


O(deg(u)) time



Θ(|V |+ |E|)

O(deg(u)) time

O(1) time



0 1 1 0 0

1 0 1 1 1

1 1 0 1 1

0 1 1 0 1

0 1 1 1 0

1

2

3

4

5

1 2 3 4 5 12345

1

12

2

3

2

3

3

4

2


12345

Basic operations

all three representations work for directed and/or weighted graphs too

Adjacency Matrix

Adjacency Matrix





Space


Θ(|V |2) Θ(|V |+ |E|)

O(1) time


O(deg(u)) time



Θ(|V |+ |E|)

O(deg(u)) time

O(1) time



0 1 1 0 0

1 0 1 1 1

1 1 0 1 1

0 1 1 0 1

0 1 1 1 0

1

2

3

4

5

1 2 3 4 5

(with the same complexities)

12345

1

12

2

3

2

3

3

4

2


12345

Basic operations

all three representations work for directed and/or weighted graphs too

Adjacency Matrix

Adjacency Matrix





Space


Θ(|V |2) Θ(|V |+ |E|)

O(1) time


O(deg(u)) time



Θ(|V |+ |E|)

O(deg(u)) time

O(1) time

why don’t we always use these?



0 1 1 0 0

1 0 1 1 1

1 1 0 1 1

0 1 1 0 1

0 1 1 1 0

1

2

3

4

5

1 2 3 4 5

(with the same complexities)

12345

1

12

2

3

2

3

3

4

2


12345

Basic operations

Adjacency Matrix Adjacency List(using linked lists)



Space


Θ(|V |2) Θ(|V |+ |E|)

O(1) time


O(deg(u)) time

Θ(|V |+ |E|)

O(deg(u)) time

O(1) time




Basic operations




Space


Θ(|V |2) Θ(|V |+ |E|)

O(1) time


O(deg(u)) time

Θ(|V |+ |E|)

O(deg(u)) time

O(1) time




Basic hash tables give expected time complexities (constant time ‘on average’)

- no worst case guarantees against collisions

Basic operations




Space


Θ(|V |2) Θ(|V |+ |E|)

O(1) time


O(deg(u)) time

Θ(|V |+ |E|)

O(deg(u)) time

O(1) time






If you’re interested in hashing with provable guarantees,come to COMS31900 (Advanced Algorithms)

Basic operations




Space


Θ(|V |2) Θ(|V |+ |E|)

O(1) time


O(deg(u)) time

Θ(|V |+ |E|)

O(deg(u)) time

O(1) time






If you’re interested in hashing with provable guarantees,come to COMS31900 (Advanced Algorithms)

Fortunately, few algorithms need to ask “is there an edge?”

Normally, “tell me all the edges” is fine

Basic operations




Space


Θ(|V |2) Θ(|V |+ |E|)

O(1) time


O(deg(u)) time

Θ(|V |+ |E|)

O(deg(u)) time

O(1) time




Basic operations




Space


Θ(|V |2) Θ(|V |+ |E|)

O(1) time


O(deg(u)) time

Θ(|V |+ |E|)

O(deg(u)) time

O(1) time




For this course we’ll stick to Adjacency Matrices and Lists (using linked lists)(for today just Adjacency Lists)

Basic operations




Space


Θ(|V |2) Θ(|V |+ |E|)

O(1) time


O(deg(u)) time

Θ(|V |+ |E|)

O(deg(u)) time

O(1) time





One practical reason to stick to standard representations is that

you may not have control over how your graph is stored.

Basic operations




Space


Θ(|V |2) Θ(|V |+ |E|)

O(1) time


O(deg(u)) time

Θ(|V |+ |E|)

O(deg(u)) time

O(1) time







it may not even be stored as a graph...

Basic operations




Space


Θ(|V |2) Θ(|V |+ |E|)

O(1) time


O(deg(u)) time

Θ(|V |+ |E|)

O(deg(u)) time

O(1) time







it may not even be stored as a graph...

Fortunately in many cases, you can pretend your graph is stored as one of the above.

Intersection Graphs

Intersection Graphs

the intersections of these circles

correspond to the graph below

Intersection Graphs

each circle is a vertex the intersections of these circles


Intersection Graphs



Intersection Graphs

each intersection

is an edge



Intersection Graphs

each intersection

is an edge



Intersection Graphs

each intersection

is an edge

we can pretend we have

an Adjacency Matrix

without building one

even if we only store the circles,



Other intersection graphs. . .

(these are 1D intervals on a line spread out for visual clarity)

both of these ‘collections’ also

correspond to the example graph


= an edge

= a vertex





= an edge

= a vertex

there is an edge if two intervals intersect

each interval is a vertex





= an edge

= a vertex

there is an edge if two intervals intersect

each interval is a vertex



an Adjacency Matrix


Again,



Configuration Graphs

This is the configuration graph for the

(4 disk) towers of Hanoi

a node is a state that the

game can be in

there is an edge if you can get from

one state to another in a single move





game can be in







game can be in







game can be in







game can be in







game can be in







game can be in







game can be in







game can be in







game can be in



storing this uses much less space than

storing this this graph





game can be in



storing this uses much less space than

storing this this graph


an Adjacency List


Exploring a graph

you are here

BAG

Exploring a graph

you are here

BAG Goal: visit every vertex in a

connected graph efficiently

Exploring a graph

you are here



The bag (secretly a data structure)

We can put a vertex in the bag

We can take a vertex from the bag

We don’t care how it works (for now)

(the bag doesn’t forget or change things)

but we don’t know which one we’ll get

Exploring a graph



We going to use an adjacency list so the

graph is really stored like this:

The bag (secretly a data structure)

We can put a vertex in the bag

We can take a vertex from the bag

We don’t care how it works (for now)

(the bag doesn’t forget or change things)

but we don’t know which one we’ll get

Exploring a graph

you are here



Exploring a graph

vertex s

BAG

put s into the bag

while the bag is not empty

take u from the bag

if u unmarked

mark u

for every edge (u, v)

put v into the bag

TRAVERSE(s)

Goal: visit every vertex in a


Exploring a graph

vertex s

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Exploring a graph

vertex s

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Exploring a graph

vertex s

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



back in!

in twice!

Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



already marked

(do nothing)

Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Some time later. . .

Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Some time later. . . ?

Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)



Some time later. . . ?

Questions:

1. Does TRAVERSE always stop?

2. Does it always visit every vertex?

3. How fast is it? (in the worst case)

Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

Questions:




Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)


Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)


Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

back in!

in twice!


Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

back in!

in twice!


We may put a vertex in the bag many times but each edge is only

processed twice (once in each direction)

Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

back in!

in twice!




never seen

again!

Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

back in!

in twice!




never seen

again!

Important later: number of ‘puts’ 6 2|E|

Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

back in!

in twice!




never seen

again!


TRAVERSE(s)

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

back in!

in twice!




never seen

again!


Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

back in!

in twice!

1. Does TRAVERSE always stop? Yes



never seen

again!


Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

Questions:



Yes


Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)


Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)


When a vertex on this path is marked, the next vertex is put in the bag

Eventually, that vertex is removed from the bag and is marked.

Consider any path from s to some v:

Proof (by induction)

(unless it was already marked)

Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v


there could be a ‘shortcut’


Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v




Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v




Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v




Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v




Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v




Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v



Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v


Yes


Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v


Yes

The correctness doesn’t depend

on how the bag works!


Exploring a graph

BAG

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)





s

v


Yes

The correctness doesn’t depend

on how the bag works!

(but this doesn’t tell you anything about

which order vertices are marked in)


Exploring a graph

Questions:



Yes

Yes3. How fast is it? (in the worst case)

Exploring a graph

Questions:



Yes


Assumption

(we’ll come back to this)

bag operations

take O(1) time

Exploring a graph

Questions:



Yes


Assumption


bag operations

take O(1) time



Exploring a graph

Questions:



Yes


Assumption


put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

bag operations

take O(1) time



Exploring a graph

Questions:



Yes


Time complexity:

Assumption


put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

bag operations

take O(1) time



Exploring a graph

Questions:



Yes


Time complexity:

Assumption


O(1) time every time we take from the bag

put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

bag operations

take O(1) time



Exploring a graph

Questions:



Yes


Time complexity:

Assumption


(store an array where mark[u] = 1 iff u is marked)


put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

bag operations

take O(1) time



Exploring a graph

Questions:



Yes


Time complexity:

Assumption




put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

bag operations

take O(1) time

O(1) time every time we put into the bag



Exploring a graph

Questions:



Yes


Time complexity:

Assumption




put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

bag operations

take O(1) time


What is the total number of bag operations?



Exploring a graph

Questions:



Yes


Time complexity:

Assumption




put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

bag operations

take O(1) time



we do at most 2|E| put operations



Exploring a graph

Questions:



Yes


Time complexity:

Assumption




put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

bag operations

take O(1) time




so we do at most 2|E| take operations



Exploring a graph

Questions:



Yes


Time complexity:

Assumption




put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

bag operations

take O(1) time





The overall time complexity is O(|E|)



Exploring a graph

Questions:



Yes


Time complexity:

Assumption




put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

bag operations

take O(1) time





The overall time complexity is O(|E|)

O(|E|)



Exploring a graph

Questions:



Yes


Assumption


put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

bag operations

take O(1) time

O(|E|)



Exploring a graph

Questions:



Yes


Assumption


put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

bag operations

take O(1) time

O(|E|)

What if we had used an

adjacency matrix?

0 1 1 0 0

1 0 1 1 1

1 1 0 1 1

0 1 1 0 1

0 1 1 1 0

1

2

3

4

5

1 2 3 4 5



Exploring a graph

Questions:



Yes


Assumption


put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

bag operations

take O(1) time

O(|E|)


adjacency matrix?

finding all edges leaving u would have taken O(|V |) time

0 1 1 0 0

1 0 1 1 1

1 1 0 1 1

0 1 1 0 1

0 1 1 1 0

1

2

3

4

5

1 2 3 4 5



Exploring a graph

Questions:



Yes


Assumption


put s into the bag


take u from the bag

if u unmarked

mark u


put v into the bag

TRAVERSE(s)

bag operations

take O(1) time

O(|E|)


adjacency matrix?

finding all edges leaving u would have taken O(|V |) time

0 1 1 0 0

1 0 1 1 1

1 1 0 1 1

0 1 1 0 1

0 1 1 1 0

1

2

3

4

5

1 2 3 4 5

overall, the time complexity would have been O(|V |2) instead of O(|E|).



How should we implement the bag?

BAG

Queue Stack

Operations take O(1) time

Depth First SearchBreadth First Search

but in different orders with different types of bag

TRAVERSE visits every vertex in a connected graph in O(|E|) time

with a Queue the algorithm is called with a Stack the algorithm is called

Applications Applications

Shortest paths in unweighted graphs

Max-Flow

Testing whether a graph is bipartite

Finding (strongly) connected components

Topicologically sorting a Directed Acyclic Graph

Testing for planarity

How should we implement the bag?

BAG

Queue Stack

Operations take O(1) time

Depth First SearchBreadth First Search

but in different orders with different types of bag





Max-Flow





(and it works for directed graphs too)


s

Goal: find the distance from the

source s to every other vertex


s



distance = 1


s



distance = 3


s



distance = 6


s




s



Breadth-First Search (BFS)

is TRAVERSE using a queue as the bag

TRAVERSE(s) - with a queue

put s into the queue

while the queue is not empty

take u from the queue

if u unmarked

mark u


put v into the queue


s





Lemma In BFS, the vertices

are marked in distance order (smallest first)





if u unmarked

mark u




s











if u unmarked

mark u




s











if u unmarked

mark u




s











if u unmarked

mark u




s











if u unmarked

mark u




s











if u unmarked

mark u




s











if u unmarked

mark u




s











if u unmarked

mark u




s











if u unmarked

mark u




s







these are all in front of these

in the queue





if u unmarked

mark u




s







these are all in front of these

in the queue





if u unmarked

mark u




s











if u unmarked

mark u




s











if u unmarked

mark u




s











if u unmarked

mark u




s











if u unmarked

mark u




s











if u unmarked

mark u




s











if u unmarked

mark u




s











if u unmarked

mark u




s











if u unmarked

mark u




s







This is why it’s called

Breadth-First Search





if u unmarked

mark u




s









Lemma In BFS, the vertices are marked in

distance order (smallest first)

Proof by induction (on the distance from s)





if u unmarked

mark u




s









Base Case: BFS marks all vertices at distance 0 from s

before marking any vertex at distance > 0 .








if u unmarked

mark u




s


















if u unmarked

mark u




s











Inductive Hypothesis: Assume that BFS marks all vertices at distance (i− 1)

before marking any vertex at distance > (i− 1).








if u unmarked

mark u




s













When BFS marks a vertex at distance (i− 1),it puts all its neighbours in the queue.








if u unmarked

mark u




s













When BFS marks a vertex at distance (i− 1),it puts all its neighbours in the queue.




v is u’s neighbour iff

(u, v) ∈ E





if u unmarked

mark u




s













When BFS marks a vertex at distance (i− 1),

Immediately after marking all vertices at distance (i− 1):

it puts all its neighbours in the queue.





(u, v) ∈ E





if u unmarked

mark u




s
















every vertex at distance i is in the queue.

no vertex at distance > i has been put in the queue.





(u, v) ∈ E





if u unmarked

mark u




s


















because we haven’t marked any of its neighbours




(they are all at distance > (i− 1))


(u, v) ∈ E





if u unmarked

mark u




s


















because we haven’t marked any of its neighbours

Therefore, all vertices at distance i will be marked before any vertex at distance > i




(they are all at distance > (i− 1))


(u, v) ∈ E





if u unmarked

mark u




s











if u unmarked

mark u




s







we can use this to find the shortest path

from s to every other vertex in O(|V |+ |E|) time

With a little bit of book-keeping,





if u unmarked

mark u




s







This also works for directed, unweighted graphs








if u unmarked

mark u




s







This also works for directed, unweighted graphs




It does not work for weighted graphs





if u unmarked

mark u



Shortest Paths using BFS

for all v, set dist(v) =∞ (NEW!)

set dist(s) = 0 (NEW!)




if u unmarked

mark u



if dist(v) =∞ (NEW!)

dist(v) = dist(u) + 1 (NEW!)

BFS(s)

dist(v) gives the distance

between s and v

We’ve added four (NEW!) lines to TRAVERSE

to track the distances from s







if u unmarked

mark u





BFS(s)


between s and v


to track the distances from s How does this affect the time complexity?







if u unmarked

mark u





BFS(s)


between s and v

Time complexity:









if u unmarked

mark u





BFS(s)


between s and v

Time complexity:



O(|V |) time to initialise an array dist







if u unmarked

mark u





BFS(s)


between s and v

Time complexity:




O(1) time to set the distance to s







if u unmarked

mark u





BFS(s)


between s and v

Time complexity:





O(1) time whenever we put into the queue

(so this doesn’t change the complexity)







if u unmarked

mark u





BFS(s)


between s and v

Time complexity:





O(1) time whenever we put into the queue

(so this doesn’t change the complexity)

so the overall complexity is O(|V |+ |E|)







if u unmarked

mark u





BFS(s)


between s and v









if u unmarked

mark u





BFS(s)


between s and v



Why does this work?







if u unmarked

mark u





BFS(s)


between s and v



Why does this work?









if u unmarked

mark u





BFS(s)


between s and v



Why does this work?

Correctness sketch: (using the Lemma)









if u unmarked

mark u





BFS(s)


between s and v



Why does this work?


For each v, dist(v) is set when it is first ‘discovered’

and inserted into the queue. (and it never changes)









if u unmarked

mark u





BFS(s)


between s and v



Why does this work?




Let u be the vertex which first ‘discovered’ v









if u unmarked

mark u





BFS(s)


between s and v



Why does this work?







BFS sets dist(v) = dist(u) + 1







if u unmarked

mark u





BFS(s)


between s and v



Why does this work?







Assume for a contradiction that there is a path

from s to v with length < dist(u) + 1








if u unmarked

mark u





BFS(s)


between s and v



Why does this work?










length < dist(u) + 1

sv







if u unmarked

mark u





BFS(s)


between s and v



Why does this work?







Let x be the previous vertex on this path





sv







if u unmarked

mark u





BFS(s)


between s and v



Why does this work?












sv

x







if u unmarked

mark u





BFS(s)


between s and v



Why does this work?











length < dist(u) length = 1

sv

x







if u unmarked

mark u





BFS(s)


between s and v



Why does this work?












sv

x







if u unmarked

mark u





BFS(s)


between s and v



Why does this work?










x has distance < dist(u) so was marked before u

(by the Lemma) and ‘discovered’ v first



sv

x







if u unmarked

mark u





BFS(s)


between s and v



Why does this work?










x has distance < dist(u) so was marked before u

(by the Lemma) and ‘discovered’ v first

Contradiction!



sv

x

Conclusion

Depth First Search (DFS)Breadth First Search (BFS)

- the traversal order depends on the type of bag





Max-Flow





(with an O(1) time bag)

take O(|V |+ |E|) time using BFS

Question

What does TRAVERSE do on an

unconnected graph?(works for directed graphs too)

(and it works for directed graphs too)



Education

Depth First Search and Breadth First Search