shortest path algorithms
Download
Skip this Video
Download Presentation
Shortest Path Algorithms

Loading in 2 Seconds...

play fullscreen
1 / 32

Shortest Path Algorithms - PowerPoint PPT Presentation


  • 221 Views
  • Uploaded on

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.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Shortest Path Algorithms' - savanna


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
routing 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.
  • Weight of a path is the sum of weight of all links
  • Shortest path is the minimum weight path
slide3

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
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

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
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
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
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
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
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
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

(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

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
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
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
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
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
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

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

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

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
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

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

bellman ford algorithm
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

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

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

2. d(s) = 0

3. For t=1 to V-1,

example27

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
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
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

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

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
Features of this algorithm
  • Note that a node needs information about its neighbors only!
  • So we do not need a global processor.
ad