Data Structures & Algorithms Shortest Paths Richard Newman based on book by R. Sedgewick and slides by S. Sahni

Data Structures & Algorithms

Shortest Paths

Richard Newmanbased on book by R. Sedgewick

and slides by S. Sahni

Minimum Cost Path

• Weighted, digraph G, or network• Directed simple path p from s to t• Cost(p) = sum of edge weights on p• Minimum cost path p from s to t in G

such that no other path p' from s to t in G has cost(p') < cost(p)

Minimum Cost Path

s = 1, t = 10What is minimum cost path?

23

8101

45

911

67

48

6

6

7

5

24

4 53

8

2

A Spanning Tree

path cost = 28Is there a cheaper path?

23

8101

45

911

67

48

6

6

7

5

24

4 53

8

2

A Spanning Tree


23

8101

45

911

67

48

6

6

7

5

24

4 53

8

2

A Spanning Tree


23

8101

45

911

67

48

6

6

7

5

24

4 53

8

2

Shortest Path Problems• No negative weight edges allowed!• s-t shortest path

– Single source, destination– Fastest route to Epcot

• Single Source Shortest Path– Best routes from A to anywhere

• All Pairs Shortest Paths– Routing tables in network nodes

Shortest Path Algorithms

• Dijkstra's Algorithm• Floyd's Algorithm• Bellman-Ford Algorithm



Dijkstra's Algorithm• Very similar to Prim's algorithm• Differences are that

– Paths form a rooted tree (whereas MST is not rooted)

– Graph is directed (not undirected)• Grow known shortest paths from

source one edge at a time• Priority of edge is different

Dijkstra's Algorithm• Set Known nodes K = {s}• Set dist(s) = 0, dist(u) = ∞ for all

other nodes u in G• Set pred(s) = s, pred(u) = NULL for

all other nodes u in G• Set Seen nodes S = {neighbors of s}• Set pred(u) = s for all nodes in S

Dijkstra's AlgorithmWhile |K| < V

Find nearest node v in SAdd v to KFor each edge (v,w) in E

If dist(v) + cost(v,w) < dist(w)Add w to SPred(w) = vdist(w) = dist(v) + cost(v,w)

Dijkstra's Algorithm

s = 1Grow SPT by adding node nearest to s

48

6

6

7

5

24

4 53

8

2

67

2

4 5

3

1 8

9

10

11

7

5

6

5

5

67

2

4 5

3

1 8

9

10

11

0

2

42

4

6

5

3

7

12

11

14

9

13

7

9

17

21

228

11

10

19

Update bestdistances

Dijkstra's Algorithm Correct

• Builds shortest path tree (SPT)• Always adds nearest seen node v• Path takes into account all nodes in K• No other node x not in K can be

closer than v• Hence no path through x could be

shorter than the path we have to v

Dijkstra's Algorithm Complexity

• Initialization – O(V)• Select next node – O(V) linear list• Update dist, pred – O(E) total• Selection done V-1 times• Total time – O(V2 + E) = O(V2)• Using linear list for S

Dijkstra's Algorithm Complexity

• MinHeap – O((V+E) lg V)• V removals, E changes to S• What if G is dense – E is O(V2)?

• Worse!! • Fibonacci Heap – O(V lg V + E)

• Even better!


• Solves single source shortest path• Builds SPT

• For s-t shortest path, • Just stop when t is added to K

• Also works for sink-trees (take edges in reverse direction)


• Does NOT work with negative edge weights! (Violates assumption needed by greedy method)

• Can be used to solve all pairs shortest path• Build SPT from each node

• Complexity of SSSP times V




• Floyd's Algorithm• Single source shortest paths• Works like Warshall’s algorithm for

reachability• Except takes path costs into

account

Floyd’s Algorithm

• Recall Warshall's AlgorithmFor each intermediate node i

For each source sFor each destination t

s reaches t if s already reaches t or if s reaches i and i reaches t

Floyd’s Algorithm

• Now just track distancesFor each intermediate node i

For each source sFor each destination t

cost(s,t) = lesser ofcost(s,t) and cost(s,i) + cost(i,t)

Floyd’s Algorithm

• Complexity of Floyd’s algorithm:• O(V3)• Dynamic Programming and• Relaxation

• Build estimates• Improve estimates (node relax)• Converge

Floyd's Algorithm

Consider paths through nodes numbered <1, <2, <3, etc.

410 1

4

5

3 2

19

32 51

21

3632

50

3645

290 1 2 3 4 5

0 0 41 29

1 0 51 32

2 0 50

3 45 0 36

4 32 36 0

5 29 21 0

Floyd's Algorithm

Paths through nodes numbered <13-0-1 better, 3-0-5 worse

410 1

4

5

3 2

19

32 51

21

3632

50

3645

290 1 2 3 4 5

0 0 41 29

1 0 51 32

2 0 50

3 45 86 0 36

4 32 36 0

5 29 21 0

Floyd's Algorithm

Paths through nodes numbered <229+32 = 61 > 21

410 1

4

5

3 2

29

32 51

21

3632

50

3645

290 1 2 3 4 5

0 0 41 92 73 29

1 0 51 32

2 0 50

3 45 86 137 0 118 36

4 32 36 0

5 29 80 21 0

Floyd's Algorithm

Paths through nodes numbered <3

410 1

4

5

3 2

29

32 51

21

3632

50

3645

290 1 2 3 4 5

0 0 41 92 142 73 29

1 0 51 101 32

2 0 50

3 45 86 137 0 118 36

4 32 36 0

5 29 80 130 21 0

Floyd's Algorithm


410 1

4

5

3 2

29

32 51

21

3632

50

3645

290 1 2 3 4 5

0 0 41 92 142 73 29

1 146 0 51 101 32 137

2 95 136 0 50 168 86

3 45 86 137 0 118 36

4 81 122 32 36 0 72

5 175 29 80 130 21 0

Floyd's Algorithm


410 1

4

5

3 2

29

32 51

21

3632

50

3645

290 1 2 3 4 5

0 0 41 92 109 73 29

1 113 0 51 68 32 106

2 95 136 0 50 168 88

3 45 86 137 0 118 36

4 81 122 32 36 0 72

5 102 29 53 57 21 0

Floyd's Algorithm


410 1

4

5

3 2

29

32 51

21

3632

50

3645

290 1 2 3 4 5

0 0 41 82 86 50 29

1 113 0 51 68 32 106

2 95 117 0 50 109 88

3 45 65 89 0 57 36

4 81 101 32 36 0 72

5 102 29 53 57 21 0

Floyd’s Algorithm

• Update successor node when updating minimum cost path

• Method of choice for APSP for dense graphs

• Works even with negative weights• But not with negative cycles!

• (can detect at least one)




• Bellman-Ford Algorithm• SSSP• Compute best cost path by edge

relaxation – checking all edges• Essentially considers paths of

increasing potential length

Bellman-Ford Algorithm

Initialize: dist[t] = {0 if t==s, else infinity}pred[v] = NULL for all v

For (i = 1 to V-1)For each edge e=(u,v) in E

If (dist[u] + cost[e] < dist[v])dist[v] = dist[u] + cost[e]pred[v] = u


Consider paths of length <2, <3, etc.Adjacency matrix is paths of length <2

410 1

4

5

3 2

19

32 51

21

3632

50

3645

290 1 2 3 4 5

0 0 41 29

1 0 51 32

2 0 50

3 45 0 36

4 32 36 0

5 29 21 0


Edge (0,1)

410 1

4

5

3 2

19

32 51

21

3632

50

3645

29 0 1 2 3 4 5

0 0 41 29

1 0 51 32

2 0 50

3 45 86 0 36

4 32 36 0

5 29 21 0

Enter here

Leave here


Edge (0,5) doesn’t helpEdge (1,2)

410 1

4

5

3 2

19

32 51

21

3632

50

3645

29 0 1 2 3 4 5

0 0 41 92 29

1 0 51 32

2 0 50

3 45 86 137 0 36

4 32 36 0

5 29 80 21 0


Edge (2,3)

410 1

4

5

3 2

19

32 51

21

3632

50

3645

29 0 1 2 3 4 5

0 0 41 92 142 29

1 0 51 101 32

2 0 50

3 45 86 137 0 36

4 32 36 0

5 29 80 130 21 0


Edge (3,0)

410 1

4

5

3 2

19

32 51

21

3632

50

3645

29 0 1 2 3 4 5

0 0 41 92 142 29

1 146 0 51 101 32

2 95 0 50

3 45 86 137 0 36

4 81 32 36 0

5 175 29 80 130 21 0


Edge (3,5)

410 1

4

5

3 2

19

32 51

21

3632

50

3645

29 0 1 2 3 4 5

0 0 41 92 142 29

1 146 0 51 101 32 137

2 95 0 50 86

3 45 86 137 0 36

4 81 32 36 0 72

5 175 29 80 130 21 0


Edge (4,2)

410 1

4

5

3 2

19

32 51

21

3632

50

3645

29 0 1 2 3 4 5

0 0 41 92 142 29

1 146 0 64 101 32 137

2 95 0 50 86

3 45 86 137 0 36

4 81 32 36 0 72

5 175 29 53 130 21 0


Edge (4,3)

410 1

4

5

3 2

19

32 51

21

3632

50

3645

29 0 1 2 3 4 5

0 0 41 92 128 29

1 146 0 64 68 32 137

2 95 0 50 86

3 45 86 137 0 36

4 81 32 36 0 72

5 175 29 53 57 21 0


Edge (5,1)

410 1

4

5

3 2

19

32 51

21

3632

50

3645

29 0 1 2 3 4 5

0 0 41 92 128 29

1 146 0 64 68 32 137

2 95 115 0 50 86

3 45 65 137 0 36

4 81 101 32 36 0 72

5 175 29 53 57 21 0


Edge (5,4)

410 1

4

5

3 2

19

32 51

21

3632

50

3645

29 0 1 2 3 4 5

0 0 41 92 128 50 29

1 146 0 64 68 32 137

2 95 115 0 50 107 86

3 45 65 137 0 57 36

4 81 101 32 36 0 72

5 175 29 53 57 21 0


• Well, that was ONE pass – need to do that V times!



Documents

Data Structures & Algorithms Shortest Paths Richard Newman based on book by R. Sedgewick and slides by S. Sahni