Graph Problems So Far
A*: Same as Dijkstra’s but with h(v, goal) added to priority of each vertex.
Topological Sorting
What Problem solved by TS
Suppose we have tasks 0 through 7, where an arrow from v to w indicates that v must happen before w.
Valid orderings include: [0, 2, 1, 3, 5, 4, 7, 6], [2, 0, 3, 5, 1, 4, 6, 7], …
Idea/solution
Perform a DFS traversal from every vertex with indegree 0, NOT clearing markings in between traversals.
- Record DFS postorder in a list.
- [7, 4, 1, 3, 0, 6, 5, 2]
- Topological ordering is given by the reverse of that list (reverse postorder).
- [2, 5, 6, 0, 3, 1, 4, 7]
vertex with indegree 0:其实可以是任意点，最后的要求是，在进行多次“”postorder“”的DFS之后，图中所有的点都被mark。
Why this solution called Topological Sorting
- The reason it’s called topological sort: Can think of this process as sorting our nodes so they appear in an order consistent with edges, e.g. [2, 5, 6, 0, 3, 1, 4, 7]
- When nodes are sorted in diagram, arrows all point rightwards.
- When nodes are sorted in diagram, arrows all point rightwards.
Be aware, that when people say “Depth First Search”, they sometimes mean with restarts, and they sometimes mean without.For example, when we did DepthFirstPaths for reachability, we did not restart.For Topological Sort, we restarted from every vertex with indegree 0.
What is the runtime to find all vertices of indegree 0?
Interesting thing I did not tell you: You don’t have to.
ANother better topological sort algorithm:
- Run DFS from an arbitrary vertex.
- If not all marked, pick an unmarked vertex and do it again.
- Repeat until done.
A topological sort only exists if the graph is a directed acyclic graph (DAG).
For the graph below, there is NO possible ordering where all arrows are respected.
Shortest Paths on DAGs
If we allow negative edges, Dijkstra’s algorithm can fail.Now we try to come up with an algorithm for shortest paths on a DAG that works even if there are negative edges.
One simple idea: Visit vertices in topological order.
- On each visit, relax all outgoing edges.
- Each vertex is visited only when all possible info about it has been used
demo
Runtime of the DAG SPT Algorithm: Relax in Topological Order
-
First: We have to find a topological order, e.g. 031245. Runtime is O(V + E).
Second: We have to visit all the vertices in topological order, relaxing all edges as we go. Let’s see a demo -
Runtime for step 2 is also O(V + E).
Quick note: In office hours, someone asked, why isn’t it O(V*E), since we’re relaxing all edges from each vertex.
- Keep in mind that E is the TOTAL number of edges in the entire graph, not the number of edges per vertex, e.g. for graph below E = 8.
Summary So far
Demo
Code: Topological.java
Demo
Code: AcyclicSP.java
/******************************************************************************
* Compilation: javac AcyclicSP.java
* Execution: java AcyclicSP V E
* Dependencies: EdgeWeightedDigraph.java DirectedEdge.java Topological.java
* Data files: https://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 {@code 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.
* <p>
* This implementation uses a topological-sort based algorithm.
* The constructor takes Θ(<em>V</em> + <em>E</em>) time in the
* worst case, where <em>V</em> is the number of vertices and
* <em>E</em> is the number of edges.
* Each instance method takes Θ(1) time.
* It uses Θ(<em>V</em>) extra space (not including the
* edge-weighted digraph).
* <p>
* For additional documentation,
* see <a href="https://algs4.cs.princeton.edu/44sp">Section 4.4</a> of
* <i>Algorithms, 4th Edition</i> 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 {@code s} to every other vertex in
* the directed acyclic graph {@code G}.
* @param G the acyclic digraph
* @param s the source vertex
* @throws IllegalArgumentException if the digraph is not acyclic
* @throws IllegalArgumentException unless {@code 0 <= s < V}
*/
public AcyclicSP(EdgeWeightedDigraph G, int s) {
distTo = new double[G.V()];
edgeTo = new DirectedEdge[G.V()];
validateVertex(s);
for (int v = 0; v < G.V(); v++)
distTo[v] = Double.POSITIVE_INFINITY;
distTo[s] = 0.0;
// visit vertices in topological 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 {@code s} to vertex {@code v}.
* @param v the destination vertex
* @return the length of a shortest path from the source vertex {@code s} to vertex {@code v};
* {@code Double.POSITIVE_INFINITY} if no such path
* @throws IllegalArgumentException unless {@code 0 <= v < V}
*/
public double distTo(int v) {
validateVertex(v);
return distTo[v];
}
/**
* Is there a path from the source vertex {@code s} to vertex {@code v}?
* @param v the destination vertex
* @return {@code true} if there is a path from the source vertex
* {@code s} to vertex {@code v}, and {@code false} otherwise
* @throws IllegalArgumentException unless {@code 0 <= v < V}
*/
public boolean hasPathTo(int v) {
validateVertex(v);
return distTo[v] < Double.POSITIVE_INFINITY;
}
/**
* Returns a shortest path from the source vertex {@code s} to vertex {@code v}.
* @param v the destination vertex
* @return a shortest path from the source vertex {@code s} to vertex {@code v}
* as an iterable of edges, and {@code null} if no such path
* @throws IllegalArgumentException unless {@code 0 <= v < V}
*/
public Iterable<DirectedEdge> pathTo(int v) {
validateVertex(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;
}
// throw an IllegalArgumentException unless {@code 0 <= v < V}
private void validateVertex(int v) {
int V = distTo.length;
if (v < 0 || v >= V)
throw new IllegalArgumentException("vertex " + v + " is not between 0 and " + (V-1));
}
/**
* Unit tests the {@code AcyclicSP} data type.
*
* @param args the command-line arguments
*/
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);
}
}
}
}
Longest Paths
The Longest Paths Problem on DAGs
扫一扫
7211
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
