Algorithms and Data Structures Lecture 10 Graph Algorithms III: - - PowerPoint PPT Presentation

Algorithms and Complexity Fabian Kuhn

Lecture 10 Graph Algorithms III: Shortest Paths

Algorithms and Data Structures

Fabian Kuhn Algorithms and Complexity

Algorithms and Complexity Fabian Kuhn

Single Sourse Shortest Paths Problem

• Given: weighted graph 𝐻 = 𝑊, 𝐹, 𝑥 , start node 𝑡 ∈ 𝑊

– We denote the weight of an edge 𝑣, 𝑤 by 𝑥 𝑣, 𝑤 – Assumption for now: ∀𝑓 ∈ 𝐹: 𝑥 𝑓 ≥ 0

• Goal: Find shortest paths / distances from 𝑡 to all nodes

– Distance from 𝑡 to 𝑤: 𝑒𝐻 𝑡, 𝑤 (length of a shortest path)

2

Shortest Paths

1 2 3 4 5 6 8 7 1 3 6 8 9 1 15 2 9 7 6 3 1

Distance from node 1 to node 7 : 10

𝒕

Algorithms and Complexity Fabian Kuhn

Lemma: If 𝑤0, 𝑤1, … , 𝑤𝑙 is a shortest path from 𝑤0 to 𝑤𝑙, then it holds for all 0 ≤ 𝑗 ≤ 𝑘 ≤ 𝑙 that the subpath 𝑤𝑗, 𝑤𝑗+1, … , 𝑤𝑘 is also a shortest path from 𝑤𝑗 to 𝑤𝑘. Shortest path from 𝒘𝟏 to 𝒘𝒍:

• Subpath from 𝑤𝑗 to 𝑤𝑘 is also a shortest path.

– Otherwise, one could replace the path from 𝑤𝑗 to 𝑤𝑘 by the shortest path from 𝑤𝑗 to 𝑤𝑘. – If by doing this, nodes are visited multiple time, one can cut out cycles and

• btains an even shorter path.
• Lemma also holds for negative edge weights,

– as long as the graph does not contain negative cycles.

3

Optimality of Subpaths

𝒘𝟏

𝒘𝟐

𝒘𝒋 𝒘𝒌 𝒘𝒍

Algorithms and Complexity Fabian Kuhn

• Spanning tree that is rooted at node 𝑡 and that contains

shortest paths from 𝑡 to all other nodes.

– Such a tree always exists (follows from the optimality of subpaths)

• For unweighted graphs: BFS spanning tree
• Goal: Find a shortest path tree

4

Shortest-Path Tree

1 2 3 4 5 6 8 7 1 3 6 8 9 1 15 2 9 7 6 3

𝒕

Algorithms and Complexity Fabian Kuhn

• Algorithm by Edsger W. Dijkstra (published in 1959)

Idea:

• We start at 𝑡 and build the spanning tree in a step-by-step manner.
• Goal: In each step of the algorithm, add one node

– Initially: subtree only consists of 𝑡 (trivially satisfies invariant...) – 1st step: Because of the optimality of subpaths, there must be a shortest path consisting of a single edge... – Always add the remaining node at the smallest distance from 𝑡.

5

Dijkstra’s Algorithm: Idea

Invariant: Algorithm always has a tree rooted at 𝑡, which is a subtree

• f a shortest path tree.

Algorithms and Complexity Fabian Kuhn

Given: A tree 𝑈 that is rooted in 𝑡, such that 𝑈 is a subtree of a shortest paths tree for node 𝑡 in 𝐻. (nodes of 𝑈 : 𝑇) How can we extend 𝑈 by a single node?

6

Dijkstra’s Algorithm : One Step

𝒕 1 4 3 2 2 5 𝟏 𝟐 𝟔 𝟑 𝟓 𝟕 𝟗

𝑻 𝑶(𝑻)

10 5 3 1 7 3 2 5 6 𝟐𝟏 𝟐𝟐 𝟗 𝟗 𝟐𝟏

𝑇 : nodes in the tree 𝑈 𝑂 𝑇 : nodes that can be added to the tree directly. To add 𝑤 ∈ 𝑂 𝑇 it most hold that 𝑒𝐻 𝑡, 𝑤 = min

𝑣∈𝑇 𝑒𝐻 𝑡, 𝑣 + 𝑥 𝑣, 𝑤

We will see that this always holds for 𝑤 ∈ 𝑂 𝑇 with minimum distance 𝑒𝐻 𝑡, 𝑤 from 𝑡.

Algorithms and Complexity Fabian Kuhn

Given: 𝑈 is subtree of a shortest path tree for 𝑡 in 𝐻. Lemma: For a node 𝑤 ∈ 𝑂 𝑇 and an edge 𝑣, 𝑤 with 𝑣 ∈ 𝑇 such that 𝑒𝐻 𝑡, 𝑣 + 𝑥 𝑣, 𝑤 is minimized, it holds that 𝒆𝑯 𝒕, 𝒘 = 𝒆𝑯 𝒕, 𝒗 + 𝒙 𝒗, 𝒘 Consider the 𝑡-𝑤 path that we obtain in this way: Assume that there is a shorter path:

– Because there are no negative edge weights, we therefore have 𝑒𝐻 𝑡, 𝑦 + 𝑥 𝑦, 𝑧 ≤ 𝑒𝐻(𝑡, 𝑤) < 𝑒𝐻 𝑡, 𝑣 + 𝑥(𝑣, 𝑤)

7

Dijkstra’s Algorithm : One Step

𝒕 𝒘 𝒗

𝑻 𝑶(𝑻)

𝒕 𝒚 𝒛

𝑻 𝑶(𝑻)

𝒘

Algorithms and Complexity Fabian Kuhn

• At the beginning, we have 𝑈 =

𝑡 , ∅

• For each node 𝑤 ∉ 𝑇, one at all times computes

𝜀 𝑡, 𝑤 ≔ min

𝑣∈𝑇∩𝑂in 𝑤 𝑒𝐻 𝑡, 𝑣 + 𝑥 𝑣, 𝑤

– as well as the incoming neighbor 𝑣 =: 𝛽 𝑤 that minimized the expression...

• 𝜀 𝑡, 𝑤 corresponds to an 𝑡-𝑤 path ⟹ 𝜀 𝑡, 𝑤 ≥ 𝑒𝐻 𝑡, 𝑤
• Lemma on last slide:

For minimum 𝜺 𝒕, 𝒘 , we have: 𝜺 𝒕, 𝒘 = 𝒆𝑯 𝒕, 𝒘

8

Dijkstra’s Algorithm

Invariant: Algorithm always has a tree 𝑈 = (𝑇, 𝐵) rooted at 𝑡, which is a subtree of a shortest path tree of 𝐻.

Algorithms and Complexity Fabian Kuhn

Initialization 𝑼 = ∅, ∅

• 𝜀 𝑡, 𝑡 = 0, and 𝜀 𝑡, 𝑤 = ∞ for all 𝑤 ≠ 𝑡
• 𝛽 𝑤 = NULL for all 𝑤 ∈ 𝑊

Iteration Step

• Choose a node 𝑤 with smallest

𝜀 𝑡, 𝑤 ≔ min

𝑣∈𝑇∩𝑂in 𝑤 𝑒𝐻 𝑡, 𝑣 + 𝑥 𝑣, 𝑤

• Go through all out-neighbors 𝑦 ∈ 𝑊 ∖ 𝑇 and set

𝜀 𝑡, 𝑦 ≔ min 𝜀 𝑡, 𝑦 , 𝜀 𝑡, 𝑤 + 𝑥 𝑤, 𝑦

– If 𝜀 𝑡, 𝑦 is decreased, set 𝛽 𝑦 = 𝑤

• Add node 𝑤 and edge 𝛽 𝑤 , 𝑤 to the tree 𝑈.

9

Dijkstra’s Algorithm

𝒕 𝒘 𝒚

update 𝜀 𝑡, 𝑦

Algorithms and Complexity Fabian Kuhn 10

Dijkstra’s Algorithm: Example

∞ 𝟏 ∞ ∞ ∞ ∞ ∞ ∞ ∞ ∞ ∞ 3 13 4 9 1 10 32 23 3 3 8 2 20 1 18 17 1 19 9 1 6 2 2

Algorithms and Complexity Fabian Kuhn 11

Dijkstra’s Algorithm: Example

𝟐 𝟏 ∞ ∞ ∞ 𝟐𝟘 ∞ 𝟐𝟖 𝟑𝟏 ∞ 𝟐𝟗 3 13 4 9 1 10 32 23 3 3 8 2 20 1 18 17 1 19 9 1 6 2 2

Algorithms and Complexity Fabian Kuhn 12

Dijkstra’s Algorithm: Example

𝟐 𝟏 𝟐𝟓 ∞ 𝟓 𝟐𝟘 ∞ 𝟖 𝟑𝟏 ∞ 𝟐𝟗 3 13 4 9 1 10 32 23 3 3 8 2 20 1 18 17 1 19 9 1 6 2 2

Algorithms and Complexity Fabian Kuhn 13

Dijkstra’s Algorithm: Example

𝟐 𝟏 𝟐𝟒 ∞ 𝟓 𝟐𝟘 𝟔 𝟖 𝟑𝟏 ∞ 𝟐𝟗 3 13 4 9 1 10 32 23 3 3 8 2 20 1 18 17 1 19 9 1 6 2 2

Algorithms and Complexity Fabian Kuhn 14

Dijkstra’s Algorithm: Example

𝟐 𝟏 𝟐𝟒 ∞ 𝟓 𝟐𝟘 𝟔 𝟖 𝟑𝟏 𝟒𝟖 𝟐𝟗 3 13 4 9 1 10 32 23 3 3 8 2 20 1 18 17 1 19 9 1 6 2 2

Algorithms and Complexity Fabian Kuhn 15

Dijkstra’s Algorithm: Example

𝟐 𝟏 𝟘 ∞ 𝟓 𝟐𝟘 𝟔 𝟖 𝟑𝟏 𝟒𝟖 𝟐𝟔 3 13 4 9 1 10 32 23 3 3 8 2 20 1 18 17 1 19 9 1 6 2 2

Algorithms and Complexity Fabian Kuhn 16

Dijkstra’s Algorithm: Example

𝟐 𝟏 𝟘 𝟐𝟑 𝟓 𝟐𝟐 𝟔 𝟖 𝟑𝟏 𝟐𝟘 𝟐𝟔 3 13 4 9 1 10 32 23 3 3 8 2 20 1 18 17 1 19 9 1 6 2 2

Algorithms and Complexity Fabian Kuhn 17

Dijkstra’s Algorithm: Example

𝟐 𝟏 𝟘 𝟐𝟑 𝟓 𝟐𝟐 𝟔 𝟖 𝟐𝟒 𝟐𝟘 𝟐𝟑 3 13 4 9 1 10 32 23 3 3 8 2 20 1 18 17 1 19 9 1 6 2 2

Algorithms and Complexity Fabian Kuhn

Initialization 𝑼 = ∅, ∅

• 𝜀 𝑡, 𝑡 = 0, and 𝜀 𝑡, 𝑤 = ∞ for all 𝑤 ≠ 𝑡
• 𝛽 𝑤 = NULL for all 𝑤 ∈ 𝑊

Iteration Step

• Choose a node 𝑤 with smallest

𝜀 𝑡, 𝑤 ≔ min

𝑣∈𝑇∩𝑂in 𝑤 𝑒𝐻 𝑡, 𝑣 + 𝑥 𝑣, 𝑤

• Go through all out-neighbors 𝑦 ∈ 𝑊 ∖ 𝑇 and set

𝜀 𝑡, 𝑦 ≔ min 𝜀 𝑡, 𝑦 , 𝜀 𝑡, 𝑤 + 𝑥 𝑤, 𝑦

– If 𝜀 𝑡, 𝑦 is decreased, set 𝛽 𝑦 = 𝑤

• Add node 𝑤 and edge 𝛽 𝑤 , 𝑤 to the tree 𝑈.

18

Dijkstra’s Algorithm

𝒕 𝒘 𝒚

update 𝜀 𝑡, 𝑦

Similar to the MST algorithm

• f Prim!

Algorithms and Complexity Fabian Kuhn

𝐼 = new priority queue; 𝐵 = ∅ for all 𝑣 ∈ 𝑊 ∖ {𝑡} do 𝐼.insert(𝑣, ∞); 𝛽(𝑣) = NULL 𝐼.insert(𝑡, 0) while 𝐼 is not empty do 𝑣 = H.deleteMin() for all unmarked neighbors 𝑤 of 𝑣 do if 𝑥 𝑣, 𝑤 < 𝑒(𝑤) then 𝐼.decreaseKey(𝑤, 𝑥 𝑣, 𝑤 ) 𝛽 𝑤 = 𝑣 𝑣.marked = true if 𝑣 ≠ 𝑡 then 𝐵 = 𝐵 ∪ 𝑣, 𝛽 𝑣

19

Reminder : Prim’s MST Algorithm

Algorithms and Complexity Fabian Kuhn

𝐼 = new priority queue; 𝐵 = ∅ for all 𝑣 ∈ 𝑊 ∖ {𝑡} do 𝐼.insert(𝑣, ∞); 𝜀 𝑡, 𝑣 = ∞; 𝛽(𝑣) = NULL 𝐼.insert(𝑡, 0) while 𝐼 is not empty do 𝑣 = H.deleteMin() for all unmarked out-neighbors 𝑤 of 𝑣 do if 𝜀 𝑡, 𝑣 + 𝑥 𝑣, 𝑤 < 𝜀 𝑡, 𝑤 then 𝜀(𝑡, 𝑤) = 𝜀 𝑡, 𝑣 + 𝑥(𝑣, 𝑤) 𝐼.decreaseKey(𝑤, 𝜀 𝑡, 𝑤 ) 𝛽 𝑤 = 𝑣 𝑣.marked = true if 𝑣 ≠ 𝑡 then 𝐵 = 𝐵 ∪ 𝛽 𝑣 , 𝑣

20

Dijkstra’s Algorithm : Implementation

Algorithms and Complexity Fabian Kuhn

• Algorithm implementation is almost identical to the

implementation of Prim’s MST algorithm.

• Number of heap operations:

create: 1, insert: 𝑜, deleteMin: 𝑜, decreaseKey: ≤ 𝑛

– Or alternatively without decrease-key: 𝑃 𝑛 insert and deleteMin Op.

• Running time with binary heap:

𝑷 𝒏 𝐦𝐩𝐡 𝒐

• Running time with Fibonacci heap:

𝑷 𝒏 + 𝒐 𝐦𝐩𝐡 𝒐

21

Dijkstra’s Algorithm: Running Time

Algorithms and Complexity Fabian Kuhn

• Shortest paths can also be defined for graphs with

negative edge weights.

– Shortest path is defined if there no shorter way, even if nodes can be visited multiple times.

Example

22

Negative Edge Weights

𝑡

3 5 2

−4 −3 −6 3 6 4 8 7

−

Algorithms and Complexity Fabian Kuhn

Lemma: In a directed, weighted graph 𝐻, there is a shortest path from 𝑡 to 𝑤 if and only if there is no there is no negative cycle that is reachable from 𝑡 and from which one can reach 𝑤.

• Also holds for undirected graphs if edges 𝑣, 𝑤 are considered as 2

directed edges 𝑣, 𝑤 and 𝑤, 𝑣 .

Negative Edge Weights

𝑡 𝑤

−

no shortest path from 𝑣 to 𝑤 no reachable negative cycle We can restrict our attention to simple path. There are only finitely many such path.

Nodes are not visited multiple times.

Algorithms and Complexity Fabian Kuhn

Does Dijkstra’s algorithm work with negative edge weights?

• Answer: no

𝑡

2 1

2 −2 1

1

𝑤

24

Dijkstra’s Algorithm and Negative Weights

Shortest path has length 2. Dijkstra path has length 3.

Algorithms and Complexity Fabian Kuhn

• To simplify, we only compute the distances 𝑒𝐻 𝑡, 𝑤

Assumption:

• For all nodes 𝑤: algorithm has dist. estimate 𝜺 𝒕, 𝒘 ≥ 𝒆𝑯 𝒕, 𝒘
• Initialization: 𝜀 𝑡, 𝑡 = 0, 𝜀 𝑡, 𝑤 = ∞ for 𝑤 ≠ 𝑡

Observation:

• If 𝑣, 𝑤 ∈ 𝐹 such that 𝜀 𝑡, 𝑣 + 𝑥 𝑣, 𝑤 < 𝜀(𝑡, 𝑤), then we can

decrease (and thus improve) 𝜀 𝑡, 𝑤 because 𝒆𝑯 𝒕, 𝒘 ≤ 𝑒𝐻 𝑡, 𝑣 + 𝑥 𝑣, 𝑤 ≤ 𝜺 𝒕, 𝒗 + 𝒙 𝒗, 𝒘

25

Bellman-Ford Algorithm

Algorithms and Complexity Fabian Kuhn

• Consider all edges 𝑣, 𝑤 and try to improve 𝜀 𝑡, 𝑤 ,

– until all distances are correct (∀𝑤 ∈ 𝑊: 𝜀 𝑡, 𝑤 = 𝑒𝐻 𝑡, 𝑤 )

𝜀 𝑡, 𝑡 ≔ 0; ∀𝑤 ∈ 𝑊 ∖ 𝑡 ∶ 𝜀 𝑡, 𝑤 ≔ ∞ repeat for all 𝑣, 𝑤 ∈ 𝐹 do if 𝜀 𝑡, 𝑣 + 𝑥 𝑣, 𝑤 < 𝜀 𝑡, 𝑤 then 𝜀 𝑡, 𝑤 ≔ 𝜀 𝑡, 𝑣 + 𝑥 𝑣, 𝑤 until ∀𝑤 ∈ 𝑊: 𝜀 𝑡, 𝑤 = 𝑒𝐻 𝑡, 𝑤

• How many repetitions are necessary?

– Shortest paths consisting of one edge ⟹ 1 repetitions – Shortest paths consisting of two edges ⟹ 2 repetitions – … – Shortest paths consisting of 𝑙 edges ⟹ 𝑙 repetitions

26

Bellman-Ford Algorithm

Algorithms and Complexity Fabian Kuhn

𝜀 𝑡, 𝑡 ≔ 0; ∀𝑤 ∈ 𝑊 ∖ 𝑡 ∶ 𝜀 𝑡, 𝑤 ≔ ∞ for i := 1 to n-1 do for all 𝑣, 𝑤 ∈ 𝐹 do if 𝜀 𝑡, 𝑣 + 𝑥 𝑣, 𝑤 < 𝜀 𝑡, 𝑤 then 𝜀 𝑡, 𝑤 ≔ 𝜀 𝑡, 𝑣 + 𝑥 𝑣, 𝑤 After 𝑗 repetitions, we have 𝜺 𝒕, 𝒘 ≤ 𝒆𝑯

𝒋 𝒕, 𝒘 , where 𝑒𝐻 𝑗 𝑡, 𝑤 is

the length of a shortest path consisting of at most 𝑗 edges.

• Follows by induction on 𝒋:

– 𝑗 = 0: 𝜀 𝑡, 𝑡 = 𝑒𝐻

0 𝑡, 𝑡 = 0, 𝑤 ≠ 𝑡 ⟹ 𝜀 𝑡, 𝑤 = 𝑒𝐻 0 𝑡, 𝑤 = ∞

– 𝑗 > 0: 𝑒𝐻

𝑗 𝑡, 𝑤 = min 𝑒𝐻 𝑗−1 𝑡, 𝑤 ,

min

𝑣∈𝑂𝑗𝑜 𝑤 𝑒𝐻 𝑗−1 𝑡, 𝑣 + 𝑥(𝑣, 𝑤)

(shortest path consists of ≤ 𝑗 − 1 edges or of exactly 𝑗 edges)

27

Bellman-Ford Algorithm

Algorithms and Complexity Fabian Kuhn

𝜀 𝑡, 𝑡 ≔ 0; ∀𝑤 ∈ 𝑊 ∖ 𝑡 ∶ 𝜀 𝑡, 𝑤 ≔ ∞ for i := 1 to n-1 do for all 𝑣, 𝑤 ∈ 𝐹 do if 𝜀 𝑡, 𝑣 + 𝑥 𝑣, 𝑤 < 𝜀 𝑡, 𝑤 then 𝜀 𝑡, 𝑤 ≔ 𝜀 𝑡, 𝑣 + 𝑥 𝑣, 𝑤 Theorem: If the graph has no negative cycles that are reachable from 𝑡, at the end all distances are computed correctly.

• At the end, we have for all 𝑤 ∈ 𝑊:

𝜀 𝑡, 𝑤 ≤ 𝑒𝐻

𝑜−1 (𝑡, 𝑤)

• Because every path consists of ≤ 𝑜 − 1 edges, we also have

𝑒𝐻

𝑜−1 𝑡, 𝑤 = 𝑒𝐻(𝑡, 𝑤)

28

Bellman-Ford Algorithm

Algorithms and Complexity Fabian Kuhn

• We will see: If there is a (from 𝑡 reachable) negative cycle, then

there is an improvement for some edge: ∃ 𝑣, 𝑤 ∈ 𝐹 ∶ 𝜀 𝑡, 𝑣 + 𝑥 𝑣, 𝑤 < 𝜀 𝑡, 𝑤 Bellman-Ford Algorithm

for i := 1 to n-1 do for all 𝑣, 𝑤 ∈ 𝐹 do if 𝜀 𝑡, 𝑣 + 𝑥 𝑣, 𝑤 < 𝜀 𝑡, 𝑤 then 𝜀 𝑡, 𝑤 ≔ 𝜀 𝑡, 𝑣 + 𝑥 𝑣, 𝑤 for all 𝑣, 𝑤 ∈ 𝐹 do if 𝜀 𝑡, 𝑣 + 𝑥 𝑣, 𝑤 < 𝜀(𝑡, 𝑤) then return false return true

29

Detecting Negative Cycles

Algorithms and Complexity Fabian Kuhn 30

Detecting Negative Cycles

−

𝑡 𝑤1 𝑤2 𝑤3 𝑤0 = 𝑤𝑙

• neg. cycle ⟹ ෍

𝑗=1 𝑙

𝑥 𝑤𝑗−1, 𝑤𝑗 < 0 !

= < 0

Lemma: If 𝐻 contains a negative cycles that is reachable from 𝑡, then the Bellman-Ford algorithm returns false. Proof by contradiction:

• Assumption : ∀𝑗 ∈ 1, … , 𝑙 ∶ 𝜀 𝑡, 𝑤𝑗−1 + 𝑥 𝑤𝑗−1, 𝑤𝑗 ≥ 𝜀 𝑡, 𝑤𝑗

෍

𝑗=1 𝑙

𝜀 𝑡, 𝑤𝑗 ≤ ෍

𝑗=1 𝑙

𝜀 𝑡, 𝑤𝑗−1 + 𝑥 𝑤𝑗−1, 𝑤𝑗 = ෍

𝑗=1 𝑙

𝜀 𝑡, 𝑤𝑗−1 + ෍

𝑗=1 𝑙

𝑥 𝑤𝑗−1, 𝑤𝑗

≤

reachable from 𝑡 ⟹ 𝜀 𝑡, 𝑤𝑗 ≠ ∞

Algorithms and Complexity Fabian Kuhn

A shortest path tree can be computed in the usual way. Initialization:

• 𝜀 𝑡, 𝑡 = 0, für 𝑤 ≠ 𝑡 ∶ 𝜀 𝑡, 𝑤 = NULL
• 𝛽 𝑡 = NULL, for 𝑤 ≠ 𝑡 ∶ 𝛽 𝑤 = NULL

In every loop iteration: ... if 𝜀 𝑡, 𝑣 + 𝑥 𝑣, 𝑤 < 𝜀 𝑡, 𝑤 then 𝜀 𝑡, 𝑤 ≔ 𝜀 𝑡, 𝑣 + 𝑥 𝑣, 𝑤 𝛽 𝑤 ≔ 𝑣

• At the end, 𝛽 𝑤 points to a parent in the shortest path tree

– if there are no negative cycles...

31

Bellman-Ford Algorithm : Shortest Paths

Algorithms and Complexity Fabian Kuhn

Theorem: If there is a negative cycle that is reachable from 𝑡, the Bellman-Ford algorithm detects this. If no such cycle exists, the Bellman-Ford algorithm computes a shortest path tree in time 𝑃 𝑊 ⋅ 𝐹 .

• Correctness: already proven
• Running time:

– 𝑜 − 1 + 1 loop iterations – In every loop iteration, we go once through all the edges.

• Remark: One can adapt the algorithm such that it computes a

shortest path for all 𝑤, for shich such a path from 𝑡 existsts (and it detects if no shortest path exists).

– in the same asymptotic running time

32

Bellman-Ford Algorithm : Summary

Algorithms and Complexity Fabian Kuhn

Goal: Optimal routing paths for some destination 𝑢

• For every node, we want to know to which neighbor one has to

send a message destined at node 𝑢.

• This corresponds to computing a shortest path tree if all edges are

reversed (transpose graph) Algorithm:

• Nodes remember tha current distance 𝜀 𝑣, 𝑢 and the currently

best neighbor.

• All nodes in parallel check if there is an improvement for some

neighbor: ∃ 𝑣, 𝑤 ∈ 𝐹 ∶ 𝑥 𝑣, 𝑤 + 𝜀 𝑤, 𝑢 < 𝜀 𝑣, 𝑢

• Corresponds to a parallel variant of the Bellman-Ford algorithm

33

Routing Paths in Networks

Algorithms and Complexity Fabian Kuhn

• all pairs shortest paths problem

Compute single-source shortest paths for all nodes

• Dijkstra algorithm with all nodes:

Running time: 𝑜 ⋅ 𝑃 Running time Dijkstra ∈ 𝑃 𝑛𝑜 + 𝑜2 log 𝑜

– Problem: only works for non-negative edge weights

• Bellman-Ford algorithm with all nodes:

Running time: 𝑜 ⋅ 𝑃 Running time BF ∈ 𝑃 𝑛𝑜2 ∈ 𝑃 𝑜4

– Problem: slow... – If the Bellman-Ford algorithm is carried out for all nodes, the running time can be improved to 𝑃 𝑜3 ⋅ log 𝑜 . – If all 𝑒𝐻

𝑗 𝑣, 𝑤 -distances are known, one can directly compute the

𝑒𝐻

2𝑗 𝑣, 𝑤 -distances in one iteration.

• Further details and discussion of other algorithms in various text books.

34

Shortest Paths Between All Node Pairs