Scribd
Upload
106 views

אלגוריתמים- הרצאה 7 - Single Source Shortest Path Problem

The document discusses algorithms for solving single-source shortest path problems: 1) Dijkstra's algorithm efficiently finds shortest paths from a single source node to all other nodes in a graph where all edge weights are non-negative. 2) Bellman-Ford algorithm can handle graphs with negative edge weights by performing relaxation of all edges |V|-1 times to detect negative cycles. 3) For directed acyclic graphs (DAGs), topological sorting allows shortest paths to be found in one pass rather than |V|-1 passes as in Bellman-Ford.

Uploaded by

Ron
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
106 views

אלגוריתמים- הרצאה 7 - Single Source Shortest Path Problem

The document discusses algorithms for solving single-source shortest path problems: 1) Dijkstra's algorithm efficiently finds shortest paths from a single source node to all other nodes in a graph where all edge weights are non-negative. 2) Bellman-Ford algorithm can handle graphs with negative edge weights by performing relaxation of all edges |V|-1 times to detect negative cycles. 3) For directed acyclic graphs (DAGs), topological sorting allows shortest paths to be found in one pass rather than |V|-1 passes as in Bellman-Ford.

Uploaded by

Ron
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 5

Algorithms

Dana Shapira Lesson #7: Single source shortest path problem

Single Source Shortest Path Problem


Given a weighted, directed 1 graph G = (V, E), with weight 5 function w: E R mapping 10 edges to real valued weights. 1 Single source shortest path 3 8 2 3 problem: given vertex s, for every vertex vV find a 1 1 3 shortest path from s to v. 1 4 6 Dijkstras algorithm solves this problem efficiently for 6 5 the case in which all weights 2 are nonnegative

Shortest Path Properties


We have optimal substructure: the shortest path consists of shortest subpaths:

Shortest Path Properties


Define (u,v) to be the weight of the shortest path from u to v Shortest paths satisfy the triangle inequality: (u,v) (u,x) + (x,v) For each edge (x,v) (u,v) (u,x) + (x,v) (why?)
x

Proof: suppose some subpath is not a shortest path There must then exist a shorter subpath Could substitute the shorter subpath for a shorter path But then overall path is not shortest path. Contradiction

This path is no longer than any other path


3 4

Shortest Path Properties


In graphs with negative weight cycles, some shortest paths will not exist (Why?):

Relaxation
For all v, maintain upper bound d[v] on (s,v) Relax(u,v,w) { if (d[v] > d[u]+w(u,v)) then d[v]=d[u]+w(u,v); }

< 0
5 2 9 5 2 6

Relax
5
5

Relax
7 5 2 6
6

Dijkstras Algorithm
B Dijkstra(G,s) 2 10 for each v V 4 3 d[v] = ; (v)=NULL; A d[s] = 0; S = ; Q = V; (s)=NULL; 5 1 C while (Q ) u = ExtractMin(Q); S = S U {u}; for each v Adj[u] if (d[v] > d[u]+w(u,v)) Relaxation d[v] = d[u]+w(u,v); Step (v)=u What will be the total running time?
7

Correctness Of Dijkstra's Algorithm


D We must show that when u is removed from Q, it has already converged p2 u s y x p1 Note that d[v] (s,v) v Let u be first vertex in S such that d[u] (s,u) when it is removed from Q. 8

Correctness Of Dijkstra's Algorithm


p2 u s y x p1 Let y be first vertex V-S on actual shortest path from su d[y] = (s,y) Because d[x] is set correctly for y's predecessor x S on the shortest path (u was the first vertex in S such that d[u] (s,u)) , When we put x into S, we relaxed (x,y), giving d[y] the 9 correct value

Correctness Of Dijkstra's Algorithm


p2 u s y x p1 d[u]> (s,u) = (s,y) + (y,u) (Why?) = d[y] + (y,u) d[y] But if d[u] > d[y], wouldn't have chosen u. Contradiction.
10

Question
Can you give an example of a graph that includes negative weights, and does not work with Dijkstras algorithm? A 4 0 B -2 4 D A 4 4 B

Bellman-Ford Algorithm
BellmanFord() for each v V d[v] = ; d[s] = 0; for i=1 to |V|-1 for each edge (u,v) E Relax(u,v, w(u,v)); for each edge (u,v) E if (d[v] > d[u] + w(u,v)) return no solution;
Initialize d[], which will converge to shortest-path value Relaxation: Make |V|-1 passes, relaxing each edge Test for solution Under what condition do we get a solution?

3 D 1

3 3 1 C
11

Relax(u,v,w): if (d[v] > d[u]+w) then d[v]=d[u]+w

12

Bellman-Ford Algorithm
BellmanFord() What will be the running time? for each v V A: O(|V||E|) d[v] = ; d[s] = 0; for i=1 to |V|-1 for each edge (u,v) E Relax(u,v, w(u,v)); for each edge (u,v) E if (d[v] > d[u] + w(u,v)) return no solution;

Bellman-Ford Algorithm
BellmanFord() for each v V s d[v] = ; d[s] = 0; for i=1 to |V|-1 for each edge (u,v) E Relax(u,v, w(u,v)); for each edge (u,v) E if (d[v] > d[u] + w(u,v)) return no solution; -1 A 4 C 3 1 D B 2 2 E -3

5 Example

Relax(u,v,w): if (d[v] > d[u]+w) then d[v]=d[u]+w

Relax(u,v,w): if (d[v] > d[u]+w) then d[v]=d[u]+w

13

14

Bellman-Ford
Correctness: show d[v] = (s,v) after |V|-1 passes Lemma: d[v] (s,v) always Initially true Let v be first vertex for which d[v] < (s,v) Let u be the vertex that caused d[v] to change: d[v] = d[u] + w(u,v) Then d[v] < (s,v) (s,v) (s,u) + w(u,v) (Why?) (s,u) + w(u,v) d[u] + w(u,v) (Why?) So d[v] < d[u] + w(u,v). Contradiction.
15

Bellman-Ford
Prove: after |V|-1 passes, all d values correct Consider shortest path from s to v: s v1 v2 v3 v Initially, d[s] = 0 is correct, and doesnt change (Why?) After 1 pass through edges, d[v1] is correct (Why?) and doesnt change After 2 passes, d[v2] is correct and doesnt change Terminates in |V| - 1 passes: (Why?)

What if it doesnt?

16

Bellman-Ford Example
t 6 s

DAG Shortest Paths


Problem: finding shortest paths in DAG Bellman-Ford takes O(|V||E|) time.

5 -2

0
7

3 7 2 4 9 z

How can we do better?


Idea: use topological sort If were lucky and processes vertices on each shortest path from left to right, would be done in one pass Every path in a DAG is subsequence of topologically sorted vertex order, so processing vertices in that order, we will do each path in forward order (will never relax edges out of vertices before doing all edges into vertices). 18 Thus: just one pass. What will be the running time?

17

You might also like