Once again, Robert Sedgewick provides a current and comprehensive introduction to important algorithms. The focus this time is on graph algorithms, which are increasingly critical for a wide range of applications, such as network connectivity, circuit design, scheduling, transaction processing, and resource allocation. This chapter, about shortest-paths algorithms, explains a simple operation known as relaxation

This chapter is from the book

Every path in a weighted digraph has an associated path weight, the value of which is the sum of the weights of that path's edges. This essential measure allows us to formulate such problems
as "find the lowest-weight path between two given vertices." These shortest-paths problems are the topic of this chapter. Not only are shortest-paths problems intuitive for many direct applications, but they also
take us into a powerful and general realm where we seek efficient algorithms to solve general problems that can encompass
a broad variety of specific applications.

Several of the algorithms that we consider in this chapter relate directly to various algorithms that we examined in Chapters 17 through 20. Our basic graph-search paradigm applies immediately, and several of the specific mechanisms that we used in Chapters 17 and 19 to address connectivity in graphs and digraphs provide the basis for us to solve shortest-paths problems.

For economy, we refer to weighted digraphs as networks. Figure 21.1 shows a sample network, with standard representations. We have already developed an ADT interface with adjacency-matrix and
adjacency-lists class implementations for networks in Section 20.1we just pass true as a second parameter when we call the constructor so that the class keeps one representation of each edge, precisely as
we did when deriving digraph representations in Chapter 19 from the undirected graph representations in Chapter 17 (see Programs 20.1 through 20.4).

As discussed at length in Chapter 20, we use references to abstract edges for weighted digraphs to broaden the applicability of our implementations. This approach
has certain implications that are different for digraphs than the ones that we considered for undirected graphs in Section 20.1 and are worth noting. First, since there is only one representation of each edge, we do not need to use the from method in the edge class (see Program 20.1) when using an iterator: In a digraph, e.from(v) is true for every edge reference e returned by an iterator for v. Second, as we saw in Chapter 19, it is often useful when processing a digraph to be able to work with its reverse graph, but we need a different approach
than that taken by Program 19.1, because that implementation creates edges to create the reverse, and we assume that a graph ADT whose clients provide references
to edges should not create edges on its own (see Exercise 21.3).

In applications or systems for which we need all types of graphs, it is a textbook exercise in software engineering to define
a network ADT from which ADTs for the unweighted undirected graphs of Chapters 17 and 18, the unweighted digraphs of Chapter 19, or the weighted undirected graphs of Chapter 20 can be derived (see Exercise 21.10).

When we work with networks, it is generally convenient to keep self-loops in all the representations. This convention allows
algorithms the flexibility to use a sentinel maximum-value weight to indicate that a vertex cannot be reached from itself.
In our examples, we use self-loops of weight 0, although positive-weight self-loops certainly make sense in many applications. Many applications also call for parallel
edges, perhaps with differing weights. As we mentioned in Section 20.1, various options for ignoring or combining such edges are appropriate in various different applications. In this chapter,
for simplicity, none of our examples use parallel edges, and we do not allow parallel edges in the adjacency-matrix representation;
we also do not check for parallel edges or remove them in adjacency lists.

All the connectivity properties of digraphs that we considered in Chapter 19 are relevant in networks. In that chapter, we wished to know whether it is possible to get from one vertex to another; in this chapter, we take weights into considerationwe wish to find the best way to get from one vertex to another.

Definition 21.1Ashortest pathbetween two vertices s and t in a network is a directed simple path from s to t with the property that no other such path
has a lower weight.

This definition is succinct, but its brevity masks points worth examining. First, if t is not reachable from s, there is no path at all, and therefore there is no shortest path. For convenience, the algorithms that we consider often
treat this case as equivalent to one in which there exists an infinite-weight path from s to t. Second, as we did for MST algorithms, we use networks where edge weights are proportional to edge lengths in examples, but
the definition has no such requirement and our algorithms (other than the one in Section 21.5) do not make this assumption. Indeed, shortest-paths algorithms are at their best when they discover counterintuitive shortcuts,
such as a path between two vertices that passes through several other vertices but has total weight smaller than that of a
direct edge connecting those vertices. Third, there may be multiple paths of the same weight from one vertex to another; we
typically are content to find one of them. Figure 21.2 shows an example with general weights that illustrates these points.

The restriction in the definition to simple paths is unnecessary in networks that contain edges that have nonnegative weight,
because any cycle in a path in such a network can be removed to give a path that is no longer (and is shorter unless the cycle
comprises zero-weight edges). But when we consider networks with edges that could have negative weight, the need for the restriction
to simple paths is readily apparent: Otherwise, the concept of a shortest path is meaningless if there is a cycle in the network
that has negative weight. For example, suppose that the edge 3-5 in the network in Figure 21.1 were to have weight -.38, and edge 5-1 were to have weight -.31. Then, the weight of the cycle 1-4-3-5-1 would be .32 + .36 - .38 - .31 = -.01, and we could spin around that cycle to generate arbitrarily short paths. Note carefully that, as is true in this example,
it is not necessary for all the edges on a negative-weight cycle to be of negative weight; what counts is the sum of the edge weights. For brevity, we use the term negative cycle to refer to directed cycles whose total weight is negative.

In the definition, suppose that some vertex on a path from s to t is also on a negative cycle. In this case, the existence of a (nonsimple) shortest path from s to t would be a contradiction, because we could use the cycle to construct a path that had a weight lower than any given value.
To avoid this contradiction, we restrict to simple paths in the definition so that the concept of a shortest path is well
defined in any network. However, we do not consider negative cycles in networks until Section 21.7, because, as we see there, they present a truly fundamental barrier to the solution of shortest-paths problems.

To find shortest paths in a weighted undirected graph, we build a network with the same vertices and with two edges (one in
each direction) corresponding to each edge in the graph. There is a one-to-one correspondence between simple paths in the
network and simple paths in the graph, and the costs of the paths are the same; so shortest-paths problems are equivalent.
Indeed, we build precisely such a network when we build the standard adjacency-lists or adjacency-matrix representation of
a weighted undirected graph (see, for example, Figure 20.3). This construction is not helpful if weights can be negative, because it gives negative cycles in the network, and we do
not know how to solve shortest-paths problems in networks that have negative cycles (see Section 21.7). Otherwise, the algorithms for networks that we consider in this chapter also work for weighted undirected graphs.

In certain applications, it is convenient to have weights on vertices instead of, or in addition to, weights on edges; and
we might also consider more complicated problems where both the number of edges on the path and the overall weight of the
path play a role. We can handle such problems by recasting them in terms of edge-weighted networks (see, for example, Exercise 21.4) or by slightly extending the basic algorithms (see, for example, Exercise 21.52).

Because the distinction is clear from the context, we do not introduce special terminology to distinguish shortest paths in
weighted graphs from shortest paths in graphs that have no weights (where a path's weight is simply its number of edgessee
Section 17.7). The usual nomenclature refers to (edge-weighted) networks, as used in this chapter, since the special cases presented by
undirected or unweighted graphs are handled easily by algorithms that process networks.

We are interested in the same basic problems that we defined for undirected and unweighted graphs in Section 18.7. We restate them here, noting that Definition 21.1 implicitly generalizes them to take weights into account in networks.

Sourcesink shortest path Given a start vertex s and a finish vertex t, find a shortest path in the graph from s to t. We refer to the start vertex as the source and to the finish vertex as the sink, except in contexts where this usage conflicts with the definition of sources (vertices with no incoming edges) and sinks
(vertices with no outgoing edges) in digraphs.

Single-source shortest paths Given a start vertex s, find shortest paths from s to each other vertex in the graph.

All-pairs shortest paths Find shortest paths connecting each pair of vertices in the graph. For brevity, we sometimes use the term all shortest paths to refer to this set of V2 paths.

If there are multiple shortest paths connecting any given pair of vertices, we are content to find any one of them. Since
paths have varying number of edges, our implementations provide methods that allow clients to trace paths in time proportional
to the paths' lengths. Any shortest path also implicitly gives us the shortest-path length, but our implementations explicitly
provide lengths. In summary, to be precise, when we say "find a shortest path" in the problem statements just given, we mean
"compute the shortest-path length and a way to trace a specific path in time proportional to that path's length."

Figure 21.3 illustrates shortest paths for the example network in Figure 21.1. In networks with V vertices, we need to specify V paths to solve the single-source problem and to specify V2 paths to solve the all-pairs problem. In our implementations, we use a representation more compact than these lists of paths;
we first noted it in Section 18.7, and we consider it in detail in Section 21.1.

In Java implementations, we build our algorithmic solutions to these problems into ADT implementations that allow us to build
efficient client programs that can solve a variety of practical graph-processing problems. For example, as we see in Section 21.3, we implement solutions to the all-pairs shortest-paths classes as constructors within classes that support constant-time
shortest-path queries. We also build classes to solve single-source problems so that clients who need to compute shortest
paths from a specific vertex (or a small set of them) can avoid the expense of computing shortest paths for other vertices.
Careful consideration of such issues and proper use of the algorithms that we examine can mean the difference between an efficient
solution to a practical problem and a solution that is so costly that no client could afford to use it.

Shortest-paths problems arise in various guises in numerous applications. Many of the applications appeal immediately to geometric
intuition, but many others involve arbitrary cost structures. As we did with minimum spanning trees (MSTs) in Chapter 20, we sometimes take advantage of geometric intuition to help develop an understanding of algorithms that solve the problems
but stay cognizant that our algorithms operate properly in more general settings. In Section 21.5, we do consider specialized algorithms for Euclidean networks. More important, in Sections 21.6 and 21.7, we see that the basic algorithms are effective for numerous applications where networks represent an abstract model of the
computation.

Road maps Tables that give distances between all pairs of major cities are a prominent feature of many road maps. We presume that the
map maker took the trouble to be sure that the distances are the shortest ones, but our assumption is not necessarily always
valid (see, for example, Exercise 21.11). Generally, such tables are for undirected graphs that we should treat as networks with edges in both directions corresponding
to each road, though we might contemplate handling one-way streets for city maps and some similar applications.

As we see in Section 21.3, it is not difficult to provide other useful information, such as a table that tells how to execute the shortest paths (see
Figure 21.4). In modern applications, embedded systems provide this kind of capability in cars and transportation systems. Maps are Euclidean
graphs; in Section 21.4, we examine shortest-paths algorithms that take into account the vertex position when they seek shortest paths.

Airline routes Route maps and schedules for airlines or other transportation systems can be represented as networks for which various shortest-paths
problems are of direct importance. For example, we might wish to minimize the time that it takes to fly between two cities
or to minimize the cost of the trip. Costs in such networks might involve functions of time, of money, or of other complicated
resources. For example, flights between two cities typically take more time in one direction than the other because of prevailing
winds. Air travelers also know that the fare is not necessarily a simple function of the distance between the citiessituations
where it is cheaper to use a circuitous route (or endure a stopover) than to take a direct flight are all too common. Such
complications can be handled by the basic shortest-paths algorithms that we consider in this chapter; these algorithms are
designed to handle any positive costs.

The fundamental shortest-paths computations suggested by these applications only scratch the surface of the applicability
of shortest-paths algorithms. In Section 21.6, we consider problems from applications areas that appear unrelated to these natural ones, in the context of a discussion
of reduction, a formal mechanism for proving relationships among problems. We solve problems for these applications by transforming them
into abstract shortest-paths problems that do not have the intuitive geometric feel of the problems just described. Indeed,
some applications lead us to consider shortest-paths problems in networks with negative weights. Such problems can be far
more difficult to solve than are problems where negative weights cannot occur. Shortest-paths problems for such applications
not only bridge a gap between elementary algorithms and unsolved algorithmic challenges but also lead us to powerful and general
problem-solving mechanisms.

As with MST algorithms in Chapter 20, we often mix the weight, cost, and distance metaphors. Again, we normally exploit the natural appeal of geometric intuition
even when working in more general settings with arbitrary edge weights; thus we refer to the "length" of paths and edges when
we should say "weight" and to one path as "shorter" than another when we should say that it "has lower weight." We also might
say that v is "closer" to s than w when we should say that "the lowest-weight directed path from s to v has weight lower than that of the lowest-weight directed path s to w," and so forth. This usage is inherent in the standard use of the term "shortest paths" and is natural even when weights
are not related to distances (see Figure 21.2); however, when we expand our algorithms to handle negative weights in Section 21.6, we must abandon such usage.

This chapter is organized as follows: After introducing the basic underlying principles in Section 21.1, we introduce basic algorithms for the single-source and all-pairs shortest-paths problems in Sections 21.2 and 21.3. Then, we consider acyclic networks (or, in a clash of shorthand terms, weighted DAGs) in Section 21.4 and ways of exploiting geometric properties for the sourcesink problem in Euclidean graphs in Section 21.5. We then cast off in the other direction to look at more general problems in Sections 21.6 and 21.7, where we explore shortest-paths algorithms, perhaps involving networks with negative weights, as a high-level problem-solving
tool.

Exercises

21.1 Label the following points in the plane 0 through 5, respectively:

Taking edge lengths to be weights, consider the network defined by the edges

Draw the network and give the adjacency-lists structure that is built by Program 20.5.

21.2 Show, in the style of Figure 21.3, all shortest paths in the network defined in Exercise 21.1.

21.3 Develop a network class implementation that represents the reverse of the weighted digraph defined by the edges inserted.
Include a "reverse copy" constructor that takes a graph as parameter and inserts all that graph's edges to build its reverse.

21.4 Show that shortest-paths computations in networks with nonnegative weights on both vertices and edges (where the weight of a path is defined to be the sum of the weights of the vertices and the edges on the
path) can be handled by building a network ADT that has weights on only the edges.

21.5 Find a large network onlineperhaps a geographic database with entries for roads that connect cities or an airline or railroad
schedule that contains distances or costs.

21.6 Write a random-network generator for sparse networks based on Program 17.12. To assign edge weights, define a random-edgeweight ADT and write two implementations: one that generates uniformly distributed
weights, another that generates weights according to a Gaussian distribution. Write client programs to generate sparse random
networks for both weight distributions with a well-chosen set of values of V and E so that you can use them to run empirical tests on graphs drawn from various distributions of edge weights.

21.7 Write a random-network generator for dense networks based on Program 17.13 and edge-weight generators as described in Exercise 21.6. Write client programs to generate random networks for both weight distributions with a well-chosen set of values of V and E so that you can use them to run empirical tests on graphs drawn from these models.

21.8 Implement a representation-independent network client that builds a network by taking edges with weights (pairs of integers
between 0 and V  1 with weights between 0 and 1) from standard input.

21.9 Write a program that generates V random points in the plane, then builds a network with edges (in both directions) connecting all pairs of points within a
given distance d of one another (see Exercise 17.74), setting each edge's weight to the distance between the two points that that edge connects. Determine how to set d so that the expected number of edges is E.

21.10 Write a base class and derived classes that implement ADTs for graphs that may be undirected or directed graphs, weighted
or unweighted, and dense or sparse.

21.11 The following table from a published road map purports to give the length of the shortest routes connecting the cities. It
contains an error. Correct the table. Also, add a table that shows how to execute the shortest routes, in the style of Figure 21.4.