143 lines
5.0 KiB
Java
143 lines
5.0 KiB
Java
|
|
|
|
import edu.princeton.cs.introcs.In;
|
|
import edu.princeton.cs.introcs.StdOut;
|
|
|
|
/*************************************************************************
|
|
* Compilation: javac AcyclicSP.java
|
|
* Execution: java AcyclicSP V E
|
|
* Dependencies: EdgeWeightedDigraph.java DirectedEdge.java Topological.java
|
|
* Data files: http://algs4.cs.princeton.edu/44sp/tinyEWDAG.txt
|
|
*
|
|
* Computes shortest paths in an edge-weighted acyclic digraph.
|
|
*
|
|
* % java AcyclicSP tinyEWDAG.txt 5
|
|
* 5 to 0 (0.73) 5->4 0.35 4->0 0.38
|
|
* 5 to 1 (0.32) 5->1 0.32
|
|
* 5 to 2 (0.62) 5->7 0.28 7->2 0.34
|
|
* 5 to 3 (0.61) 5->1 0.32 1->3 0.29
|
|
* 5 to 4 (0.35) 5->4 0.35
|
|
* 5 to 5 (0.00)
|
|
* 5 to 6 (1.13) 5->1 0.32 1->3 0.29 3->6 0.52
|
|
* 5 to 7 (0.28) 5->7 0.28
|
|
*
|
|
*************************************************************************/
|
|
|
|
/**
|
|
* The AcyclicSP class represents a data type for solving the
|
|
* single-source shortest paths problem in edge-weighted directed acyclic
|
|
* graphs (DAGs). The edge weights can be positive, negative, or zero.
|
|
*
|
|
* This implementation uses a topological-sort based algorithm.
|
|
* The constructor takes time proportional to V + E ,
|
|
* where V is the number of vertices and E is the number of edges.
|
|
* Afterwards, the distTo() and hasPathTo() methods take
|
|
* constant time and the pathTo() method takes time proportional to the
|
|
* number of edges in the shortest path returned.
|
|
*
|
|
* For additional documentation, see <a href="/algs4/44sp">Section 4.4</a> of
|
|
* Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.
|
|
*
|
|
* @author Robert Sedgewick
|
|
* @author Kevin Wayne
|
|
*/
|
|
public class AcyclicSP {
|
|
private double[] distTo; // distTo[v] = distance of shortest s->v path
|
|
private DirectedEdge[] edgeTo; // edgeTo[v] = last edge on shortest s->v path
|
|
|
|
|
|
/**
|
|
* Computes a shortest paths tree from s to every other vertex in
|
|
* the directed acyclic graph G .
|
|
* @param G the acyclic digraph
|
|
* @param s the source vertex
|
|
* @throws IllegalArgumentException if the digraph is not acyclic
|
|
* @throws IllegalArgumentException unless 0 ≤ s ≤ V - 1
|
|
*/
|
|
public AcyclicSP(EdgeWeightedDigraph G, int s) {
|
|
distTo = new double[G.V()];
|
|
edgeTo = new DirectedEdge[G.V()];
|
|
for (int v = 0; v < G.V(); v++)
|
|
distTo[v] = Double.POSITIVE_INFINITY;
|
|
distTo[s] = 0.0;
|
|
|
|
// visit vertices in toplogical order
|
|
Topological topological = new Topological(G);
|
|
if (!topological.hasOrder())
|
|
throw new IllegalArgumentException("Digraph is not acyclic.");
|
|
for (int v : topological.order()) {
|
|
for (DirectedEdge e : G.adj(v))
|
|
relax(e);
|
|
}
|
|
}
|
|
|
|
// relax edge e
|
|
private void relax(DirectedEdge e) {
|
|
int v = e.from(), w = e.to();
|
|
if (distTo[w] > distTo[v] + e.weight()) {
|
|
distTo[w] = distTo[v] + e.weight();
|
|
edgeTo[w] = e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the length of a shortest path from the source vertex s to vertex v .
|
|
* @param v the destination vertex
|
|
* @return the length of a shortest path from the source vertex s to vertex v ;
|
|
* Double.POSITIVE_INFINITY if no such path
|
|
*/
|
|
public double distTo(int v) {
|
|
return distTo[v];
|
|
}
|
|
|
|
/**
|
|
* Is there a path from the source vertex s to vertex v ?
|
|
* @param v the destination vertex
|
|
* @return true if there is a path from the source vertex
|
|
* s to vertex v , and false otherwise
|
|
*/
|
|
public boolean hasPathTo(int v) {
|
|
return distTo[v] < Double.POSITIVE_INFINITY;
|
|
}
|
|
|
|
/**
|
|
* Returns a shortest path from the source vertex s to vertex v .
|
|
* @param v the destination vertex
|
|
* @return a shortest path from the source vertex s to vertex v
|
|
* as an iterable of edges, and null if no such path
|
|
*/
|
|
public Iterable<DirectedEdge> pathTo(int v) {
|
|
if (!hasPathTo(v)) return null;
|
|
Stack<DirectedEdge> path = new Stack<DirectedEdge>();
|
|
for (DirectedEdge e = edgeTo[v]; e != null; e = edgeTo[e.from()]) {
|
|
path.push(e);
|
|
}
|
|
return path;
|
|
}
|
|
|
|
|
|
/**
|
|
* Unit tests the AcyclicSP data type.
|
|
*/
|
|
public static void main(String[] args) {
|
|
In in = new In(args[0]);
|
|
int s = Integer.parseInt(args[1]);
|
|
EdgeWeightedDigraph G = new EdgeWeightedDigraph(in);
|
|
|
|
// find shortest path from s to each other vertex in DAG
|
|
AcyclicSP sp = new AcyclicSP(G, s);
|
|
for (int v = 0; v < G.V(); v++) {
|
|
if (sp.hasPathTo(v)) {
|
|
StdOut.printf("%d to %d (%.2f) ", s, v, sp.distTo(v));
|
|
for (DirectedEdge e : sp.pathTo(v)) {
|
|
StdOut.print(e + " ");
|
|
}
|
|
StdOut.println();
|
|
}
|
|
else {
|
|
StdOut.printf("%d to %d no path\n", s, v);
|
|
}
|
|
}
|
|
}
|
|
}
|