Shortest Path Routing

1. Last time we began discussing algorithms for finding shortest paths based on modeling networks as graphs

   • Each computer/router in the network is represented by a node in the graph.

   • Links between computers in the network are represented by directed edges (one in each direction).

   • A cost or weight is associated with each edge.

     For our discussion, we will use the symbols d_{i ->j} to denote the cost (distance) of the edge from node i to node j.

   • We will use the symbols D_{i ->j} to denote the length of the shortest path from i to j.

2. The first algorithm, known as the Bellman-Ford algorithm is based on a simple formula relating values of D_{i ->j}.

   • The Bellman-Ford algorithm works by computing a series, Dⁱ_{i ->j}, of approximations to these values that converges to the actual path lengths.

   • Initally, the algorithm set D⁰_{i ->j} = infty for i !=j and D⁰_{i ->i} = 0.

   • The algorithm then repeatedly sets

     Dⁿ⁺¹_{i ->j} = min_k ( d_{i ->k} + Dⁿ_{k ->j})

     until on some iteration nothing changes.

   • Note that his version of the Bellman-Ford algorithm differs from that in the book in several ways.

     • First, for now I'm assuming a sequential, centralized implementation. Shay presents a somewhat distributed version.

     • More importantly, the iteration step of the algorithm in the book is more accurately described by the formula:

       Dⁿ⁺¹_{i ->j} = min_k ( Dⁿ_{i ->k} + Dⁿ_{k ->j})

       That is, while the d_{i ->j} values are used to initialize the algorithm, they are not involved in the update process. While this may speed the initial convergence of the algorithm, it makes it unable to adjust to dynamic changes in the costs associated with network links.

3. The second algorithms is Dijkstra's algorithm which is also sometimes known as the "SPF" or Shortest Path First algorithm.

   • Now, imagine we select some node "s" (for source) and try to find the best paths from that source to all the nodes in the graph.

   • The trick to Dijkstra's algorithm is that it finds the shortest path from "s" to each other node in the graph by considering nodes in order of the length of their shortest path from s.

     • Once "s" is selected, we can order all the nodes of the graph by the values of the shortest path from "s" to each node. That is we will place node i before node j if D_{s ->i} < D_{s ->j}.

   • To get the job started, it is obvious that the cost of the minimal path from s to itself is 0. Therefore, the algorithm begins with s and simply declares that the shortest path from s to s is the null path with cost 0.

   • At any point as the algorithm proceeds it will have found the shortest paths to some subset of the graph's nodes, W. For each node, i, in W it will know D_{s ->i} The next step is to find the node in G-W whose distance from s is minimal.

   • Suppose the next node to be added is n. The minimal path from s to n can not contain any nodes in G-W other than n. If it did, then the length of the shotest path from s to that node would be less than the length of the shortest path from s to n (contradicting the assumption that n is the next node to add to W).

     So, to find "n", the algorithm only needs to consider paths contained completely in W except for the last step.

   • Therefore, rather than worrying about minimal path lengths as we go, what we can do is keep track of a value D^W_{s ->j} which will be the length of the shortest path from s to j using only nodes of W as intermediate nodes.

     • Initally (i.e. when W only contains s), D^W_{s ->j} = d_{s ->j} for all j.

     • Assuming we keep track of the values of D^W_{s ->j} as the algorithms proceeds then when we add a node "n" to W, all we need to do is set

       D^W_{s ->j} = min( D^W_{s ->j}, D^W_{s ->n} + d_{n ->j})

     • In fact, when we update the D^W values after adding n, we only need to consider those j that are neighbors of n. Thus, the total work required to update the values of D^W over the course of the algorithm is proportional to the number of edges.

     • Each time we add a node to W, we have to at most look at the D^W values of all but one node in the graph. So, the total cost of these additions to W will be proportional to the square of the number of nodes.

   • To determine the correct new node "n" to add to W at each step we simply search for the node in G-W with associated with the smallest D^W_{s ->n} value.

   • Note that in the process of finding the lengths of the shortest paths from s to each node, the algorithm is effectively building a spanning tree for the graph rooted at s. At each step, the edge from some node in W to the node n in W that is the last step in the minimum length path from s to n is part of this tree. The best path from s to any n is then the only path from s to n in the spanning tree.