- 221 Views
- Uploaded on

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

- 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

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

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)

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.

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

- 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

- 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

- 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

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

(c ) Remove v from Q;

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

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

}

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

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

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

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

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.

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

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

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!

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

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

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

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

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

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

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.

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

- Note that a node needs information about its neighbors only!
- So we do not need a global processor.

Download Presentation

Connecting to Server..