Shortest path with one skippable edge - graph

Question

I have this problem: "Shortest path with one skippable edge. Given an edge-weighted digraph, design an E*log(V) algorithm to find a shortest path from s to t where you can change the weight of any one edge to zero. Assume the edge weights are nonnegative."
I don't understand what they want me to do. What does it mean to change the weight to zero? I think that I can change any edge in any shortest path to zero and it will still be the shortest.

Answer 1

First use Dijkstra to find the length S(v) of shortest path from s to v for every vertex v. Then use Dijkstra to find the length T(v) of shortest path from v to t for every vertex v. Then for every edge (v, w) find the sum S(v) + T(w) by using the rules above. Finally, choose the minimum path.
Note: In this approach we nullify the edge (v,w) weight and find the shortest path through (v,w)

Answer 2

The problem is simple.
Suppose that you have a shortest path with one skippable edge, p = v1,...,vi,vi+1,...,vm
and (vi,vi+1) is a skipped edge
Obviously, a path(v1,...,vi) is a shortest path between v1 and vi
and a path(vi+1,...,vm) is a shortest path between vi+1 and vm
Define d(x,y) as the length of the shortest path between node x and node y
you can simply find d(s,x) and d(x,t) for all node x by dijkstra algorithm
and now we have to choose the skipped edge one by one.
In other words, the length of the shortest path with one skippable edge is
min( d(s,u) + d(v,t) ) for all edge (u,v) in the graph
and the time complexity is O(E log V) because of Dijkstra Algorithm

Answer 3

The previous answers seem to suppose that Dijkstra gives the shortest distance from every vertex to every vertex, but this is not the case.
If you execute Dijkstra only once, starting from s, you have the shortest path from s to every vertex.
To find the shortest distance from every vertex to t, it is necessary to execute Dijkstra again starting from t after reversing every edge of the graph.
The complete solution is:
1) Execute Dijkstra on the graph G starting from s to obtain the shortest distance T(v) between s and any v.
2) Reverse all the edges to obtain the reversed graph G'
3) Execute Dijkstra on the graph G' starting from t to obtain the shortest distance R(v) between t and any v.
4) The one to skip is the edge e(v1 --> v2) for which T(v1) + R(v2) is minimum.
5) The path to follow is a concatenation of the shortest path between s and v1 given by the first Dijkstra and the shortest path between v2 and t given by the second Dijkstra.

Answer 4

The existing answers are good and correct, but another idea that is more intuitive to me is to transform the graph and use a layered approach:
Create a copy of the graph G, and call it G'
For each edge (u, v) in G, create an edge (u, v') directed from u (in G) to v' (in G'), of weight 0.
Use any standard shortest path algorithm such as Dijkstra to compute the shortest path from s to t'.

Answer 5

I came across this question when I was doing the Princeton Algorithms course on Coursera. I get the accepted answer, but I came up with an approach that I think should provide the shortest path with one skipped edge from s to any other edge.
We'll use the following class to store weighted, directed edge info:
public class DirectedEdge implements Comparable<DirectedEdge> {
private int from;
private int to;
private double weight;
... boilerplate stuff...
However, we'll also add a decorator class:
public static class SkipPathEdge {
DirectedEdge directedEdge;
double longest;
public SkipPathEdge(DirectedEdge directedEdge, double longest) {
this.directedEdge = directedEdge;
this.longest = longest;
}
}
longest here representing the longest known segment of the shortest known path to the vertex.
The rest is pretty standard Djikstra's with an indexed minimum priority queue and all, but with a slightly modified relaxation method:
private void relax(EdgeWeightedDigraph G, int e) {
SkipPathEdge parentEdge = edgeTo[e];
for (DirectedEdge edge : G.adj(e)) {
double longest = Math.max(parentEdge.longest, edge.getWeight());
double adjustment = longest - parentEdge.longest;
SkipPathEdge childEdge = new SkipPathEdge(edge, longest);
int from = edge.getFrom(), to = edge.getTo();
if (distTo[to] > distTo[from] + edge.getWeight() - adjustment) {
distTo[to] = distTo[from] + edge.getWeight() - adjustment;
edgeTo[to] = childEdge;
if (minPQ.contains(to)) {
minPQ.changeKey(to, distTo[to]);
} else {
minPQ.addKey(to, distTo[to]);
}
}
}
}
And to clarify we initialize edgeTo[s] to new SkipPathEdge(null, 0); so we shouldn't ever run into a null parent edge.
I think this should work, unless there's something I'm not thinking of.