CSC317 Shortest path algorithms So far we only looked at unweighted graphs. But what if we need to account for weights (and on top of it negative weights)? Definition of a shortest path problem: We are given a weighted graph G = (V,E) with a weight function mapping edges to real-valued values. The weight w(p) of path is the sum of the weights of its constituent weights We define the shortest path weight d(u,v) from u to v by if there exists a path from u to v otherwise A shortest path from u to v is then defined as any path with weight w(p) = d(u,v) CSC317

Variants: Single destination shortest path problem: Shortest paths to a given destination vertex t from each vertex v (what happens when we reverse edges?) Single pair shortest path problem: Shortest path from u to v for given u, v All pairs shortest path problem: Shortest path from u to v for all u, v Optimal substructure of shortest paths Shortest-paths algorithms typically rely on the property that a shortest path between two vertices contains other shortest paths within it (does that sound familiar?). Optimal substructure is one key element of dynamic programming and greedy algorithms. Dijkstra algorithm is a greedy algorithm Floyd-Warshall algorithm is a dynamic programming algorithm CSC317

CSC317 Negative weights: (what is the problem?) Dijkstra’s algorithm only works on positive weights Floyd-Warshall allows negative weights CSC317

CSC317 Can a shortest path contain a cycle? As we have just seen, it cannot contain a negative-weight cycle. Nor can it contain a positive-weight cycle, since removing the cycle from the path produces a path with the same source and destination vertices and a lower path weight. If is a path and is a positive weight cycle so that then vi = vj and w(c) > p then the path has weight w(p‘) = w(p) – w(c) < w(p) and so p cannot be a shortest path. That leaves only 0-weight cycles. We can remove a 0-weight cycle from any path to produce another path whose weight is the same. Thus, if there is a shortest path from a source vertex s to a destination vertex v that contains a 0-weight cycle, then there is another shortest path from s to v without this cycle. CSC317

CSC317 Dijkstra’s shortest path algorithm This algorithm finds a single source shortest path on a directed graph, with weights for the edges (for instance, weights could be driving distances between locations). This is a greedy algorithm, and the weights must be non negative (otherwise, for instance if we want to represent positive profit and negative loss, we can use a “cousin” algorithm, Bellman Ford, which we do not discuss here, and uses dynamic programming). Remember that Breadth First Search (BFS) also finds a shortest path, but in the case of unweighted edges. Dijkstra can be seen as a generalization of BFS. CSC317

The main idea is that we maintain a set of vertices S whose final shortest path lengths have already been determined. In each time we consider not yet discovered vertices in the graph, and all edges going from a discovered vertex (u) to an undiscovered vertex (v). We choose an undiscovered vertex with an edge from u to v, that gives the shortest path length. The length from u to v for each vertex v, is given by the length of u, plus the weight between u and v. In the initialization step, we just include source node s in the set of discovered nodes, and set its length to 0. All other lengths are initially infinity. Then we keep expanding set S of discovered nodes in a greedy manner. CSC317

CSC317

CSC317

In the figure, the black vertices at each step are those vertices added to set S. Initially, only s is in set S. s can go to t (length 10) or y (length 5), and y yields the shortest path. Now both s and y are in set S. We consider all possibilities from set S (vertices s and y) to other vertices. We already have the s to t (length 10) stored and we also look at y to t (5 + 3 = 8) y to z (5 + 2 = 7) and y to x (5 + 9) – 14. The shortest greedy choice is y to z (length 7), so now z is added to our set of discovered nodes S. And so on see figure below. CSC317

CSC317 Run time: We run through each node once. For each node we look into it’s adjacency list. If there are n nodes and m edges, we have the usual (n+m) number of operations. However, each operation takes time since we need to find the minimum among all possible edges. This can be done by extracting the minimum from a queue with each minimum taking O(lg n) time. As a consequence we have O((n+m)lg n) complexity. CSC317

CSC317 Bellman-Ford algorithm Given a weighted, directed graph G = (V, E) with source s and weight function the Bellman-Ford algorithm returns a boolean value indicating whether or not there is a negative-weight cycle that is reachable from the source. If there is such a cycle, the algorithm indicates that no solution exists. If there is no such cycle, the algorithm produces the shortest paths and their weights. CSC317

CSC317

Run time: O(EV) Θ(V) Θ(EV) O(E) CSC317