Shortest path algorithms l.jpg
This presentation is the property of its rightful owner.
Sponsored Links
1 / 32

Shortest Path Algorithms PowerPoint PPT Presentation


  • 177 Views
  • Uploaded on
  • Presentation posted in: General

Shortest Path Algorithms. Routing Algorithms. Shortest path routing What is a shortest path? Minimum number of hops? Minimum distance? There is a weight associated with each link Weight can be a measure of congestion in the link, propagation delay etc.

Download Presentation

Shortest Path Algorithms

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Shortest path algorithms l.jpg

Shortest Path Algorithms


Routing algorithms l.jpg

Routing Algorithms

  • Shortest path routing

  • What is a shortest path?

    • Minimum number of hops?

    • Minimum distance?

  • There is a weight associated with each link

    • Weight can be a measure of congestion in the link, propagation delay etc.

  • Weight of a path is the sum of weight of all links

  • Shortest path is the minimum weight path


Slide3 l.jpg

Path 1

1

1.5

0.5

2.5

Source

Destination

Path 2

Weight of path 1 = 2.5

Weight of path 2 = 3.0


Computation of shortest paths l.jpg

Computation of shortest paths

  • Enumerate all paths?

    • Exponential complexity

  • Several polynomial complexity algorithms exist

    • Dijkstras algorithm (greedy algorithm)

    • Bellman-ford algorithm (distributed algorithm)

    • Flloyd-Warshall algorithm (dynamic programming)

    • Johnsons algorithm


Dijkstras algorithm l.jpg

Source

Destination

Dijkstras algorithm

  • Assumes a directed graph

  • Given any node, finds the shortest path to every other node in the graph

  • O(V log V + E)


Slide6 l.jpg

  • Let source node be s

  • Maintains shortest path ``estimate’’ for every vertex v, (d(v))

    • ``estimate’’ is what it believes to be the shortest path from s

      and the list of vertices for whom the shortest path is known

  • Initially the list of vertices for whom the shortest path is known is empty and

    the estimates are infinity for all vertices except the source vertex itself.


Slide7 l.jpg

  • It holds that whenever the estimate d(v) is finite for a vertex v, there exists a path from the source s to v with weight d(v)

  • It turns out that the estimate is accurate for the vertex with the minimum value of this estimate

    • Shortest path is known for this vertex (v)

  • This vertex (v) is added to the list of vertices for whom shortest path is known

  • Shortest path estimates are upgraded for every vertex which has an edge from v, and is not in this ``known list’’.


Estimate upgrade procedure l.jpg

Estimate Upgrade Procedure

  • Suppose vertex v is added to the list newly, and we are upgrading the estimate for vertex u

    • d(v) is the shortest path estimate for v, d(u) is the estimate for u

    • w(v, u) is the weight of the edge from v to u

      d(u) -> min(d(u), d(v) + w(v, u))


Intuition behind the upgrade procedure l.jpg

Intuition behind the upgrade procedure

  • Assume that d(u) and d(v) are finite

  • So there exists a path to v from s of weight d(v), (s, v1, v2,…..v)

  • Hence there exists a path from s to u (s, v1, v2,…..v, u) of weight d(v) + w(v, u)

  • Also, there exists a path to u of weight d(u).

  • So the shortest path to u can not have weight more than either d(u) or d(v) + w(v, u).

  • So we upgrade the estimate by the minimum of the two.


Notation l.jpg

Notation

  • Source vertex: s

  • Shortest path estimate of vertex v: d(v)

  • Weight of edge (u, v): w(u, v)

  • Set of vertices whose shortest paths are known: S

  • Q = V \ S


Algorithm l.jpg

Algorithm

1. For every vertex v in V, d(v) = 

2. d(s) = 0

3. Q = V

S = 

4. While Q is non-empty

{

(a) v=Extract-min(Q);


Slide12 l.jpg

(b) Add v to S;

(c ) Remove v from Q;

(d) For each vertex u in Adj(v)

d(u) -> min(d(u), d(v)) + w(v, u))

}


Example l.jpg

7

1

1

5

1

10

7

7

7

s

s

8

5

8

s

8

4

5

3

3

2

2

3

2

4

5

4

0

0

0

2

2

2

5

5

2

2

5

7

6

5

6

5

1

1

5

1

6

7

7

s

s

7

8

8

s

2

3

8

4

5

2

3

4

5

2

3

4

5

0

0

0

2

2

2

5

5

2

7

2

7

5

2

7

Example


Algorithm complexity l.jpg

Algorithm Complexity

  • Statement 1 is executed |V| times

  • Statements 2 and 3 are executed once

  • Loop at statement 4 is executed |V| times

  • Every extract-min operation can be done in at most |V| operations

  • Statement 4(a) is executed total |V|2 times

  • Statements 4(b) and 4(c ) are executed |V| times each (total)

  • Observe that statement 4(d) is executed |E| times


Slide15 l.jpg

  • So overall complexity is O(|V|2 + |E|) and this is same as O(|V|2)

  • Using improved data structures complexity can be reduced

    • O((|V| + |E|)log |V|) using binary heaps

    • O(|V| log |V| + |E|) using fibonacci heaps


Proof of correctness l.jpg

Proof of Correctness

  • Exercise:

    • Verify that whenever d(v) is finite, there is a path from source s to vertex v of weight d(v)


Assumptions l.jpg

Assumptions

  • Assume that source s is connected to every vertex in the graph, and all edge weights are finite Also, assume that edge weights are positive.

  • Let p(s, v) be the weight of the shortest path from s to v.

  • Will show that the graph terminates with d(v)=shortest path weights for every vertex


Slide18 l.jpg

  • Will first show that once a vertex v enters S, d(v) equals the shortest path weight from source s, at all subsequent times.

    • Clearly this holds in step 1, as source enters S in step 1, and d(s) = 0

    • Let this not hold for the first time in step k > 1

      • Thus the vertex u added has d(u) > p(s, u)

  • Consider the situation just before insertion of u.

  • Consider the true shortest path, p, from s to u.


Slide19 l.jpg

  • Since s is in S, and u is in Q, path p must jump from S to Q at some point.

S

Q

u

s

x

y

Path p

Let the jump have end point x in S, and y in Q (possibly s = x, and u = y)

We will argue that y and u are different vertices

Since path p is the shortest path from s to u, the segment of path p between s and x, is the shortest path from s to x, and that between s and y is the shortest from s to y


Slide20 l.jpg

S

Q

u

s

w(x,y)

y

x

Path p

  • Weight of the segment between s and x is d(x)

    • since x is in S, d(x) is the weight of the shortest path to x

Weight of the segment between s and y is d(x) + w(x, y)

Thus, p(s, y) = d(x) + w(x, y)

Also, d(y) <= d(x) + w(x, y) = p(s, y)

Follows that d(y) = p(s, y)

However, d(u) > p(s, u). So, u and y are different


Slide21 l.jpg

s

y

u

  • Since, y appears somewhere along the shortest path between s and u, but y and u are different, p(s, y) < p(s, u)

    • Using the fact that all edges have positive weight

Hence, d(y) = p(s, y) < p(s, u) < d(u)

Both y and u are in Q. So, u should not be chosen in this step

So, whenever a vertex u is inducted in S, d(y) = p(s, y).

Once d(u) equals p(s, u) for any vertex it can not change any further (d(u) can only decrease or remain same, and d(u) can not fall below p(s, u).

Since the algorithm terminates only when S= V, we are done!


Slide22 l.jpg

  • We have proved only for edges with positive weight

    • One can prove for edges with nonnegative weight

  • Shortcoming

    • Does not hold for edges with nonnegative weight

    • Centralized algorithm


Slide23 l.jpg

Exercise: This computation gives shortest path weights only. Modify this algorithm to generate shortest paths as well!


Bellman ford algorithm l.jpg

Bellman-ford Algorithm

  • Applies as long as there are no nonpositive

    weight cycles

    • If there are circles of weight 0 or less, then the shortest paths are not well defined

  • Capable of full distributed operation

  • O(|V||E|) complexity

    • slower than Dijkstra


Algorithm description l.jpg

0.5

2.1

2

d(v) = 2.6

1

5

0.1

v

Algorithm description

  • Every node v maintains a shortest path weight estimate, d(v)

  • These estimates are initialized to infinity, for all vertices except source, s, d(s)=0

  • Every node repeatedly updates its shortest path estimate as follows


Slide26 l.jpg

1. For every vertex v in V, d(v) = 

2. d(s) = 0

3. For t=1 to V-1,


Example27 l.jpg

7

1

1

5

1

8

7

7

7

s

s

8

5

8

s

8

4

5

3

3

2

2

3

2

4

5

4

0

0

0

2

2

2

5

5

2

2

5

7

6

6

5

5

1

1

7

7

s

s

8

8

2

2

3

3

4

4

5

5

0

0

2

2

5

5

2

2

7

7

Example


Complexity analysis l.jpg

Complexity Analysis

  • Initialization step takes |V| + 1 steps

  • The loop in statement 3 is executed |V| times

  • Each execution takes |E| steps

  • Overall, there are |V| + 1 + |V||E| steps

    • O(|V||E|)


Proof that it works l.jpg

Proof that it works

  • Assume that all vertices are reachable from source, s.

    • Thus there is a shortest path to any vertex v from s.

  • Assume that the graph has no cycles of weight 0 or less

    • So the shortest paths can not have more than |V|-1 edges.

  • We will prove that at the termination of Bellman-Ford algorithm, d(v)=p(s,v) for every vertex v.

  • We will show that if there is one shortest path to a vertex of k hops, then after the kth execution of the loop in statement 3, d(v) freezes at p(s, v)


Slide30 l.jpg

Consider a vertex u with a shortest path p of k + 1 hops.

p

s

y

u

p1

Let vertex y be its predecessor. Clearly p1 is a shortest path to y and it has k hops. So weight of path p1 is p(s, y)

We know the above holds for k = 0, as d(s) = p(s, s) = 0 at all times.

Let the above hold for 1,….,k. We will show that this holds for k + 1

So, by induction hypothesis, d(y) = p(s, y) after the kth iteration and at all subsequent times .

So by the estimate update procedure, d(u) <= d(y) + w(y, u) = p(s, y) + w(y, u) = weight of path p = p(s, u) after the k+1 th iteration and all subsequent times.


Slide31 l.jpg

We have just shown that d(u) <= p(s, u) after the k+1 th iteration

Again verify that as long as d(v) is finite, d(v) is length of some path to vertex v.

Hence d(u) >= p(s, u) always

Thus, d(u) = p(s, u), always after the k+1th iteration.


Features of this algorithm l.jpg

Features of this algorithm

  • Note that a node needs information about its neighbors only!

  • So we do not need a global processor.


  • Login