有向图的基本定义：由一组顶点和一组有向边组成，每条有向边连接着有序的一对顶点。
import java.util.InputMismatchException; import java.util.NoSuchElementException; public class Digraph { private final int V; // number of vertices in this digraph private int E; // number of edges in this digraph private Bag<Integer>[] adj; // adj[v] = adjacency list for vertex v private int[] indegree; // indegree[v] = indegree of vertex v public Digraph(int V) { if (V < 0) throw new IllegalArgumentException("Number of vertices in a Digraph must be nonnegative"); this.V = V; this.E = 0; indegree = new int[V]; adj = (Bag<Integer>[]) new Bag[V]; for (int v = 0; v < V; v++) { adj[v] = new Bag<Integer>(); } } public int V() { return V; } public int E() { return E; } public void addEdge(int v, int w) { validateVertex(v); validateVertex(w); adj[v].add(w); indegree[w]++; E++; } public Iterable<Integer> adj(int v) { validateVertex(v); return adj[v]; } public int outdegree(int v) { validateVertex(v); return adj[v].size(); } public int indegree(int v) { validateVertex(v); return indegree[v]; } public Digraph reverse() { Digraph reverse = new Digraph(V); for (int v = 0; v < V; v++) { for (int w : adj(v)) { reverse.addEdge(w, v); } } return reverse; } }
有向路径由一系列顶点组成，对于其中的每个顶点都存在有向边从它指向序列中的下个顶点。
有向环：一条至少含有一条边且起点和重点相同的有向路径。
有向图的可达性
单点可达性问题给定一幅有向图和一个起点s，回答是否存在一条从s到给定顶点v的有向路径。
多点可达性给定一幅有向图图和顶点的集合，回答是否存在一条从集合中的任意顶点到达给定顶点V的有向路径。
public class DirectedDFS { private boolean[] marked; // marked[v] = true if v is reachable // from source (or sources) private int count; // number of vertices reachable from s public DirectedDFS(Digraph G, int s) { marked = new boolean[G.V()]; dfs(G, s); } public DirectedDFS(Digraph G, Iterable<Integer> sources) { marked = new boolean[G.V()]; for (int v : sources) { if (!marked[v]) dfs(G, v); } } private void dfs(Digraph G, int v) { count++; marked[v] = true; for (int w : G.adj(v)) { if (!marked[w]) dfs(G, w); } } public boolean marked(int v) { return marked[v]; } public int count() { return count; } }
有向无环图（DAG）：就是一幅不含有环的有向图。
public class DirectedCycle { private boolean[] marked; // marked[v] = has vertex v been marked? private int[] edgeTo; // edgeTo[v] = previous vertex on path to v private boolean[] onStack; // onStack[v] = is vertex on the stack? private Stack<Integer> cycle; // directed cycle (or null if no such cycle) public DirectedCycle(Digraph G) { marked = new boolean[G.V()]; onStack = new boolean[G.V()]; edgeTo = new int[G.V()]; for (int v = 0; v < G.V(); v++) if (!marked[v] && cycle == null) dfs(G, v); } private void dfs(Digraph G, int v) { onStack[v] = true; marked[v] = true; for (int w : G.adj(v)) { // short circuit if directed cycle found if (cycle != null) return; // found new vertex, so recur else if (!marked[w]) { edgeTo[w] = v; dfs(G, w); } // trace back directed cycle else if (onStack[w]) { cycle = new Stack<Integer>(); for (int x = v; x != w; x = edgeTo[x]) { cycle.push(x); } cycle.push(w); cycle.push(v); assert check(); } } onStack[v] = false; } public boolean hasCycle() { return cycle != null; } public Iterable<Integer> cycle() { return cycle; } }
有向图的拓扑排序： 对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若<u，v> ∈E(G)，则u在线性序列中出现在v之前。 通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列，简称拓扑序列。
public class Topological { private Iterable<Integer> order; // topological order private int[] rank; // rank[v] = position of vertex v in topological order public Topological(EdgeWeightedDigraph G) { EdgeWeightedDirectedCycle finder = new EdgeWeightedDirectedCycle(G); if (!finder.hasCycle()) { DepthFirstOrder dfs = new DepthFirstOrder(G); order = dfs.reversePost(); } } public Iterable<Integer> order() { return order; } public boolean hasOrder() { return order != null; } public int rank(int v) { if (hasOrder()) return rank[v]; else return -1; } }
有向图中基于深度优先搜索的顶点排序:
public class DepthFirstOrder { private boolean[] marked; // marked[v] = has v been marked in dfs? private int[] pre; // pre[v] = preorder number of v private int[] post; // post[v] = postorder number of v private Queue<Integer> preorder; // vertices in preorder private Queue<Integer> postorder; // vertices in postorder private int preCounter; // counter or preorder numbering private int postCounter; // counter for postorder numbering public DepthFirstOrder(EdgeWeightedDigraph G) { pre = new int[G.V()]; post = new int[G.V()]; postorder = new Queue<Integer>(); preorder = new Queue<Integer>(); marked = new boolean[G.V()]; for (int v = 0; v < G.V(); v++) if (!marked[v]) dfs(G, v); } private void dfs(EdgeWeightedDigraph G, int v) { marked[v] = true; pre[v] = preCounter++; preorder.enqueue(v); for (DirectedEdge e : G.adj(v)) { int w = e.to(); if (!marked[w]) { dfs(G, w); } } postorder.enqueue(v); post[v] = postCounter++; } public int pre(int v) { return pre[v]; } public int post(int v) { return post[v]; } public Iterable<Integer> post() { return postorder; } public Iterable<Integer> pre() { return preorder; } public Iterable<Integer> reversePost() { Stack<Integer> reverse = new Stack<Integer>(); for (int v : postorder) reverse.push(v); return reverse; } }
顶点可达性问题：是否存在一条从给定顶点V到另一个给定顶点W的路径。
强连通性：如果两个顶点V和W是互相可达的，则称它们为强连通。强连通具有以下性质：
- 自反性：任意顶点V和自己都是强连通的。
- 对称性：如果V和W是强连通的，那么W和V也是强连通的。
- 传递性：如果V和W是强连通的且W和X是强连通的，那么V和X是强连通的。
强连通分量：每个部分都是互为强连通的顶点的最大子集组成。
Kosaraju算法
/****************************************************************************** * Compilation: javac KosarajuSharirSCC.java * Execution: java KosarajuSharirSCC filename.txt * Dependencies: Digraph.java TransitiveClosure.java StdOut.java In.java * Data files: http://algs4.cs.princeton.edu/42digraph/tinyDG.txt * * Compute the strongly-connected components of a digraph using the * Kosaraju-Sharir algorithm. * * Runs in O(E + V) time. * * % java KosarajuSCC tinyDG.txt * 5 components * 1 * 0 2 3 4 5 * 9 10 11 12 * 6 8 * 7 * * % java KosarajuSharirSCC mediumDG.txt * 10 components * 21 * 2 5 6 8 9 11 12 13 15 16 18 19 22 23 25 26 28 29 30 31 32 33 34 35 37 38 39 40 42 43 44 46 47 48 49 * 14 * 3 4 17 20 24 27 36 * 41 * 7 * 45 * 1 * 0 * 10 * * % java -Xss50m KosarajuSharirSCC mediumDG.txt * 25 components * 7 11 32 36 61 84 95 116 121 128 230 ... * 28 73 80 104 115 143 149 164 184 185 ... * 38 40 200 201 207 218 286 387 418 422 ... * 12 14 56 78 87 103 216 269 271 272 ... * 42 48 112 135 160 217 243 246 273 346 ... * 46 76 96 97 224 237 297 303 308 309 ... * 9 15 21 22 27 90 167 214 220 225 227 ... * 74 99 133 146 161 166 202 205 245 262 ... * 43 83 94 120 125 183 195 206 244 254 ... * 1 13 54 91 92 93 106 140 156 194 208 ... * 10 39 67 69 131 144 145 154 168 258 ... * 6 52 66 113 118 122 139 147 212 213 ... * 8 127 150 182 203 204 249 367 400 432 ... * 63 65 101 107 108 136 169 170 171 173 ... * 55 71 102 155 159 198 228 252 325 419 ... * 4 25 34 58 70 152 172 196 199 210 226 ... * 2 44 50 88 109 138 141 178 197 211 ... * 57 89 129 162 174 179 188 209 238 276 ... * 33 41 49 119 126 132 148 181 215 221 ... * 3 18 23 26 35 64 105 124 157 186 251 ... * 5 16 17 20 31 47 81 98 158 180 187 ... * 24 29 51 59 75 82 100 114 117 134 151 ... * 30 45 53 60 72 85 111 130 137 142 163 ... * 19 37 62 77 79 110 153 352 353 361 ... * 0 68 86 123 165 176 193 239 289 336 ... * ******************************************************************************/ /** * The <tt>KosarajuSharirSCC</tt> class represents a data type for * determining the strong components in a digraph. * The <em>id</em> operation determines in which strong component * a given vertex lies; the <em>areStronglyConnected</em> operation * determines whether two vertices are in the same strong component; * and the <em>count</em> operation determines the number of strong * components. * The <em>component identifier</em> of a component is one of the * vertices in the strong component: two vertices have the same component * identifier if and only if they are in the same strong component. * <p> * This implementation uses the Kosaraju-Sharir algorithm. * The constructor takes time proportional to <em>V</em> + <em>E</em> * (in the worst case), * where <em>V</em> is the number of vertices and <em>E</em> is the number of edges. * Afterwards, the <em>id</em>, <em>count</em>, and <em>areStronglyConnected</em> * operations take constant time. * For alternate implementations of the same API, see * {@link TarjanSCC} and {@link GabowSCC}. * <p> * For additional documentation, * see <a href="http://algs4.cs.princeton.edu/42digraph">Section 4.2</a> of * <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne. * * @author Robert Sedgewick * @author Kevin Wayne */ public class KosarajuSharirSCC { private boolean[] marked; // marked[v] = has vertex v been visited? private int[] id; // id[v] = id of strong component containing v private int count; // number of strongly-connected components /** * Computes the strong components of the digraph <tt>G</tt>. * @param G the digraph */ public KosarajuSharirSCC(Digraph G) { // compute reverse postorder of reverse graph DepthFirstOrder dfs = new DepthFirstOrder(G.reverse()); // run DFS on G, using reverse postorder to guide calculation marked = new boolean[G.V()]; id = new int[G.V()]; for (int v : dfs.reversePost()) { if (!marked[v]) { dfs(G, v); count++; } } // check that id[] gives strong components assert check(G); } // DFS on graph G private void dfs(Digraph G, int v) { marked[v] = true; id[v] = count; for (int w : G.adj(v)) { if (!marked[w]) dfs(G, w); } } /** * Returns the number of strong components. * @return the number of strong components */ public int count() { return count; } /** * Are vertices <tt>v</tt> and <tt>w</tt> in the same strong component? * @param v one vertex * @param w the other vertex * @return <tt>true</tt> if vertices <tt>v</tt> and <tt>w</tt> are in the same * strong component, and <tt>false</tt> otherwise */ public boolean stronglyConnected(int v, int w) { return id[v] == id[w]; } /** * Returns the component id of the strong component containing vertex <tt>v</tt>. * @param v the vertex * @return the component id of the strong component containing vertex <tt>v</tt> */ public int id(int v) { return id[v]; } // does the id[] array contain the strongly connected components? private boolean check(Digraph G) { TransitiveClosure tc = new TransitiveClosure(G); for (int v = 0; v < G.V(); v++) { for (int w = 0; w < G.V(); w++) { if (stronglyConnected(v, w) != (tc.reachable(v, w) && tc.reachable(w, v))) return false; } } return true; } /** * Unit tests the <tt>KosarajuSharirSCC</tt> data type. */ public static void main(String[] args) { In in = new In(args[0]); Digraph G = new Digraph(in); KosarajuSharirSCC scc = new KosarajuSharirSCC(G); // number of connected components int m = scc.count(); StdOut.println(m + " components"); // compute list of vertices in each strong component Queue<Integer>[] components = (Queue<Integer>[]) new Queue[m]; for (int i = 0; i < m; i++) { components[i] = new Queue<Integer>(); } for (int v = 0; v < G.V(); v++) { components[scc.id(v)].enqueue(v); } // print results for (int i = 0; i < m; i++) { for (int v : components[i]) { StdOut.print(v + " "); } StdOut.println(); } } }