Download Exploring Graphs: BFS, DFS, and Shortest Paths and more Study notes Computer Science in PDF only on Docsity!

CS 362, Lecture 19

Jared Saia

University of New Mexico

Today’s Outline

•

BFS and DFS Wrapup

•

Shortest Paths

Generic Traverse

Traverse(s){

while (the bag is not empty){put (nil,s) in bag;

if (v is unmarked)take some edge (p,v) from the bag

for each edge (v,w) incident to v{parent(v) = p;mark v;

put (v,w) into the bag;

}

}

}

}

DFS and BFS

•

If we implement the “bag” by using a stack, we have

Depth

First Search

•

If we implement the “bag” by using a queue, we have

Breadth

First Search

Analysis

•

we implement the bag)for the “for” loop is only a constant per edge (no matter howNote that if we use adjacency lists for the graph, the overhead

•

operation on the bag takes constant timeIf we implement the bag using either stacks or queues, each

•

Hence the overall runtime is

O

(

|

V

|

+

|

E

|) =

O

(

|

E

|

)

DFS vs BFS

•

trees are short and fatNote that DFS trees tend to be long and skinny while BFS

•

In addition, the BFS tree contains

shortest paths

from the

start vertex

s

to every other vertex in its connected compo-

of edges in the path)nent. (here we define the length of a path to be the number

Final Note

•

Now assume the edges are weighted

•

If we implement the “bag” using a

priority queue

,

always

have a version of Prim’s algorithmextracting the minimum weight edge from the bag, then we

•

Each extraction from the “bag” now takes

O

(

|

E

|

) time so

the total running time is

O

(

|

V

|

+

|

E

|

(^) log

|

E

|

)

Example

a

b

e^ d

f

c

a

b

e d

f

c

of one component of the example graph, with start vertex A depth-first spanning tree and a breadth-first spanning tree

a .

Searching Disconnected Graphs

the connected component of the start vertex If the graph is disconnected, then Traverse only visits nodes in

s .

If we want to

visit

all

vertices,

we

can

use

the

following

“wrapper”

around

TraverseAll(){Traverse

for all vertices v{

if (v is unmarked){

Traverse(v);

}

}

}

DFS and BFS

•

and directed graphsNote that we can do DFS and BFS equally well on undirected

•

If the graph is undirected, there are two types of edges in

G

:

not in this treeedges that are in the DFS or BFS tree and edges that are

•

If the graph is directed, there are several types of edges

DFS in Directed Graphs

•

Tree edges

are edges that are in the tree itself

•

Back edges

are those edges (

u, v

) connecting a vertex

u

to

an ancestor

v

in the DFS tree

•

Forward edges

are nontree edges (

u, v

) that connect a vertex

u

to a descendant in a DFS tree

•

Cross edges

are all other edges.

They go between two ver-

tices where neither vertex is a descendant of the other

Acyclic graphs

•

Useful Fact:

A directed graph

G

is acyclic if and only if a

DFS of

G

yeilds no back edges

•

Challenge: Try to prove this fact.

Take Away

•

BFS and DFS are two useful algorithms for exploring graphs

•

algorithm.Each of these algorithms is an instantiation of the Traverse

BFS uses a queue to hold the edges and DFS

uses a stack

•

the nodes which are reachable from the start nodeEach of these algorithms constructs a spanning tree of all

s

Shortest Paths Problem

•

Another

interesting

problem

for

graphs

is

that

of

finding

shortest paths

•

Assume we are given a weighted

directed

graph

G

= (

V, E

)

with two special vertices, a source

s

and a target

t

•

We want to find the shortest directed path from

s

to

t

•

In other words, we want to find the path

p

starting at

s

and

ending at

t

minimizing the function

w

( p ) =

e ∑ ∈ p w

( e )

Example

•

querque,NM to Seattle,WAImagine we want to find the fastest way to drive from Albu-

•

roads, weights are driving times,We might use a graph whose vertices are cities, edges are

s

is Albuquerque and

t

is

Seattle

•

road might be different in different directions (e.g.The graph is directed since driving times along the same

because

of construction, speed traps, etc)

SSSP

•

the following more generalEvery algorithm known for solving this problem actually solves

single source shortest paths

or

SSSP problem:

•

Find the shortest path from the source vertex

s

to

every

other vertex in the graph

•

This problem is usually solved by finding a

shortest path tree

rooted at

s

that contains all the desired shortest paths

Shortest Path Tree

•

then they form a treeIt’s not hard to see that if the shortest paths are unique,

•

shortest paths are themselves shortest pathsTo prove this, we need only observe that the sub-paths of

•

paths is a treecan always choose just one of them, so that the union of theIf there are multiple shotest paths to the same vertex, we

•

If there are shortest paths to two vertices

u

and

v

which

of the paths so that the two paths diverge once only.diverge, then meet, then diverge again, we can modify one

Example

s

v u

a

b

c

d

x

y

If

s → a → b → c → d → v

and

s → a → x → y → d → u

are both

shortest paths,

then

s

→

a

→

b (^) →

c →

d

→

u

is also a shortest path.

MST vs SPT

•

can be differentNote that the minimum spanning tree and shortest path tree

•

multiple shortest path trees (one for every source vertex)For one thing there may be only one MST but there can be

Example

8

5

10

2

3

18

16

12

14

30

4

26

8

5

10

2

3

18

16

12

14

30

4

26

A minimum spanning tree (left) and a shortest path tree rooted at the

topmost vertex (right).

Negative Weights

•

We’ll actually allow negative weights on edges

•

no shortest pathThe presence of a negative cycle might mean that there is

•

A shortest path from

s

to

t

exists if and only if there is

at

least one

path from

s

to

t

but no path from

s

to

t

that

touches a negative cycle

•

In the following example, there is no shortest path from

s

to

t

s

t

5

(^2)

−

(^4)

1

3

SSSP Algorithms

•

graphs.We’ll now go over some algorithms for SSSP on directed

•

modificationThese algorithms will work for undirected graphs with slight

•

and forth across the same undirected negative-weight edgeIn particular, we must specifically prohibit alternating back

•

cial cases of a single generic algorithmLike for graph traversal, all the SSSP algorithms will be spe-

SSSP Algorithms

Each vertex

v

in the graph will store two values which describe

a

tentative

shortest path from

s

to

v

•

dist

(

v ) is the length of the tentative shortest path between

s

and

v

•

pred

(

v ) is the predecessor of

v

in this tentative shortest path

•

The

predecessor

pointers

automatically

define

a

tentative

shortest path tree

Defns

Initially we set:

dist

(

s ) = 0,

pred

(

s ) =

N U LL

•

For every vertex

v

6

s ,

dist

(

v ) =

∞

and

pred

(

v ) =

N U LL

Relaxation

•

We call an edge (

u, v

)

tense

if

dist

(

u ) +

(^) w

( u, v

)

< dist

(

v )

•

If (

u, v

) is tense, then the tentative shortest path from

s

to

v

is incorrect since the path

s

to

u

and then (

u, v

) is shorter

•

graph andOur generic algorithm repeatedly finds a tense edge in the

relaxes

it

•

have our desired shortest path treeIf there are no tense edges, our algorithm is finished and we

Relax

Relax(u,v){

pred(v) = u;dist(v) = dist(u) + w(u,v);

}

Correctness

•

from three simple claimsThe correctness of the relaxation algorithm follows directly

•

we make choices about which edges to relaxThe run time of the algorithm will depend on the way that

Claim 1

•

If

dist

(

v )

6

∞

, then

dist

(

v ) is the total weight of the prede-

cessor chain ending at

v :

s

→ · · · →

pred

(

pred

(

v ))

→

pred

(

v )

→

(^) v.

•

in the path fromThis is easy to prove by induction on the number of edges

s

to

v

. (left as an exercise)

Claim 2

•

If the algorithm halts, then

dist

(

v )

≤

w

( s

;

v ) for

any

path

s

;

v .

•

in the pathThis is easy to prove by induction on the number of edges

s

;

(^) v

. (which you will do in the hw)

Claim 3

•

reachable fromThe algorithm halts if and only if there is no negative cycle

s .

•

cyclecycle, then after the first edge in the cycle is relaxed, theThe ‘only if’ direction is easy—if there is a reachable negative

always

has at least one tense edge.

•

step reduces either the number of vertices withThe ‘if’ direction follows from the fact that every relaxation

dist

(

v ) =

∞

by some positive amount. by 1 or reduces the sum of the finite shortest path lengths

Generic SSSP

•

or what order to relax them inWe haven’t yet said how to detect which edges can be relaxed

•

tionsThe following Generic SSSP algorithm answers these ques-

•

the source vertexWe will maintain a “bag” of vertices initially containing just

s

•

Whenever we take a vertex

u

out of the bag, we scan all of

its outgoing edges, looking for something to relax

•

Whenever we successfully relax an edge (

u, v

), we put

v

in

the bag

InitSSSP

InitSSSP(s){

for all vertices v != s{pred(s) = NULL;dist(s) = 0;

pred(v) = NULL;dist(v) = infinity;

}

}

GenericSSSP

GenericSSSP(s){

while the bag is not empty{put s in the bag;InitSSSP(s);

for all edges (u,v){take u from the bag;

if (u,v) is tense{

put v in the bag;Relax(u,v);

}

}

}

}

Generic SSSP

•

for the bag gives us different algorithmsJust as with graph traversal, using different data structures

•

Some obvious choices are: a stack, a queue and a heap

•

Unfortunately if we use a stack, we need to perform Θ(

|E

| )

student)relaxation steps in the worst case (an exercise for the diligent

•

The other possibilities are more efficient

Diskstra’s Algorithm

•

v If we implement the bag as a heap, where the key of a vertex

is

dist

(

v ), we obtain Dijkstra’s algorithm

•

negative-weight edgesDijkstra’s algorithm does particularly well if the graph has no

•

thatIn this case, it’s not hard to show (by induction, of course)

the

vertices

are

scanned

in

increasing

order

of

their

shortest-path distance from

s

•

that each edge is relaxed at most onceIt follows that each vertex is scanned at most once, and thus

Dijktra’s Algorithm

•

tance fromSince the key of each vertex in the heap is its tentative dis-

s , the algorithm performs a DecreaseKey opera-

tion every time an edge is relaxed

•

Thus the algorithm performs at most

|

E

|

DecreaseKey’s

•

Similarly, there are at most

|

V

|

Insert and ExtractMin oper-

ations

•

running time of Dijkstra’s algorithm isThus if we store the vertices in a Fibonacci heap, the total

O

(

|

E

|

+

|

V

|

(^) log

|

V

|

)

Negative Edges

•

This analysis assumes that no edge has negative weight

•

tialweight edges but the worst-case run time could be exponen-The algorithm given here is still correct if there are negative

•

graphs with negative edges (which they make clear)The algorithm in our text book gives incorrect results for

Example

1

(^3)

2

(^0)

5

10

12

8

4

(^6)

(^37)

s

∞ ∞

∞

∞

4

3

1

(^3)

2

(^0)

5

10

12

8

4

(^6)

(^37)

s 0

∞ ∞

∞

∞ ∞

∞

1

(^3)

2

(^0)

5

10

12

8

4

(^6)

(^37)

s

∞ ∞

4 ∞

3 12

1

(^3)

2

(^0)

5

10

12

8

4

(^6)

(^37)

s

∞

4 ∞

3 9

4

1

(^3)

2

(^0)

5

10

12

8

4

(^6)

(^37)

s 4

3 9

4

7

14

(^0)

0

(^0)

0

At each phase, the shaded vertices are in the heap, and the bold vertex has Four phases of Dijkstra’s algorithm run on a graph with no negative edges.

just been scanned.

The bold edges describe the evolving shortest path tree.